Java——多态的使用以及多态的转型

多态：同一个事物（对象）在不同时刻体现出来的不同状态。例如：狗子是狗子也是动物，水有不同的形态。

多态的前提：

• 要有继承
• 要有方法重写
• 要有父类指向子类对象（父类的引用子类的对象，例：【左边】父 f = new 子();【右边】）

多态中的成员访问特点：

• 访问成员变量时，编译看左边（父类），运行结果看左边（父类）
• 访问成员方法时，编译看左边（父类），运行结果看右边（子类）
• 访问静态方法时，编译看左边（父类），运行结果看左边（父类）
• 访问构造方法时，创建子类对象时，访问的是父类的构造方法，对父类的数据进行初始化

多态的好处：

• 提高了代码的维护性（继承的保证）
• 提高了代码的扩展性

多态的弊端：

• 不能使用子类的特有成员

一个简单的例子，先创建动物类父类，让小猫类继承动物类，在主方法中让父类引用子类的对象，输出子类中重写方法的内容。

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

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

public class Test1Polymorphic {
    /*
        多态的前提:

            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();
    }
}

控制台输入结果：

多态中的转型

• 向上转型
  父类引用指向子类对象就是向上转型，就是之前所说的多态的特性
• 向下转型
  向下转型是为了能用子类中特有的方法，格式为：子类型 对象名 = （子类型）父类引用

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 Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();

        // A: 直接创建子类对象
        // B: 向下转型

        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        //此时可以输出子类中特有的方法
        z.method();
    }
}

解决多态在转型时出现的风险

• 多态在进行转型的时候，如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，此时就会出现ClassCastException异常
• 解决办法：
  • 使用关键字 instanceof，instanceof是java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用作对对象的判断。用法是：boolean result = obj instanceof Class，其中obj是一个对象，Class表实一个类或者一个接口，当obj是Class的对象时，或者是它的直接或者间接子类，此时result就会返回一个true，否则返回false。obj 必须是引用类型，不能是引用基本类型，当 obj 为null的时候，返回false。
  • 其实就是判断关键字左边的变量是否为右边的类型，返回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 Test4Polymorpic {
    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();
        }
    }

}

控制台输出结果：