Java06 面向对象
2024-10-21 13:00:58
一 什么是面向对象
面向对象编程（Object-Oriented Programming,OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象组织（封装）数据。
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
二，回顾方法
1，方法的定义：
- 修饰符
- 返回类型
- break和return的区别。（break跳出循环switch；return结束方法，返回结果）
- 方法名：驼峰命名法
- 参数列表：（参数类型 参数名）
- 异常抛出
修饰符 返回值类型 方法名（...）{
方法体
return 返回值；
}
public class demo01 {
public static void main(String[] args) {
}
public String sayHello(){
return "Hello,World!"; // 返回值必须和定义的类型一致string
}
public int max(int a,int b){
return a>b?a:b; // 三元运算符
}
public void print(){
return; // 返回值为空
}
}
2，方法的调用：
- 静态方法和非静态方法
package oop;
public class demo02 {
public static void main(String[] args) {
Student.say(); // 静态方法直接调用
//非静态方法的调用
Student stu = new Student(); // 非静态方法需要先进行实例化类
stu.sayHello(); // 调用
}
}
----------------------------------------------
package oop;
// 学生类
public class Student {
// 静态方法，是和类一起加载的
public static void say(){
System.out.println("学生说话");
}
// 非静态方法，类实例化之后才存在
public void sayHello(){
System.out.println("HelloWorld!");
}
}
- 形参和实参
public class Demo03 {
public static void main(String[] args) {
// 实际参数和形式参数的类型要一致
int sum = Demo03.add(1,2);
System.out.println(sum);
}
public static int add(int a,int b){
return a+b;
}
}
- 值传递和引用传递
// 值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a); // 结果为1
Demo04.change(a);
System.out.println(a); // 结果还是为1
}
// 返回值为空void
public static void change(int a){
a = 10;
}
}
// 引用传递：对象
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); // 值为Null
Demo05.change(person);
System.out.println(person.name); // 结果为admin
}
public static void change(Person person){
// person是一个对象，可以改变值
person.name = "admin";
}
}
class Person{
String name;
}
三，类与对象的创建
1，类和对象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 对象是抽象概念的具体事例
2，创建与初始化对象
使用关键字new创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 1，必须和类的名字相同
- 2，必须没有返回类型，也不能写void
package oop.Demo02;
public class Application {
// 一个项目应该只有一个main()方法
public static void main(String[] args) {
// 类是抽象的，需要实例化，类实例化后会返回一个自己的对象
Student stu = new Student(); // stu对象就是类Student的一个具体实例
Student xm = new Student(); //可以创建不同的实例
Student xh = new Student();
xm.name = "小明"; // 给对象实例的属性赋值
xm.age = 16;
System.out.println(xm.name);
System.out.println(xm.age);
System.out.println(xh.name);
System.out.println(xh.age);
}
}
package oop.Demo02;
// 学生类
public class Student {
// 属性:字段
String name;
int age;
// 方法
public void study(){
System.out.println(this.name+"在学习");
}
}
四，构造器详解
- 构造器的方法名和类名相同
- 默认没有返回值
- new本质是在调用构造器方法
- 用于初始化对象的值
- 如果定义了有参数的构造器方法，必须显式的定义一个无参数的构造器方法
package oop.Demo02;
public class Application {
// 一个项目应该只有一个main()方法
public static void main(String[] args) {
Person student = new Person(); // new实例化一个对象
System.out.println(student.name); // 输出无参数构造器默认值student
Person teacher = new Person("teacher"); // 传入参数
System.out.println(teacher.name); // 使用带参数的构造器
}
}
package oop.Demo02;
public class Person {
// 一个类即使什么都不写，也会存在一个方法（构造器），给初始值Null
String name;
// 可以显式的定义构造器，用于实例化初始值（方法名和类名相同）
public Person(){
this.name = "student";
}
// 如果定义了下方有参数的构造器，就必须定义上方的无参数构造器
public Person(String name){
this.name = name;
}
}
五、封装
该露的露，该藏的藏
我们程序设计要追求”高内聚，低耦合“，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合就是仅暴露少量的方法给外部使用。封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。记住这句话就够了：属性私有，get/set
可以通过Alt+Insert快捷键，选择“Getter and Setter"，可以快速生成get/set方法。
package oop.Demo04;
import oop.Demo04.Student;
public class Application {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("student"); // 设置属性
System.out.println(stu1.getName()); // 获取属性
}
}
package oop.Demo04;
public class Student {
// 属性私有
private String name;
private int age;
private char sex;
// 提供外部可以操作的方法
// get 获取属性
public String getName(){
return this.name;
}
// set 设置属性
public void setName(String name){
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120 || age<0){
this.age = 3;
}
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
六、继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是扩展，子类是父类的扩展。
JAVA中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有 is a 的关系。
package oop.Demo05;
public class Person {
public int money = 10_0000_0000;
public void say() {
System.out.println("说了一句话");
}
}
package oop.Demo05;
public class Student extends Person {
}
package oop.Demo05;
public class Application {
public static void main(String[] args) {
Student stu = new Student();
stu.say(); // 继承了父类的方法
System.out.println(stu.money); //继承了父类的公共属性
}
}
object类，所有类都默认继承了object类，（ Ctrl + H 快捷键，可以看到类的树形结构。）
super
- super调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中
- super和this 不能同时调用构造方法
- VS this：
- this：本身调用者这个对象
- super：代表父类对象的应用
- 前提：
- this：没有继承也可以使用
- super：只能在继承条件才可以使用
- 构造方法：
- this()：本类的构造
- super()：父类的构造
package oop.Demo05;
public class Application {
public static void main(String[] args) {
Student stu = new Student();
//stu.test("test");
stu.test1();
}
}
package oop.Demo05;
public class Person {
protected String name = "person";
public void print(){
System.out.println("person");
}
}
package oop.Demo05;
public class Student extends Person {
private String name = "student";
public void test1(){
print();
this.print(); // 子类的方法
super.print(); // 父类的方法
}
public void test(String name){
System.out.println(name);
System.out.println(this.name); // 子类的属性
System.out.println(super.name); // 父类的属性
}
public void print(){
System.out.println("student");
}
}
方法重写
- 重写需要有继承关系，子类重写父类的方法
- 重写都是方法的重写
- 子类和父类的方法名必须相同，方法体可以不同
- 参数列表必须相同，否则是方法重载
- 修饰符：范围可以扩大，public > protected > default > private
- 抛出的异常：范围可以被缩小，不能扩大
- 静态方法stacic *
ackage oop.Demo05;
public class Application {
public static void main(String[] args) {
// 静态方法，方法的调用只和左边定义的数据类型有关
A a = new A();
a.test(); // 输出结果A-test()
// 父类的引用指向了子类
B b = new A();
b.test(); // 输出结果B-test()
}
}
package oop.Demo05;
public class A extends B{
public static void test(){
System.out.println("A->test()");
}
}
package oop.Demo05;
public class B {
public static void test(){
System.out.println("B->test()");
}
}
- 非静态方法，子类重写了父类的方法 *
package oop.Demo05;
public class Application {
public static void main(String[] args) {
// 方法的调用只和左边定义的数据类型有关
A a = new A();
a.test(); // 输出结果A-test()
// 父类的引用指向了子类
B b = new A();
b.test(); // 输出结果也是A-test()
}
}
package oop.Demo05;
public class A extends B{
public void test(){
System.out.println("A->test()");
}
}
package oop.Demo05;
public class B {
public void test(){
System.out.println("B->test()");
}
}
七、多态
同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用类型有多种
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
多态注意事项：
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系
- 存在的条件：继承关系，方法需要重写，父类引用指向子类对象
- static方法，属于类，不属于实例，不能重写方法
- final属于常量，也不能重写方法
- private私有的，也不能重写
package oop.Demo06;
public class Application {
public static void main(String[] args) {
// 一个对象的实际类型是确定的，右边new，而左侧的引用类型可以不确定
Student s1 = new Student();
Person s2 = new Student(); // 父类的引用指向子类，new子类
// 对象能执行哪些方法，与左侧引用有关
s2.run(); // 引用父类中的run方法，子类重写了父类的方法，则执行子类的方法
s1.run();
s1.eat();
// s2.eat();Person s2不能调用子类独有的eat方法
}
}
package oop.Demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package oop.Demo06;
public class Student extends Person{
// 重写父类的方法
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
1. instanceof
package oop.Demo06;
public class Application {
public static void main(String[] args) {
// Object > Person > Student
// Object > Person > Teacher
// Object > String
// System.out.println(x instanceof y); // x 和 y 之间是否存在父子关系
Object object = new Student();
System.out.println(object instanceof Student); // true
System.out.println(object instanceof Person); // true
System.out.println(object instanceof Object); // true
System.out.println(object instanceof Teacher); // false
System.out.println(object instanceof String); // false
System.out.println("==================");
Person person = new Student();
System.out.println(person instanceof Student); // true
System.out.println(person instanceof Person); // true
System.out.println(person instanceof Object); // true
System.out.println(person instanceof Teacher); // false
// System.out.println(person instanceof String); // 没有关系，编译报错
System.out.println("====================");
Student student = new Student();
System.out.println(student instanceof Student); // true
System.out.println(student instanceof Person); // true
System.out.println(student instanceof Object); // true
// System.out.println(student instanceof Teacher); // 没有关系，编译报错
// System.out.println(person instanceof String); // 没有关系，编译报错
}
}
package oop.Demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package oop.Demo06;
public class Teacher extends Person{
}
package oop.Demo06;
public class Student extends Person{
}
2. 类型转换
- 父类引用指向子类的对象
- 把子类转换为父类，向下转换
- 把父类转换为子类，向下转换，强制转换
- 方便方法的调用，减少重复代码
package oop.Demo06;
public class Application {
public static void main(String[] args) {
// 类型之间的转换
Person obj = new Student(); // obj是Person类型
// 将obj转换为Student类型
Student student = (Student)obj;
student.go();
// 或者
((Student)obj).go();
}
}
package oop.Demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package oop.Demo06;
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
3、static关键字
package oop.Demo07;
public class Student {
private static int age; // 静态变量
private double score; // 非静态变量
// 非静态方法
public void run(){
}
// 静态方法
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(age); // 静态变量可以直接用
System.out.println(s1.score); // 非静态变量不能直接用
go(); // 可以直接使用静态方法
s1.run(); // 非静态方法不能直接用
}
}
package oop.Demo07;
public class Person {
{
System.out.println("匿名代码块，用来赋初始值");
}
static {
System.out.println("静态代码块，只执行一次"); // 静态代码块，只会执行一次
}
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person(); // 第一次可以执行静态代码块
System.out.println("=============");
Person person2 = new Person(); // 不会再执行静态代码块
}
}
八、抽象类
abstract修饰符可以用来修饰方法，也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，该方法就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用 new 关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类，没有实现的抽象方法，否则该子类也要声明为抽象类。
特点：
- 不能new这个抽象类，只能靠子类去实现抽象类中的方法
- 抽象类中可以写普通的方法
- 抽象方法必须在抽象类中
package oop.Demo08;
// 抽象类
public abstract class Action {
// 抽象方法，只有方法名，没有方法体
public abstract void run();
}
package oop.Demo08;
// 抽象类的子类，必须实现父类的所有方法
public class A extends Action{
public void run(){
}
}
九、接口
声明类的关键字是 class，声明接口的关键字是 interface
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是……则必须能……”的思想。如果你是汽车，则必须能跑。
接口的本质是契约，就像法律一样，指定好后大家都要遵守。
面向对象（OO）的精髓，是对对象的抽象，最能体现这一点的就是接口。
1.接口的作用：
- 约束
- 定义一些方法，让不同的人实现
- 接口中的方法默认都是 public abstract
- 接口中的变量默认都是 public static final
- 接口不能被实例化，接口中没有构造方法
- 接口可以实现多个继承，implements关键字
- 必须要重写接口中的方法
package oop.Demo09;
//定义接口
public interface User {
void run(String name);
void add(String name);
void update(String name);
void delete(String name);
}
package oop.Demo09;
public interface Time {
void timer();
}
package oop.Demo09;
// 实现接口 implemets 接口名 (可以继承多个接口)
public class UserImpl implements User,Time{
// 实现了接口的类，九必须重写接口中的方法
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void run(String name) {
}
@Override
public void update(String name) {
}
@Override
public void timer() {
}
}
十、内部类
内部类就是在一个类的内部，再定义一个类，比如A类中定义一个B类，那么B类相对A类来说，就是内部类，而A类相对B类来说就是外部类。
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
package oop.Demo10;
public class Application {
public static void main(String[] args) {
Outer out = new Outer(); // 实例化外部类
Outer.Inner in = out.new Inner(); // 实例化内部类
in.getID(); //
}
}
package oop.Demo10;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
// 内部类
public class Inner{
public void In(){
System.out.println("这是内部类的方法");
}
// 获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
public void method(){
// 方法中的局部内部类
class A{
}
}
}
// 一个类文件中只能有一个public类
class B{
}
最新文章
- 2016年12-09php函数
- std::function赋值的几种方法
- MySQL压测中遇到的一些问题
- struts中调用servlet的两种方法——IcC方式和非IoC方式的代码demo
- Codeforces 526E Transmitting Levels
- Centos rsync文件同步配置
- java利用反射获取类的属性及类型
- vue-roter2 路由传参
- C# 根据路径删除文件或文件夹
- Error fetching https://gems.ruby-china.org/: bad response Not Found 404 (https://gems.ruby-china.org/specs.4.8.gz) 报错解决办法
- tomcat部署jfinal项目
- centos7 安装memcached
- WireShark如何抓取本地localhost的包
- java中获取字母和数字的组合
- MySQL中的三中循环 while 、 loop 、repeat 求 1~n 的和
- 【咸鱼教程】Base64
- Jenkins远程测试
- bzoj 3073: [Pa2011]Journeys -- 线段树优化最短路
- Object-C—集合
- mangodb驱动编译