• 面向对象的三大特征：封装、继承和多态；

多态的形式

  父类类型    对象名称 = new 字类构造器;
  接口           对象名称 = new 实现类构造器;

• 父类类型的范围 > 字类类型的范围

多态的概念

• 同一个类型的对象，执行同一个行为，在不同的状态下表现出不同的特征；
• 多态的识别技巧
  • 对于方法的调用：编译看左边，运行看右边
  • 对于变量的调用：编译看左边，运行也看左边（变量没有多态的概念）

public class PolymorphicDemo {
    public static void main(String[] args) {
        //  父类类型 对象名称 = new 子类构造器;
        Animal dlam = new Cat();
        dlam.run(); // 对于方法的调用：编译看左边，运行看右边。
        System.out.println(dlam.name); // 对于变量的调用：编译看左边，运行看左边。

        Animal taiDi = new Dog();
        taiDi.run(); // 对于方法的调用：编译看左边，运行看右边。
        System.out.println(taiDi.name); // 对于变量的调用：编译看左边，运行看左边。
    }
}

class Dog extends Animal{
    public String name = "🐶名称Dog";
    @Override
    public void run(){
        System.out.println("🐕跑的贼快~~~~！");
    }
}

class Cat extends Animal{
    public String name = "🐱名称Cat";
    @Override
    public void run(){
        System.out.println("🐱跑的飞快~~~~！");
    }
}

class Animal{
    public String name = "动物名称Animal";
    public void run(){
        System.out.println("动物跑！");
    }
}

多态的使用前提

• 1.必须存在继承或者实现关系；
• 2.必须存在父亲类型的变量引用子类类型的对象；
• 3.需要存在方法重写

多态的优、劣势

优势

• 1.在多态的形式下，右边的对象可以实现组件化的切换，业务功能功也可以随之而发生改变，便于扩展和维护。可以实现类与类之间的解耦；
• 2.实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，可以传入一切子类对象进行方法的调用，更能体现出多态的扩展性与便利。（即为向上转型）

劣势

• 1.多态形式下，不能直接调用子类特有的功能。编译看左边!! 左边父类中没有子类独有的功能，所以代码在编译阶段就直接报错了！

public class PolymorphicDemo {
    public static void main(String[] args) {
        //  父类类型 对象名称 = new 子类构造器;
        Animal dlam = new Dog();
        dlam.run(); // 对于方法的调用：编译看左边，运行看右边。
        // dlam.lookDoor(); // 报错了，多态形式下，编译看左边，左边没有独有功能

        Animal taidi = new Dog();
        go(taidi);

        Animal tom = new Cat();
        go(tom);
    }

    // 开发一个游戏 所有动物都可以进来比赛
    public static void go(Animal d){
        System.out.println("开始。。");
        d.run();
        System.out.println("结束。。");
    }
}

class Dog extends Animal{
    @Override
    public void run(){
        System.out.println("🐕跑的贼快~~~~！");
    }

    // 独有功能
    public void lookDoor(){
        System.out.println("🐶看门");
    }
}

class Cat extends Animal{
    @Override
    public void run(){
        System.out.println("🐱跑的飞快~~~~！");
    }

    // 独有功能
    public void catchMouse(){
        System.out.println("🐱抓🐀");
    }
}

class Animal{
    public void run(){
        System.out.println("动物跑！");
    }
}

引用类型的强制类型转换

• 父亲类型的变量或者对象必须强制类型转换成子类类型的变量，否则报错；

类型 变量名称 = (类型)(对象或者变量)

• 有继承/实现关系的两个类型就可以进行强制类型转换，编译阶段一定不报错！但是运行阶段可能出现：类型转换异常 ClassCastException
• Java建议在进行强制类型转换之前先判断变量的真实类型，再强制类型转换!

变量 instanceof 类型
//判断前面的变量是否是后面的类型或者其子类类型才会返回true

public class PolymorphicDemo {
    public static void main(String[] args) {
        Animal a = new Wolf();
        a.run();
        // a.catchSheep(); // 报错！

        // 1.把动物类型的变量a 转换成 真实的狼类型
        Wolf w = (Wolf) a;
        w.catchSheep();

        // 2.多态下类型转换异常问题研究（重点）
        Animal a1 = new Cat();
        //Wolf w1 = (Wolf) a1; // 编译阶段没有报错！在运行阶段出现ClassCastException类型转换成！

        if(a1 instanceof Cat){
            Cat c1 = (Cat) a1;
            c1.catchMouse();
        }else if(a1 instanceof Wolf){
            Wolf w1 = (Wolf) a1;
            w1.catchSheep();
        }
    }
}

class Wolf extends Animal{
    @Override
    public void run(){
        System.out.println("狼跑的飞快~~~");
    }

    public void catchSheep(){
        System.out.println("🐺抓🐏");
    }
}

class Cat extends Animal{
    @Override
    public void run(){
        System.out.println("猫跑的贼快~~~");
    }

    public void catchMouse(){
        System.out.println("🐱抓🐀~~");
    }
}

class Animal{
    public void run(){
        System.out.println("动物可以跑~~");
    }
}