芝士干货 | Java多态详解

下面讲解一下Java中的多态机制，力求用最通俗易懂的语言，最精炼的话语，最生动的例子，深入浅出Java多态，帮助读者轻松掌握这个知识点。

什么是多态？

多态是指同一种行为具有多个不同表现形式的能力。

多态的分类

多态一般分为重载式多态和重写式多态：

• 重载式多态，也叫编译时多态。也就是说这种多态在编译时已经确定好了。方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。
• 重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在运行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。这种多态通过方法重写以及向上转型来实现。

多态实现的必要条件

• 有继承/实现关系：在多态中必须存在有继承关系的子类和父类或者接口及其实现类。
• 有方法重写：子类对父类中某些方法进行重新定义，再调用这些方法时就会调用子类的方法。
• 有父类引用指向子类对象：父类引用指向子类对象叫做向上转型。

向上转型和向下转型

• 向上转型：父类引用指向子类对象，这个是自动的，不需要显示转换。通过向上转型，你可以调用在父类中定义的方法，但不能调用子类特有的方法。
• 向下转型：子类引用指向父类对象，这个是非自动的，需要进行强制类型转换。在进行向下转型之前，通常需要使用 instanceof 操作符来检查引用的对象是否确实是目标子类的实例。

多态的成员访问特点

• 成员变量：编译看左边（父类），执行看左边（父类）
• 成员方法：编译看左边（父类），执行看右边（子类）

举个栗子：

// 水果类，拥有一个show()方法
public class Fruits {
    public void show() {
        System.out.println("我水果之父，打钱!");
    }
}

// 苹果类，实现父类水果，并重写show()方法
public class Apple extends Fruits{
    @Override
    public void show() {
        System.out.println("我苹果，打钱!");
    }

    public void color() {
        System.out.println("我是红色的苹果。");
    }
}

// 香蕉类，实现父类水果，并重写show()方法
class Banana extends Fruits {
    @Override
    public void show() {
        System.out.println("我香蕉，打钱!");
    }
    public void color() {
        System.out.println("我是黄色的香蕉。");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Fruits fruit = new Apple(); // 向上转型
        fruit.show();   // 我苹果，打钱!
        fruit = new Banana();   // 向上转型
        fruit.show();   // 我香蕉，打钱!
    }
}

这就是向上转型，Fruits fruit = new Apple();将子类对象Apple转化为父类对象Fruits，这个时候fruit引用指向的是子类对象，所以调用的方法是子类方法。

需要注意的是：向上转型时，子类单独定义的方法会丢失。比如，上面案例中的Apple类和Banana类都定义了自己的color方法，当进行了向上转型后，fruit引用指向Apple类的实例时是访问不到color方法的，fruit.color()会报错。

下面给出原因：

我们需要时刻记住多态的成员访问特点：编译时看左边，运行时看右边。

比如Fruits fruit = new Apple();，这行代码中的变量fruit在编译时和运行时的类型如下：

• 编译时 (Compile-time)：编译时看左边，变量fruit的类型就是Fruits，这是因为我们声明了fruit为Fruits类型。在编译时，编译器只知道fruit是一个Fruits类型的引用，因此它只允许调用在 Fruits类中定义的方法，而不允许调用子类Apple中特有的方法，除非进行向下转型。
• 运行时 (Run-time)：运行时看右边，fruit实际指向的对象是Apple类型的实例。这是因为我们使用new Apple()创建了一个Apple类型的对象并将其引用赋值给了fruit。因此，当我们调用 fruit.show()时，实际执行的是Apple类中重写的show()方法。

总结：在编译时，fruit的类型是Fruits，这决定了我们可以对fruit调用哪些方法。在运行时，fruit实际指向的对象是Apple类型，这决定了当我们调用fruit的方法时，实际执行的是哪个版本的方法（即Fruits类中的原始方法还是Apple类中的重写方法）。

上面讲的是向上转型，下面我们来讲一下向下转型：

// 测试类
public class Test {
    public static void main(String[] args) {
        Fruits fruit = new Apple(); // 向上转型
        fruit.show();   // 我苹果，打钱!
        fruit = new Banana();   // 向上转型
        fruit.show();   // 我香蕉，打钱!
        if (fruit instanceof Banana) {
            Banana banana = (Banana) fruit; // 向下转型
            banana.color(); // 我是黄色的香蕉。
        }
    }
}

注意：在进行向下转型之前，使用instanceof操作符进行检查是很重要的，否则，如果对象不是正确的类型，转型会抛出异常。

