Java 面向对象 OOP

面向对象

本质

OOP以类的方式组织代码，以对象的形式组织（封装）数据。

特征

抽象

抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和
行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节
是什么。

封装

​ 该藏的藏，该露的露。禁止直接访问一个对象中数据的实际表示，而是通过操作接口来访问，就是所谓信息隐藏，例如：int age;用private修饰，获取时用get/set方法。

class Person{
    private int age;
    public int getAge(){
        return this.age;
    }
    public void setAge(int age){
        this.age=age;
    }
}

继承

继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。

class Person{
    
}
class Student extends Person{
    
}

注：

​ private修饰的属性和方法无法继承

​ Java只有单继承

​ 调用父类的构造器super要放第一行

​ this和super不能同时调用构造方法

​ super()只能在继承条件下可以使用，只能出现在子类的方法或构造方法中

​ instanceof操作符(判断一个对象是否是某个类的对象)

class Person{
}
class Student extends Person {
}
class Teacher extends Person {
}
public class Main {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof Object);//true
        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 Teacher);//false
        System.out.println(person instanceof Object);//true
//        System.out.println(person instanceof String);//编译报错，instanceof两个参数不能毫无关系，如Person和String
        System.out.println("======================");
        Person person2 = new Person();
        System.out.println(person2 instanceof Student);//false
        System.out.println(person2 instanceof Person);//true
        System.out.println(person2 instanceof Teacher);//false
        System.out.println(person2 instanceof Object);//true
    }
}

多态

​ 含义：同一方法可以根据发送对象的不同而采用多种不同的行为方式。
分为编译时多态和运行时多态。方法重载（overload）实现的是编译时的多态性。运行时多态创造条件：继承条件，子类重写父类方法(static、final、private方法不能重写)，父类引用指向子类对象

class Person{
    public void work() {
        System.out.println("吃");
    }
}
class Student extends Person{
    @Override
    public void work() {
        System.out.println("读书");
    }

}
class Teacher extends Person{
    @Override
    public void work(){
        System.out.println("教书");
    }
}
public class Main{

    public static void main(String[] args){
        Person p0=new Person();
        Person p1=new Student();
        Person p2=new Teacher();
        //三个都是Person类对象，但调用的行为不一样
        p0.work();
        p1.work();
        p2.work();
    }
}

结果

吃
读书
教书