Java中多态以及原理

多态到底是什么,Java中的多态到底是如何实现的,参考了几篇文章,这里汇总一下。


多态经典例子

代码

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/**
* Author by darcy
* Date on 17-9-5 下午3:37.
* Description:
*
* http://blog.csdn.net/thinkGhoster/article/details/2307001
*
* A a2 = new B()
* a2.show(new B())
* a2.show(new C()) // 向上转型2次.
* a2.show(new D()) // 未转型之前调用父类方法(继承而来).
* 总的指导思路是先看是否重写了父类的相同签名的方法(方法名参数完全相同),如果重写了,
* 那么就利用多态的性质. 没有重写,但是父类中有相同签名的方法,那么就调用这个父类中这
* 个方法.(可以理解为引用为父类的类型调用自己的方法,也可以理解为子类继承了父类的该
* 方法进行调用);上面的两步都不满足, 那么将方法的传入参数向上转型为父类型,但是此时
* 的引用仍然绑定到子类类型上,所以仍然重重复上面这个过程, 即先查看是否Override
* (多态性质), 没有则看是否父类实现了转型为父类型的方法, 没有, 继续向上转型.
*/
class A {
public String show(D obj) {
return ("A and D");
}

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

class B extends A{
// A a = new B() a.show(B)不能直接调用这个方法, 因为这个方法并不是被Override的.
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 ABCDTest {
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)); // A and A
System.out.println("2--" + a1.show(c)); // A and A
System.out.println("3--" + a1.show(d)); // A and D
/*
a2.show(b),a2是一个引用变量,类型为A,则this为a2,b是B的一个实例,
于是它到类A里面找show(B obj)方法,没有找到,于是到A的super(超类)找,而A没有
超类,因此转到第三优先级this.show((super)O),this仍然是a2,这里O为B,
(super)O即(super)B即A,因此它到类A里面找show(A obj)的方法,类A有这个方法,
但是由于a2引用的是类B的一个对象,B覆盖了A的show(A obj)方法,因此最终锁定到
类B的show(A obj),输出为"B and A”。
*/
System.out.println("4--" + a2.show(b)); // B and A
System.out.println("5--" + a2.show(c)); // B and A
System.out.println("6--" + a2.show(d)); // A and D
System.out.println("7--" + b.show(b)); // B and B
/*
b.show(c),b是一个引用变量,类型为B,则this为b,c是C的一个实例,于是它到
类B找show(C obj)方法,没有找到,转而到B的超类A里面找,A里面也没有,因此也
转到第三优先级this.show((super)O),this为b,O为C,(super)O即(super)C即B,
因此它到B里面找show(B obj)方法,找到了,由于b引用的是类B的一个对象,因此直接
锁定到类B的show(B obj),输出为"B and B”。
*/
System.out.println("8--" + b.show(c)); // B and B *
System.out.println("9--" + b.show(d)); // A and D
/*
运行结果
1--A and A // 1
2--A and A // 2
3--A and D // 3
4--B and A // 4
5--B and A // 5
6--A and D // 6
7--B and B // 7
8--B and B // 8
9--A and D // 9
*/
}
}

解释