当使用instanceof关键字进行类型检查时，它会查看对象的运行时类型，而不是编译时类型。比如上面的例子中，fruit instanceof Banana这里fruit的引用在运行时指向一个Banana类型的对象，所以这个表达式的结果是true。简而言之，instanceof关键字总是基于对象的实际运行时类型来进行判断。

在向下转型中，子类引用指向父类对象（父类型，实例是子类的实例化），通常需要进行强制类型转换，但是这里有个需要注意的问题。

// 测试类
public class Test {
    public static void main(String[] args) {
        Fruits fruit = new Apple(); // 向上转型
        Apple apple = (Apple) fruit; // 向下转型，强制类型转换
        apple.color();  // 我是红色的苹果。

        Banana banana = (Banana) fruit; // 报错：java.lang.ClassCastException

        Fruits f1 = new Fruits();
        Apple a1 = (Apple) f1;  // 报错：java.lang.ClassCastException
    }
}

为什么Apple apple = (Apple)fruit;没有报错可以转换成功呢？因为apple本身就是Apple对象，所以理所当然可以向下转型为Apple，因此自然也就不能转换成Banana，人可以干出指鹿为马的事情，但是编译器不行，不会指着苹果说是香蕉。

而f1是Fruits对象，它也不能被向下转型为任何子类对象，就好比你买了一个不知名的水果，你只知道它是一种水果，但是你不能直接说这个水果是苹果或者香蕉。

总结一下向下转型需要注意的问题：

• 向下转型的前提是父类引用指向的是子类对象，也就是说，向下转型之前，它得先进行过向上转型。
• 向下转型只能转型为本类对象（苹果是不能变成香蕉的）。

最后来看一个多态的经典案例：

public class A {	// A类
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    }
}

public class B extends A {	// B类
    public String show(B obj){
        return ("B and B");
    }

    public String show(A obj) {
        return ("B and A");
    }
}

public class C extends B {	// C类
}

public class D extends B {	// D类
}

// 测试类
public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();

        System.out.println("1--" + a1.show(b));	// 1--A and A
        System.out.println("2--" + a1.show(c));	// 2--A and A
        System.out.println("3--" + a1.show(d));	// 3--A and D
        System.out.println("4--" + a2.show(b));	// 4--B and A
        System.out.println("5--" + a2.show(c));	// 5--B and A
        System.out.println("6--" + a2.show(d));	// 6--A and D
        System.out.println("7--" + b.show(b));	// 7--B and B
        System.out.println("8--" + b.show(c));	// 8--B and B
        System.out.println("9--" + b.show(d));	// 9--A and D
    }
}

前三条输出语句还好理解，从第四条开始，为什么不是输出4–B and B而是4–B and A呢？

网上博客给的一句话：当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在父类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括，其实在继承中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

这句话有点长，很抽象，我用最通俗易懂的来理解：

在这里，a2 是一个类型为 A 的引用，但它实际上引用的是一个 B 类型的对象。因此，当我们调用 a2.show(b) 时，以下是发生的事情：

1. 编译器首先查看引用 a2 的编译时类型，即 A。它会检查类 A 中是否有一个接受 B 类型参数的 show 方法。但是，类 A 中并没有明确接受 B 类型参数的 show 方法。因此，编译器会选择一个更为通用的版本，即 show(A obj)，因为 B 是 A 的子类。
2. 在运行时，JVM会查看a2实际引用的对象类型，即B。由于B类重写了show(A obj)方法，因此JVM会调用B类中的这个版本，即B and A。

换句话说，A a2 = new B();这行代码进行了向上转型，前面说过向上转型之后，子类单独定义的方法会丢失（即B类中的show(B obj)不能被调用），那么这个时候a2可以调用的方法就剩下A类中的show(D obj)、show(A obj)以及B类中的show(A obj)。然后再根据我们的口诀“编译时看左边，运行时看右边”，当运行时a2引用的就是B对象，故最终a2.show(b)就是在调用B类中的show(A obj)。

接下来再分析第五条a2.show(c)：

首先A a2 = new B();进行向上转型，那么，a2能调用的方法还是A类中的show(D obj)、show(A obj)以及B类中的show(A obj)，按照继承链中调用方法的优先级，a2是A类型的引用变量，所以继承链方法调用优先级中this.show(O)的this就代表了A，显然A类中的方法不满足这个要求，跳过，所以接下来是super.show(O)，A类没有父类（除了Object类），再次跳过，然后是this.show((super)O)，C继承于B，B继承于A，所以show(A obj)满足要求，由于a2变量引用的对象类型是B类型，而B类型又重写了该方法，所以最终调用的是B类中的show(A obj)，所以最后输出为B and A。

剩下的输出结果依次分析即可。

至此我们已经完整讲完Java多态机制，每天一个小知识点，每天进步一点点。