注意事项和使用细节

多态的前提是：两个对象（类）存在继承关系。

向上转型

（1）本质：父类的引用指向了子类的对象

（2）语法：父类类型 引用名 = new 子类类型();

（3）特点：

1）编译类型看等号左边，运行类型看等号右边

2）可以调用父类中的所有成员（需遵守访问权限）

3）不能调用子类中的特有成员，因为在编译阶段，能调用哪些成员是由编译类型来决定的

4）最终运行结果看子类的具体实现，即调用方法时，按照从运行类型开始查找方法

向下转型

（1）语法：子类类型 引用名 = (子类类型)父类引用;

（2）只能强转父类的引用，不能强转父类的对象

（3）要求父类的引用必须指向的是当前目标类型的对象

（4）当向下转型后，可以调用子类类型中所有的成员

案例演示

public class PolymorphicDetail {
    public static void main(String[] args) {
        //向上转型：父类的引用指向了子类的对象
        //语法：父类类型 引用名 = new 子类类型();
        Animal animal = new Cat();
        Object object = new Cat();//正确的，因为Object也是Cat()的父类

        //可以调用父类的所有成员，但需遵守访问权限
        //不能调用子类的特有成员，因为能调用哪些成员是由编译类型决定的
//        animal.catchMouse();//错误的，因为catchMouse()是子类的特有成员
        animal.eat();//输出  小猫吃鱼



        //希望调用Cat类的catchMouse方法
        //但如果在编译类型为Animal的情况下调用会报错，因为catchMouse()是子类的特有成员
        //向下转型
        //语法：子类类型 引用名 = (子类类型)父类引用;
        Cat cat = (Cat) animal;//注意只能强转父类的引用，即animal
        //此时cat对象的编译类型和运行类型都是Cat
        cat.catchMouse();//输出  猫抓老鼠

    }
}

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep() {
        System.out.println("睡");
    }
    public void run() {
        System.out.println("跑");
    }
    public void eat() {
        System.out.println("吃");
    }
}

public class Cat extends Animal{
    public void eat() {
        System.out.println("小猫吃鱼");
    }
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

属性没有重写一说，属性的值看编译类型

instanceof比较操作符

instanceof比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

public class PolymorphicDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB); //true
        System.out.println(bb instanceof AA); //true

        AA aa = new BB();//向上转型
        //aa编译类型为AA，运行类型为BB
        System.out.println(aa instanceof BB); //true
        System.out.println(aa instanceof AA); //true
        //所以可以得出instanceof用来判断对象的运行类型是否为某类型或某类型的子类
    }
}

class AA {} //父类
class BB extends AA{} //子类