Java多态

/*
* JVM特性：多线程、跨平台、面向对象、自动垃圾回收机制
*
* 面向对象特征：封装性、继承性、动态性（多态）、抽象
*
* 多态相关知识点：
*   软件设计六大原则
*       1 单一职责原则：功能职责单一，只拥抱一种变化
*       2 里氏替换原则：所有在使用父类的情况下，都可以使用子类
*       3 依赖倒置原则：高层通过抽象依赖底层
*       4 接口隔离原则：不应该依赖于它不需要的接口
*       5 迪米特原则：最少只是原则，减少程序的耦合
*       6 开闭原则：对扩展开放，对修改关闭
* 多态就是里氏原则的一种体现
* 多态：父类引用 指向 子类对象
*       父类引用：父类型声明的引用类型变量
*       指向：通过这个引用类型的变量可以找到 哪个对象
*       子类对象：new 的子类对象
*   通过父类创建一个引用类型的变量，可以找到子类的对象
*       父类 变量 = new 子类();
*       Animal a = new cat();
*
* 变量声明：
*       数据类型 变量名 = 值
*
* 变量分类：
*       局部变量
*           1 方法内部声明
*           2 参数列表声明
*       静态变量
*       成员变量
*
* 有变量的地方 就可以发生多态，多态是发生在变量赋值的时候
*   Animal a = new cat();
*
* 多态的几种形式
*   1 直接多态
*       不管成员变量还是局部变量 直接声明式多态: 父类 变量 = new 子类();
*   2 形参和实参
*       方法参数定义时，使用父类定义，调用方法是，传递子类对象
*   3 返回值
*       返回值类型定义为父类，返回数据的时候返回子类对象
*
* 多态缺点：
*   丢失子类特有的属性（子类有父类没有的属性）
*
* 多态调用属性
*   1 如果调用的是父类没有的，直接报错，访问不了
*   2 如果调用的是子类没有的，都访问父类的
*   3 如果调用的是子类和父类都有的，除了成员方法调用子类的之外，其他的都调用父类的，因为成员方法可以覆写
* */

---

public class _01_Poly {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal a = new Animal();
        Animal ac = new Cat(); // 多态
        ac.eat();
        System.out.println(ac.age); // 字段属性调用父类。不可覆写

        // 编译时报错，不能调用子类特有的属性
        // ac.run();

        // 形参和实参发生多态，需要传递一个Animal类型，实际传递一个Cat类型，
        // 说明传递的是Animal类型指向Cat类型，且需要cat与animal有继承关系
        m1(cat);

        // 返回值多态
        Animal animal = m2();

    }
    public static void m1(Animal animal){
        animal.cry();
    }
    public static Animal m2(){
        return new Cat();
    }
}

class Animal{
    int age = 10;
    public void eat(){
        System.out.println("动物吃东西");
    }
    public void cry(){
        System.out.println("动物会叫");
    }
}

class Cat extends Animal{
    int age = 3;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void run(){
        System.out.println("猫步");
    }
 }

class Dog extends Animal{
    int age = 5;
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
    public void run(){
        System.out.println("狗步");
    }
}

---

/*
* 多态优点：
*   1 提高代码的维护性（由继承保证）
*   2 提高代码的扩展性（由多态保证）
*   把不同子类当做父类看待，可以屏蔽不同子类之间的差异，解耦，降低耦合度，松耦合
*   写出通用的代码，做出通用的编程，以适应需求的不断变化。
*   可理解为“一个接口，多种实现”，就是同一种事物表现出的多种形态，相当于父类定义接口，子类实现，然后通过父类访问。
*   多态就是抽象化的一种体现，把一系列具体事务的共同特征抽象出来，在通过这个抽象的事物与不同的具体事务进行对话
*
* 多态前提条件
*   1 必须有继承关系的体系中
*   2 多态又叫向上转型
*   3 方法覆写
* */

---

public class _02_Poly {
    public static void main(String[] args) {
        Sub1 sub1 = new Sub1();
        Sub2 sub2 = new Sub2();
        Sub3 sub3 = new Sub3();
        Sub4 sub4 = new Sub4();

        money(sub1);
        money(sub2);
        money(sub3);
        money(sub4);
    }

    // 使用多态解决
    public static void money(Sup sup){
        sup.money();
    }

    // 编写方法 接收Sub1 和 Sub2 Sub3 并调用他们的money方法
    // 每个对象有相同的方法，导致代码大量重复
//    public static void money(Sub1 sub1){
//        sub1.money();
//    }
//    public static void money(Sub2 sub2){
//        sub2.money();
//    }
//    public static void money(Sub3 sub3){
//        sub3.money();
//    }
}

class Sup{
    public void money(){
        System.out.println("义捐");
    }
}
class Sub1 extends Sup{
    public void money(){
        System.out.println("买小车车");
    }
}

class Sub2 extends Sup{
    public void money(){
        System.out.println("买小房子");
    }
}
class Sub3 extends Sup{
    public void money(){
        System.out.println("创业");
    }
}
class Sub4 extends Sup{

}

---

