多态的概述

什么是多态？

        同一个对象，在不同时刻表现出来的不同形态。

---

多态的前提

        ①要有继承或实现关系

        ②要有方法的重写

        ③要有父类引用指向子类对象

class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Demo{
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();

        // 当前事物, 是一只动物
        Animal a = new Cat();

        a.eat();//输出：猫吃鱼
    }
}

---

多态中的成员访问特点

        ①成员变量

                编译看父类，运行看父类

        ②成员方法

                编译看父类，运行看子类

class Fu {
    int num = 10;

    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method(){
        System.out.println("Zi.. method");
    }
}

public class Demo{
    public static void main(String[] args) {
        Fu f = new Zi();

        System.out.println(f.num);  //输出：10

        f.method();  //输出：Zi.. method
    }
}

---

 多态中的转型

        ①向上转型

                父类引用指向子类对象就是向上转型

        ②向下转型

                格式：子类型 对象名 = (子类型)父类引用;

class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }

    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}

public class Demo{
    public static void main(String[] args) {
        //向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();	//输出：Zi..show...     

        //向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;	
        z.method();    //输出：我是子类特有的方法, method
    }
}

---

多态的好处与弊端

        好处：

                提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。

        弊端：

                不能使用子类的特有成员，因此需要使用向下转型。

---

多态中转型存在的风险和解决方案

        风险：

                如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现ClassCastException异常。

        解决方法：

                关键字：instanceof

                使用格式：变量名 instanceof 类型

                通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

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

public class Demo{
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
        /*
            输出：
                狗吃肉
                看家
                猫吃鱼
        */
    }

    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();

        //a.watchHome();//编译时异常

        //Dog dog = (Dog) a;
        //dog.watchHome();  // ClassCastException  类型转换异常
      
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }
}