多态中的向上转型与向下转型

什么是多态？

多态（Polymorphism）即同一操作作用于不同的对象，可以有不同的解释，产生不同的结果。

多态的分类

多态一般分为两种：

重载式多态

  • 重载式多态，也叫编译时多态。也就是说这种多态在编译时已经确定好了。方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。

重写式多态

  • 重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。这种多态通过函数的重写以及向上转型来实现。

多态实现的必要条件

  1. 继承或实现接口

在多态中必须存在有继承关系的子类和父类或者接口及其实现类

  1. 重写

子类对父类中某些方法进行重新定义，再调用这些方法时就会调用子类的方法

  1. 向上转型

父类引用指向子类对象叫做向上转型。

向上转型与向下转型

向上转型，上面已经说了。向下转型是子类引用指向父类对象（父类型，实例是子类的实例化），通常需要进行强制类型转换。

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//水果类，拥有一个show()方法
class Fruits {

    public void show() {
        System.out.println("我水果之父，打钱!");
    }

}
// 苹果类，实现父类水果，并重写show()方法
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()会报错。

向下转型

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 //还是上面的Fruits、Apple、Banana
 
 Fruits fruit = new Apple(); //向上转型
 
 Apple apple = (Apple) fruit; //向下转型，强制类型转换
子类类型 子类引用名 = (子类类型) f 

 apple.color();  //输出：我是红色的苹果。
 
 Banana banana = (Banana) fruit; //报错：java.lang.ClassCastException
// fruit向上转型是Apple类，向下转型回去也必须是Apple类
 
 Fruits f1 = new Fruits();
 
 Apple a1 = (Apple) f1;  //报错：java.lang.ClassCastException

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

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

向下转型需要注意的问题

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

多态的经典案例

简单的多态和转型，相信大家都会，最后来个复杂的，一个经典案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
class A {
    public String show(D obj) {
        return ("A and D");
    }

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

}

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

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

class C extends B{

}

class D extends B{

}

public class Demo {
    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));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}

/**
输出结果：
    1--A and A
    2--A and A
    3--A and D
    4--B and A
    5--B and A
    6--A and D
    7--B and B
    8--B and B
    9--A and D
*/

结果1、2、3还好理解，从4开始就糊涂了，4为什么不是“B and B”呢？

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

现在来分析一下4，a2.show(b)：

  • a2是A类型的引用变量，this就代表了A，但是a2所引用的是B对象（new B()），那么按照上面那句话的意思，a2.show(b)就应该要调用B类中的show(B obj)，产生的结果就是”B and B“，但是运行结果明显不是，别忘了上面的话后面还有一句，必须是父类中定义过的方法才行，然而B的父类A中并没有show(B obj)，难道上面的话是错误的？其实不是，因为它仍然要按照继承链中调用方法的优先级来确定，所以它才会在A类中找到show(A obj)，由于B中重写了该方法，所以才会调用B类中的方法，所以得到的结果是B and A。
  • 上面的解释可能有点绕，很多大佬在博客中也是这么写的，现在我来说说自己的理解。A a2 = new B();这行代码进行了向上转型，前面说过向上转型之后，子类单独定义的方法会丢失（不能被调用），那么这个时候a2可以调用的方法就剩下A类中的show(D obj)、show(A obj)以及B类中的show(A obj)，那么按照继承链中调用方法的优先级来判断，先到类A中找到show(A obj)，由于B类中进行了重写 ，所以调用的是B类中的show(A obj)。

那么按照我的理解，来分析下5，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。

能够分析出4和5，那么接下来的就很简单了