/*
* 多态缺点（扩展） 丢失子类特有属性，特有属性需要向下转型后在进行访问
*
* 并且是编译时异常
*
* 程序从开发到运行的完整生命周期
*   编译阶段：在编译阶段，父类文件有，子类文件也有，子类对象没有，代码中定义了多态
*       这时，编译器会直接按照父类类型来划分空间，来说明空间中存在哪些属性，并且检查语法结构
*       这时只能找到父类的属性说明，空间是父类声明的
*       什么时候有子类对象？ 运行时
*   运行阶段：运行时才赋值
*       个各类载入方法区，开始运行，执行new创建对象，对象用子类Cat创建的，包含子类中特有属性
*       但引用变量的类型是父类类型，并在编译阶段进行了静态绑定，所以 使用这个父类声明的空间的时候只能找到父类中有的
*       而 子类 中特有属性没办法通过父类变量找到
*       因为 父类变量声明的时候，只能够找到父类的属性列表，而创建对象之后，使用子类声明的属性列表
*       常理来说创建了对象，对象中有子类属性，为什么找不到？因为在编译时候报错了，语句检查不通过，在运行之前就报错
*       等于使用父类属性列表去调用子类属性值列表，找不到
*
* 编译时：（构造等号的左边，也就是属性）
*   编译时，会把父类属性生成一个属性列表，父类属性就有了，这是编译时绑定，绑定后程序就有了，属性就固定了
*   属性值没有固定（没运行，就不会有新空间，就没有值）
*   编译时绑定 又叫静态绑定/前绑定
* 运行时：（到堆内存才有值）
*   把类生成对应的的对象，也就有了子类的属性列表，因为创建了对象，有了空间，并进行了初始化操作，所以属性值就有了
*   这种运行阶段进行的数据绑定叫 运行时绑定/动态绑定/后绑定
* 调用时：
*   使用父类的引用，调用子类对象的属性（特有的访问不到）
*   可以理解为 使用父类的属性列表去访问子类的属性列表
*   因为父类属性列表中不存在子类特有的属性，当对父类属性列表进行调用匹配时，找不到，在编译时就直接报错
*
* super：代表父类型特征，这里可理解为父类型的属性列表
*
* 使用多态调用后结果：
*   1 父类没有的，不管子类有没有，都调用不了，直接编译不通过
*   2 只要父类有的，子类没有的，都执行父类的属性
*   3 只要两者都有的，除了调用成员方法执行子类，其他都执行父类，覆写优先，覆写相当于扩展，扩展后优先级高
* */

---

*
* 发生多态情况：
*   1 直接赋值
*   2 实参实参
*   3 返回值
*   4 隐式：类似于自动转换，不容易发现，此例子中通过this发生多态。自动发生多态
*       通过子类调用继承于父类的成员方法时候，该方法上下文环境 发生多态（父空间区域，指向子类对象）
* */

---

public class _05_Poly {

    public static void main(String[] args) {
        System.out.println("多态调用 m2 和 i");
        SupClass supClass = new SubClass();
        supClass.m2();
        System.out.println(supClass.i);
        System.out.println("==========");

        System.out.println("子类对象调用 m2 和 i");
        SubClass subClass = new SubClass();
        subClass.m2();
        System.out.println(subClass.i);
        System.out.println("=====");

        System.out.println("子类对象调用继承的 m1"); // 发生隐式多态
        subClass.m1();
    }
}

class SupClass{
    int i = 2;
    public void m1(){
        /*
        * this:谁调用就是谁 这里this一定是subClass这个子类对象
        *
        * this 是保存当前对象的内存地址，并且是第一个成员变量，变量有数据类型
        *
        * this可以存储当前对象内存地址时，其数据类型为：
        *   1 当前类类型
        *   2 父类类型
        *   如果是父类类型的话，就是多态，父类引用指向子类对象，缺点：（子类独有）
        *   this可以调用当前类的特有属性，所以this是 当前类 类型
        * 当前类：this所出现的类（在哪个类中出现，哪个类就是当前类）
        * */
        // this会发生多态，此时调用子类的m2()，称为隐式多态
        m2();
        System.out.println(i);
    }
    public void m2(){
        System.out.println("父类的m2方法");
    }
}

/*
 SupClass 编译后的源码
 Source code recreated from a .class file by IntelliJ IDEA
 (powered by FernFlower decompiler)

package com.tianl.oop._12_Ploymorphic;

class SupClass {
    int i = 2;

    SupClass() {
    }

    public void m1() {
        this.m2(); // 这里this 就等于是SupClass this
        // 那么this的引用 是子类对象（m1()方法通过子类对象SubClass访问，所以这里this指向SubClass）
        // 结合this是当前类对象，所以这里等同于 SupClass this = new SubClass();
        // 所以发生多态，m2()方法执行的是子类方法，字段i为当前类
        System.out.println(this.i);
    }

    public void m2() {
        System.out.println("父类的m2方法");
    }
}
*/


class SubClass extends SupClass {
    int i = 3;

    @Override
    public void m2(){
        this.i = 5;
        System.out.println("子类的m2方法");
    }
}