Java-多态2020年

浅浅的花香味﹌ 2022-12-22 08:54 100阅读 0赞

### 文章目录 ###

*  一、多态的概述
 *  二、多态中的成员访问特点
 *  三、多态的好处和弊端
 *  四、多态中的转型
 *  五、多态中转型存在的风险和解决方案

--------------------

# 一、多态的概述 #

同一个对象，在不同时刻表现出来的不同形态就叫做多态。  
多态的前提：

*  要有继承或实现关系
 *  要有方法的重写
 *  要有父类引用指向子类对象

代码演示

class Animal {
        
        public void eat(){
        
            System.out.println("动物吃饭");
        }
    }
    class Cat extends Animal {
        
        @Override
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    }
    public class Csdn {
        
        /*
        多态的前提:
        1. 要有(继承 \ 实现)关系
        2. 要有方法重写
        3. 要有父类引用, 指向子类对象
        */
        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 Csdn {
        
        /*
        多态的成员访问特点:
        成员变量: 编译看左边 (父类), 运行看左边 (父类)
        成员方法: 编译看左边 (父类), 运行看右边 (子类)
        */
        public static void main(String[] args) {
        
            Fu f = new Zi();
            System.out.println(f.num);
            f.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 Csdn {
        
        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
 *  解决方案
    
    1.  关键字  
        instanceof
    2.  使用格式  
        变量名 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 Csdn {
        
        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();
            }
        }
    }

--------------------