多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作 —— Delphi4 编程技术内幕

1. 概述

多态也是面向对象的一个标志，它基于继承的前提之下。它指的是，当不同的子类在继承父类后都分别重写了父类方法。虽然继承自同一脉，但是它们方法的表现却各不相同。即所谓的：多态是同一个行为具有多个不同表现形式或形态的能力。
想要实现多态，就要满足几个前提：

• 有继承关系

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

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

2. 格式：

parent p = new Chile();

复制

• 把子的对象赋值给父

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

当后面学习了接口、集合框架等内容，就会经常见到它。例如：

List<Long> list = new ArrayList<>();

复制

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

3. 多态中的成员访问方法

在学习多态时，就有一句广为流传的口诀：编译看左边，运行看右边。
不过其实它是针对非静态方法说的，而成员变量、静态方法都是只看左边。
下面的例子中 Son 类继承 Father 类，这是一个多态的形式。

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

Father f = new son;

复制

我们举例验证开头这个观点：
父类

public class Father {

    int num = 520;

    static void staticMethod() {
        System.out.println("父类静态方法");
    }

    void normalMethod() {
        System.out.println("父类普通方法");
    }

}

复制

子类

class Son extends Father {

    int num = 1314;

    static void staticMethod() {
        System.out.println("子类静态方法");
    }

    @Override
    void normalMethod() {
        System.out.println("子类普通方法");
    }

}

复制

测试类

class Test {
    public static void main(String[] args) {
        Father f = new Son();
        // 与父类一致
        System.out.println(f.num);
        // 与父类一致
        f.staticMethod();
        // 编译时与父类一致，运行时与子类一致
        f.normalMethod();

        Son z = new Son();
        System.out.println(z.num);
        z.staticMethod();
        z.normalMethod();
    }
}

复制

输出结果

520
父类静态方法
子类普通方法
1314
子类静态方法
子类普通方法

复制

通过代码已经能证明结论了：成员变量、静态方法只看左边，非静态方法编译看左边，运行看右边。

4. 多态的好处和弊端

4.1 好处

• 提高了代码的维护性（因为继承会导致代码有明确的结构和关系，不过继承会让耦合变高，后面会使用组合等方式）

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

提升扩展性是一个很重要的优点，下面就举个例子，给大家讲解一下
例如一个程序中狗、猫、猪都继承于动物类（Eg：AnimalTool）
接着分别写出对应的行为方法（Eg：eat() ）

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();
    }

}

复制

但是添加新的动物时，每次都需要修改工具类，为了优化代码，将工具类中 每一个动物的操作代码名字，写为动物总称，添加新动物后，只需要在Demo中创建新动物的对象 然后直接调用这个总的动物操作工具类。

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(); 
    }
}

复制

创对象、使用动物操作类调用对应方法。

public class DuoTaiDemo {
    public static void main(String[] args) {
        Dog d3 = new Dog();
        Dog d4 = new Dog();
        AnimalTool.useDog(d3);
        AnimalTool.useDog(d4);
    }
}

复制

如果想要再定义一个猪类，它要继承自动物，重写 eat() 方法。
并且还得再工具类中添加该类方法的调用（即类似前面 useDog 方法）这样无疑很麻烦。但是我如果使用了多态，那么就不需要再在工具类中添加新的类型，只需要传入到 useAnimal 方法中就可以了。

public class DuoTaiDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        Cat c2= new Cat();
        AnimalTool.useCat(c);
        AnimalTool.useCat(c2);

        // 推荐使用多态
        AnimalTool.useAnimal(c);
        AnimalTool.useAnimal(c2);
    }
}

复制

4.2 弊端

4.2.1 不能使用子类的特有功能

如果想使用，一种方法就是创建子类对象调用方法（可以但是很多时候不合理，而且太占内存），另一种方式把父类的引用强制转换为子类的引用（向下转型）

4.2.2 对象间的转型问题：

向上和向下，其实就是父和子的关系，父为上，子为下。
向上转型

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;
    }
}

复制