多态入门请不要放弃

3.1 多态的基本认识

概述 : 多态是同一个行为具有多个不同表现形式或形态的能力。

如下图：黑白打印机和彩色打印机相同的打印行为却有着不同的打印效果

前提：

·有继承关系

·有方法重写（抽象方法）

·有父类引用指向子类对象

格式：

parent p = new Chile();

把子的对象赋值给父

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

3.2 多态中的成员访问方法

Fu f = new zi;

我们按照上面给出格式来写一段代码（Zi 继承 Fu 类）

A：成员变量

编译看左边，运行看左边

B：构造方法

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

C；成员方法

编译看左边，运行看右边

D；静态方法

编译看左边，运行看右边

看左边即在左边即父类中寻找，看右边即在子类中寻找

3.3 多态的好处和弊端

多态的好处：

A：提高了代码的维护性（继承保护）

B：提高了代码的扩展性（由多态保证）

Eg：例如一个程序中 狗 猫 猪 都继承于动物类（Eg：AnimalTool）

分别写出对应的行为方法（Eg：eat()）

而将调用动物功能的代码 写入动物操作工具类

但是添加新的动物时，每次都需要修改工具类

为了优化代码，将工具类中 每一个动物的操作代码名字

写为动物总称，添加新动物后，只需要在 Demo 中创建 新动物的对象 然后直接调用这个总的动物操作工具类

---

class Animal {public void eat() {System.out.println("eat");
    }
}

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

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


class AnimalTool {private AnimalTool() {}
    
    // 调用猫的功能
    public static void useCat(Cat c) {c.eat();
    }
    
    // 调用狗的功能
    public static void useDog(Dog d) {d.eat();
    }
    
    // 把所有的可能都归为动物类
    public static void useAnimal(Animal a) {a.eat(); // 还可以写其他方法
    }
}

public class DuoTaiDemo {public static void main(String[] args) {
        
        /*
         * 直接创对象调用对应方法
         */
        
        // 我养了一只狗
        Dog d = new Dog();
        d.eat();
        
        // 我又养了一只狗
        Dog d2 = new Dog();
        d2.eat();
        
        
        /*
         * 创对象、使用动物操作类调用对应方法（）*/
        Dog d3 = new Dog();
        Dog d4 = new Dog();
        AnimalTool.useDog(d3);
        AnimalTool.useDog(d4);
        
        // 我喜欢猫
        // 定义一个猪类，它要继承自动物，提一个 eat() 方法
        // 并且还得再工具类中添加该类方法的调用（即类似前面 useDog()）这样无疑很麻烦
        
        Cat c = new Cat();
        Cat c2= new Cat();
        AnimalTool.useCat(c);
        AnimalTool.useCat(c2);
        
        // 推荐使用多态
        AnimalTool.useAnimal(c);
        AnimalTool.useAnimal(c2);
    }

多态的弊端：

A：不能使用子类的特有功能

如果想使用：

·创建子类对象调用方法即可（可以但是很多时候不合理，而且太占内存）

·把父类的引用强制转换为子类的引用（向下转型）

对象间的转型问题：

向上转型：

Fu f = new Zi();

向下转型：

Zi z = (Zi)f; // 要求 f 必须能够转为 Zi

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

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

class DuoTaiDemo2 {public static void main(String[] args) {Fu fu = new Zi();
        fu.show();
        //fu.method(); 错误，不能使用子类特有功能
        
        // 通过转型可以使用子类特有功能
        
        // 创建子类对象
        // 可以但是不推荐
        Zi zi = new Zi();
        zi.show();
        zi.method();
        
        // 要求 f 必须能够转为 Zi
        // 推荐（）Zi zi2 = (Zi)fu;
    }
}

结尾：

如果内容中有什么不足，或者错误的地方，欢迎大家给我留言提出意见, 蟹蟹大家！^_^

如果能帮到你的话，那就来关注我吧！

在这里的我们素不相识，却都在为了自己的梦而努力 ❤

一个坚持推送原创 Java 技术的公众号：理想二旬不止