Java—— 一篇文章学会面向对象的三大特征

封装

什么是封装

告诉我们如何正确设计对象的属性和方法。

原则:对象代表什么，就得封装对应的数据，并提供数据对应的行为

举例：

人画圆，对象是圆不是人，所以要封装圆的数据，提供画圆的方法 

public class Circle {
    double radius;

    public void draw(){
        System.out.println("根据半径"+ radius +"画一个圆");
    }

}

封装思想的好处

让编程变得很简单，有什么事，找对象，调方法就行，降低我们的学习成本。

例如String对象封装了字符串的属性，提供了字符串的方法，以供我们使用。

标准的JavaBean类

1.类名需要见名知意
2.成员变量使用private修饰
3. 提供至少两个构造方法：无参构造方法 ，带全部参数的构造方法
4.成员方法
提供每一个成员变量对应的setXxx()/getXxx()
如果还有其他方法，也需要写上 

public class Student {
    private String name;
    private int age;
    
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void study(){
        System.out.println("学习");
    }
}

继承

什么是继承

继承让类跟类之间产生父子的关系。

继承的格式

Java中提供一个关键字extends，用这个关键字可以让一个类和另一个类建立起继承关系。
public class Student extends Person { }
Student称为子类(派生类)，Person称为父类(基类或超类)。

使用继承的好处

可以把多个子类中重复的代码抽取到父类中了，提高代码的复用性。
子类可以在父类的基础上，增加其他的功能，使子类更强大。

什么时候用继承

当类与类之间，存在相同(共性)的内容，并满足子类是父类中的一种，就可以考虑使用继承来优化代码

继承的特点

1. Java只能单继承:一个类只能继承一个直接父类。
2. Java不支持多继承、但是支持多层继承。子类A继承父类B，父类B可以继承父类C
3. Java中所有的类都直接或者间接继承于Object类。

子类到底能继承父类中的哪些内容

注：只有非private，非static，非final修饰的虚方法才可以被继承，存在一个虚方法表，记录从最高父类Object到最低子类的所有虚方法，如果有重复的方法会被重写覆盖。

继承中成员变量访问特点

就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上。

如果出现了重名的成员变量怎么办

System.out.println(name);                //从局部位置开始往上找
System.out.println(this.name);         //从本类成员位置开始往上找

System.out.println(super.name);      //从父类成员位置开始往上找

class Person{
    String name = "张三";
}

class Student extends Person{
    String name = "李四";

    public void show(){
        String name = "王五";
        
        System.out.println(name);//王五
        System.out.println(this.name);//李四
        System.out.println(super.name);//张三
    }
}

public class test{
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

 继承中成员方法访问特点

this调用：就近原则

super调用：直接找父类

class Person{
    public void study(){
        System.out.println("学习");
    }
}

class Student extends Person{
    @Override
    public void study(){
        System.out.println("学习语文");
    }

    public void show(){
        study();//学习语文
        this.study();//学习语文
        super.study();//学习
    }
}

public class test{
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

 study为方法重写，方法重写注意事项和要求

1. 重写方法的名称、形参列表必须与父类中的一致。
2.子类重写父类方法时，访问权限子类必须大于等于父类(空着不写<protected < public )
3.子类重写父类方法时，返回值类型子类必须小于等于父类
4.建议: 重写的方法尽量和父类保持一致。
5.只有被添加到虚方法表中的方法才能被重写

继承中构造方法访问特点

父类中的构造方法不会被子类继承。
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。

为什么

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

怎样调用父类构造方法

子类构造方法的第一行语句默认都是:super()，不写也存在，且必须在第一行。
如果想调用父类有参构造，必须手动写super进行调用，super(参数1，参数2，...)。

this、super使用总结

this:理解为一个变量，表示当前方法调用者的地址值;
super: 代表父类存储空间。

继承的标准JavaBean类

要求定义：

1.经理
成员变量:工号，姓名，工资，管理奖金
成员方法:工作(管理其他人)，吃饭(吃米饭)
2.厨师
成员变量:工号，姓名，工资
成员方法:工作(炒菜)，吃饭(吃米饭)

父类：

public class Employee{

    private String id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void work(){
        System.out.println("员工在工作");
    }
    public void eat(){
        System.out.println("吃米饭");
    }
}

经理：

public class Manager extends Employee{

    private double bouns;

    public Manager() {
    }
    public Manager(String id, String name, double salary, double bouns) {
        super(id, name, salary);
        this.bouns = bouns;
    }

    public double getBouns() {
        return bouns;
    }

    public void setBouns(double bouns) {
        this.bouns = bouns;
    }

    @Override
    public void work() {
        System.out.println("经理正在管理其他人");
    }
}

厨师：

public class Cook extends Employee{

    public Cook() {
    }
    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }

    @Override
    public void work() {
        System.out.println("厨师正在炒菜");
    }
}

多态

什么是多态

对象的多种形态

多态的前提

有继承/实现关系
有父类引用指向子类对象
有方法的重写

多态的格式

父类对象  对象名称  =  new  子类对象（）；

多态的好处

使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利

多态调用成员的特点

变量调用:编译看左边，运行也看左边。
方法调用:编译看左边，运行看右边。

代码演示

public class test {
    public static void main(String[] args) {
        //根据多态的方式创建对象
        Animal a = new Dog();

        //变量调用:编译看左边，运行也看左边。
        //编译看左边:javac编译代码的时候，会看左边的父类有没有变量name，如果有，编译成功，如果没有则失败
        //运行也看左边:java运行代码的时候，实际获取的就是左边父类变量的值
        System.out.println(a.name);//Animal

        //方法调用:编译看左边，运行看右边。
        //编译看左边:javac在编译代码的时候，会看左边父类有没有show方法，如果有，编译成功，如果没有则失败
        //运行看右边:java运行代码的时候，实际运行的就是右边子类的show方法
        a.show();//Dog的show方法
    }
}

class Animal{
    String name = "Animal";
    public void show(){
        System.out.println("Animal的show方法");
    }
}

class Dog extends Animal{
    String name = "Dog";
    public void show(){
        System.out.println("Dog的show方法");
    }
}

原理：

父类的成员变量子类会继承下来，因此内存中存在 Animal 的 name 和 Dod 的 name ，a是 Animal类型的，因此运行获取的是 Animal 的成员变量。

父类的虚方法子类也会继承，但是子类重写了父类的方法，因此实际运行的是子类的方法。

多态的优势

1.在多态形式下，右边对象可以实现解耦合，便于扩展和维护。
Person p = new Student ();
p.work()；//Student转换为Teacher时，此代码无需修改
2.定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。 

多态的弊端

不能调用子类的特有功能

为什么 

当调用成员方法的时候，编译看左边，运行看右边
那么在编译的时候会先检查左边的父类中有没有这个方法，该方法子类特有，所以报错。

解决方案

将父类变回子类类型就可以了 

Animal  a  =  new  Dog () ；

利用 instanceof 判断 a 是否是 Dog 类型，如果是才转换

if (a  instanceof  Dog ) {

        Dog  d  =  (Dog)a；

        d.lookhome()；

}

JDK14新特性

if (a  instanceof  Dog d ) {

        d.lookhome()；

}