java中多态的利与弊

多态中成员访问特点

构造方法:同继承一样，子类会通过super访问父类构造方法
成员变量：编译看左边（父类），执行看左边(父类）
	意思是如果父类没有这个变量，当在主类程序进行使用的时候就会报错，而且输出的也是父类的这个变量值。
成员方法：编译看左边（父类），执行看右边（子类）
	当父类和子类都有这个方法的时候，在主类中调用这个方法的时候，如果父类没有这个方法，编译器就直接报错了，但是执行的时候是使用的是子类里边的这个方法。

多态的好处和弊端

多态的好处：提高了程序的扩展性。
	具体体现：定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的任意子类对象
多态的弊端：
	不能使用子类的特有功能。

public class Test3Polymorpic {
    public static void main(String[] args) {
        // Dog d = new Dog();
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){
        a.eat();
        // a.watchHome();   // 不能调用子类特有的功能
    }
}

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 Test4Polymorpic {
    public static void main(String[] args) {
        // 1.向上转型：父类引用指向子类对象
        Fu f = new Zi();
        f.show();

        // 多态的弊端：不能调用子类特有的成员
        // f.method();

        // A:直接创建子类对象
        Zi z = new Zi();
        z.method();
        // B:向下转型

        // 2.向下转型：从父类类型，转换回子类类型
        Zi zz = (Zi) f;  // 因为父类比子类大，而且大的类型向小的类型转换需要转换，所以这里要 强制类型转换
        zz.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");
    }
}

多态中的转型存在的风险

概述：如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现 ClassCastException  类型转换错误
关键字 instanceof
使用格式：
	变量名：instanceof类型
	通俗的理解：
		判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

比如，此时存在动物类，和狗类，猫类，动物类是猫和狗的父类。

public class Test3Polymorpic {
    public static void main(String[] args) {
        // Dog d = new Dog();
        useAnimal(new Dog());  // 因为第一次传过去的是狗类，强制转换成狗类没问题
        useAnimal(new Cat());  // 这里传入的是猫类，但是猫类要转换成狗类就出错了  所以要通过 instanceof关键字来判断一下
    }

    public static void useAnimal(Animal a){ // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();
        // a.watchHome();   // 不能调用子类特有的功能

        if (a instanceof Dog){  // 判断当前变量是不是所记录的子类类型，是的话才能转换，否则就会报错
            Dog dog = (Dog) a;
            dog.watchHome();  // ClassCastException 是类型转换的错误
        }
        // Dog dog = (Dog) a;
        // dog.watchHome();  // ClassCastException 是类型转换的错误
    }
}

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("猫吃鱼");
    }
}