Java多态实例详解三步走（一）【具体类多态】

约定不等于承诺〃 2022-05-19 07:21 184阅读 0赞

**多态的概念：**多态其实是同一个对象在不同时刻体现出来的不同状态

多态分为三种：

*  具体类多态（几乎没有）：  
    　　class Fu \{ \}  
    　　class Zi extends Fu \{ \}
    
    　　Fu f = new Zi();
 *  抽象类多态（常用）：  
    　　abstract class Fu \{ \}  
    　　class Zi extends Fu \{ \}
    
    　　Fu f = new Zi();  
    　　请看 [Java多态实例详解三步走（二）【抽象类多态】][Java]
 *  接口类多态（最常用）：  
    　　interface class Fu \{ \}  
    　　class Zi implements Fu \{ \}
    
    　　Fu f = new Zi();  
    　　请看 [Java多态实例详解三步走（三）【接口多态】][Java 1]

本文讲解为具体类多态，也是基础。

**多态的前提：**  
1、有继承或者实现关系。  
2、有方法重写（因为多态就是靠方法重写来体现不同状态的）。  
3、要有父类或者父接口引用指向子类对象。  
　 格式：父 f = new 子()

**多态中的成员访问特点：**  
1、成员变量  
　　编译看左边（父类），运行看左边（子类）。

2、构造方法  
　　创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化

3、成员方法  
　　编译看左边（父类），运行看右边（子类）  
　　（因为成员方法存在方法重写，所以成员方法访问的时候访问的是子类）。

4、静态方法  
　　编译看左边（父类），运行看左边（子类）  
　　（静态和类相关，算不上重写，所以，访问还是左边）

**多态的好处：**  
1、提高了代码的维护性（由继承来保证）  
2、提高了代码的扩展性（由多态来保证）

对于下面的代码，是没有用多态来写的，如果创建一个新的子类，就要在工具类中多增加一个方法，如果创建很多个，那么同样的代码要重复好多遍，如果用多态，就可以保证在多增加一个类的同时，工具类中不用再增加一个方法。这就提高了代码的扩展性。

**代码1：**

public class Main { 
        public static void main(String[] args) {
            cat c = new cat();
            dog d = new dog();
            AnimalTool.useCat(c);
            AnimalTool.useDog(d);
        }
    }
    
    //创建工具类
    class AnimalTool { 
        private AnimalTool() {}
    
        //调用猫的功能
        public static void useCat(cat c) {
            c.eat();
            c.sleep();
        }
    
        //调用狗的功能
        public static void useDog(dog d) {
            d.eat();
            d.sleep();
        }
    
        //如果我创建一个新的子类，就要在这里多增加一个方法，如果创建很多个，那么同样的代码要重复好多遍
    
    }
    
    //创建父类
    class Animal { 
        public void eat() {
            System.out.println("eat");
        }
    
        public void sleep() {
            System.out.println("sleep");
        }
    }
    
    //创建子类
    class cat extends Animal { 
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
        public void sleep() {
            System.out.println("猫卧着睡");
        }
    }
    
    //创建子类
    class dog extends Animal { 
        public void eat() {
            System.out.println("狗吃肉");
        }
    
        public void sleep() {
            System.out.println("狗趴着睡");
        }
    }

如果用多态，就会节省很多代码。因为只需要修改AnimalTool类，所以只给出了AnimalTool修改后的代码。

**代码2：**

class AnimalTool {
        private AnimalTool() {}
        //运用多态就能很好的解决代码重复的问题
        public static void useAnimal(Animal a) {
            a.eat();
            a.sleep();
        }
    }

**多态的弊端：**不能使用子类的特有功能。

如果想要解决就涉及到对象的转型问题

> 向上转型：Fu f = new Zi();  
> 向下转型：Zi z = (Zi)f; //要求f必须是能够转换为Zi类的

例如下面的代码：

public class Main { 
        public static void main(String[] args) {
            Animal a = new Dog();//向上转型
    
            a.eat();
            //这里调用eat方法是没有问题的
            //需注意的是，这里调用的eat方法是Dog中的方法，而不是Animal中的eat方法。
            //也就是说，这里调用的是重写后的eat方法
            //所以这里输出的应该是 狗吃东西
    
            //这里需要注意，此时输出成员变量flag，输出的是父类中的值
            System.out.println(a.flag);//输出的值为78
    
    
            //调用Dog中的特有方法会报错，可以把注释去掉试一试
            //a.lookDoor();
    
            //出现以上两种情况是因为，a 是 Animal 类型的。
            //这就对应了上边说的，编译看左边，运行看右边。
    
            //但是，如果我现在就想用Dog中的lookDoor方法，怎么办
    
            //那就把父类的引用强制转换为子类的引用（向下转型）。
            Dog d = (Dog)a;
            //这时再使用lookDoor方法就没有问题了
            d.lookDoor();
    
            //可能有的小伙伴要说了，我直接Dog d = new Dog() 不就行了。
            //这样做也可以，但是会浪费内存
    
            a = new Cat()//我把 a 的地址换为指向Cat，内存中就是猫的
            a.eat();//输出 猫吃东西
            //所以，我将a转化为Cat是没问题的
            Cat c = (Cat)a;
    
    
            // Dog dd = (Dog)a;
            //因为此时内存中是猫，所以将此时的a转化为Dog是会报错
            //ClassCastException（类型转换异常），一般在向下转型时出现
    
            //以上也就解释了在向下转型时，要求f必须是能够转换为Zi类的这个条件。
        }
    }
    
    class Animal { 
        int flag = 78;
        public void eat() {}
    
    }
    
    class Dog extends Animal { 
        int flag = 23;
        public void eat() {
            System.out.println("狗吃东西");
        }
    
        public void lookDoor() {
            System.out.println("狗看门");
        }
    
    }
    
    class Cat extends Animal { 
        int flag = 99;
        public void eat() {
            System.out.println("猫吃东西");
        }
    
        public void playGame() {
            System.out.println("猫玩游戏");
        }
    }

[Java]: https://blog.csdn.net/k_young1997/article/details/81169726
[Java 1]: https://blog.csdn.net/k_young1997/article/details/81178170