概念解释

  • ①②③比较好理解,一般不会出错。④⑤就有点糊涂了,为什么输出的不是”B and B”呢?!!先来回顾一下多态性。运行时多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。
  • 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写(Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
  • 当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。(但是如果强制把超类转换成子类的话,就可以调用子类中新添加而超类没有的方法了。)
  • 实际上这里涉及方法调用的优先问题,优先级由高到低依次为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。让我们来看看它是怎么工作的。

难点解释

  • 比如④,a2.show(b),a2是一个引用变量,类型为A,则this为a2,b是B的一个实例,于是它到类A里面找show(B obj)方法,没有找到,于是到A的super(超类)找,而A没有超类,因此转到第三优先级this.show((super)O),this仍然是a2,这里O为B,(super)O即(super)B即A,因此它到类A里面找show(A obj)的方法,类A有这个方法,但是由于a2引用的是类B的一个对象,B覆盖了A的show(A obj)方法,因此最终锁定到类B的show(A obj),输出为”B and A”。
  • 再比如⑧,b.show(c),b是一个引用变量,类型为B,则this为b,c是C的一个实例,于是它到类B找show(C obj)方法,没有找到,转而到B的超类A里面找,A里面也没有,因此也转到第三优先级this.show((super)O),this为b,O为C,(super)O即(super)C即B,因此它到B里面找show(B obj)方法,找到了,由于b引用的是类B的一个对象,因此直接锁定到类B的show(B obj),输出为”B and B”。

总结

  • 现在我们再来看上面的分析过程是怎么体现出粗体字体那句话的内涵的。它说:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。还是拿a2.show(b)来说吧。
    • a2是一个引用变量,类型为A,它引用的是B的一个对象,因此这句话的意思是由B来决定调用的是哪个方法。因此应该调用B的show(B obj)从而输出”B and B”才对。但是为什么跟前面的分析得到的结果不相符呢?问题在于我们不要忽略了粗体字体的后半部分,那里特别指明:这个被调用的方法必须是在超类中定义过的,也就是被子类覆盖的方法。B里面的show(B obj)在超类A中有定义吗?没有!那就更谈不上被覆盖了。实际上这句话隐藏了一条信息:它仍然是按照方法调用的优先级来确定的。它在类A中找到了show(A obj),如果子类B没有覆盖show(A obj)方法,那么它就调用A的show(A obj)(由于B继承A,虽然没有覆盖这个方法,但从超类A那里继承了这个方法,从某种意义上说,还是由B确定调用的方法,只是方法是在A中实现而已);现在子类B覆盖了 show(A obj),因此它最终锁定到B的show(A obj)。这就是那句话的意义所在。

多态的实现原理

Java多态概述

  • Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但可具有不同的参数列表、返回值类型。调用方法时通过传递的参数类型来决定具体使用哪个方法,这就是多态性。
  • Java的方法重写,是父类与子类之间的多态性,子类可继承父类中的方法,但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。重写的参数列表和返回类型均不可修改。

方法重写后的动态绑定

  • 多态允许具体访问时实现方法的动态绑定。Java对于动态绑定的实现主要依赖于方法表,通过继承和接口的多态实现有所不同。
    • 继承:在执行某个方法时,在方法区中找到该类的方法表,再确认该方法在方法表中的偏移量,找到该方法后如果被重写则直接调用,否则认为没有重写父类该方法,这时会按照继承关系搜索父类的方法表中该偏移量对应的方法。
    • 接口:Java 允许一个类实现多个接口,从某种意义上来说相当于多继承,这样同一个接口的的方法在不同类方法表中的位置就可能不一样了。所以不能通过偏移量的方法,而是通过搜索完整的方法表。

JVM的结构

  • 当程序运行需要某个类时,类加载器会将相应的class文件载入到JVM中,并在方法区建立该类的类型信息(包括方法代码,类变量、成员变量、以及方法表)。
  • 方法表是实现动态调用的核心。为了优化对象调用方法的速度,方法区的类型信息会增加一个指针,该指针指向记录该类方法的方法表,方法表中的每一个项都是对应方法的指针。这些方法中包括从父类继承的所有方法以及自身重写(override)的方法。

jvm-structure.png-82.3kB

Java 的方法调用方式

  • Java 的方法调用有两类,动态方法调用与静态方法调用。
    • 静态方法调用是指对于类的静态方法的调用方式,是静态绑定的;而动态方法调用需要有方法调用所作用的对象,是动态绑定的。
    • 类调用 (invokestatic) 是在编译时就已经确定好具体调用方法的情况。
    • 实例调用 (invokevirtual)则是在调用的时候才确定具体的调用方法,这就是动态绑定,也是多态要解决的核心问题。
  • JVM 的方法调用指令有四个,分别是 invokestatic,invokespecial,invokesvirtual 和 invokeinterface。前两个是静态绑定,后两个是动态绑定。

方法表和方法调用

demo

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
class Person {
public String toString() {
return "I'm a person.";
}

public void eat() {
}

public void speak() {
}

}

class Boy extends Person {
public String toString() {
return "I'm a boy";
}

public void speak() {
}

public void fight() {
}
}

class Girl extends Person {
public String toString() {
return "I'm a girl";
}

public void speak() {
}

public void sing() {
}
}

class Party {
void happyHour() {
Person girl = new Girl();
girl.speak();
}
}

public class PersonBoyGirl {
}
  • 当这三个类被载入到Java虚拟机之后,方法区中就包含了各自的类的信息。Girl和Boy在方法区中的方法表可表示如下

PersonGirlBoy.png-100.7kB

  • Girl 和 Boy 的方法表包含继承自Object的方法,继承自直接父类Person的方法及各自新定义的方法。注意方法表条目指向的具体的方法地址,如 Girl 继承自 Object 的方法中,只有 toString() 指向自己的实现(Girl 的方法代码),其余皆指向 Object 的方法代码;其继承自于 Person 的方法 eat() 和 speak() 分别指向 Person 的方法实现和本身的实现。
  • 如果子类改写了父类的方法,那么子类和父类的那些同名的方法共享一个方法表项。因此,方法表的偏移量总是固定的。所有继承父类的子类的方法表中,其父类所定义的方法的偏移量也总是一个定值。
  • Person 或 Object中的任意一个方法,在它们的方法表和其子类 Girl 和 Boy 的方法表中的位置 (index) 是一样的。这样 JVM 在调用实例方法其实只需要指定调用方法表中的第几个方法即可。

调用示意图

1
2
Person girl = new Girl();   
girl.speak(); }

InvokeVirtual.png-152.6kB

调用步骤

  • 在常量池(ClassReference常量池)中找到方法调用的符号引用 。
  • 查看Person的方法表,得到speak方法在该方法表的偏移量(假设为15),这样就得到该方法的直接引用。
  • 根据this指针得到具体的对象(即 girl 所指向的位于堆中的对象)。
  • 根据对象得到该对象对应的方法表,根据偏移量15查看有无重写(override)该方法,如果重写,则可以直接调用(Girl的方法表的speak项指向自身的方法而非父类);如果没有重写,则需要拿到按照继承关系从下往上的基类(这里是Person类)的方法表,同样按照这个偏移量15查看有无该方法。

接口调用

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
interface IDance{
void dance();
}

class Person2 {
public String toString(){
return "I'm a person.";
}
public void eat(){}
public void speak(){}

}

class Dancer extends Person2 implements IDance {
public String toString(){
return "I'm a dancer.";
}
public void dance(){}
}

class Snake implements IDance{
public String toString(){
return "A snake."; }
public void dance(){
//snake dance
}
}
public class IDancePerson {
}

方法表示意图

IDancePerson.png-119.8kB

  • 由于接口的介入,继承自接口IDance的方法dance()在类Dancer和Snake的方法表中的位置已经不一样了,显然我们无法仅根据偏移量来进行方法的调用。
  • Java 对于接口方法的调用是采用搜索方法表的方式,如,要在Dancer的方法表中找到dance()方法,必须搜索Dancer的整个方法表。
  • 因为每次接口调用都要搜索方法表,所以从效率上来说,接口方法的调用总是慢于类方法的调用的。

InvokeVirtual 和 InvokeSpecial


参考