Java中的方法调用
程序员文章站
2022-07-13 16:02:01
...
今天遇到一个问题：子类重写父类中的方法之后，后期虚拟机是如何确定要执行的方法？
要解决上面的那个问题，我们先来看看Java中的方法调用。方法调用并不等同于方法执行，方法调用阶段唯一的任务就是确定被调用方法的版本（即要执行哪一个方法），他还不会设计方法内部的具体运行过程。
所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中一部分的符号引用转换为直接引用。这种解析能够成立的前提是：方法在程序可以运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。换句话说，调用目标在程序代码写好，编译器进行
编译时就必须确定下来，这类方法的调用称为解析。
Java语言中符合“编译期可知，运行期不可变”的方法主要包括静态方法和私有方法两大类。前者直接和类型关联，后者在外部不可访问。他们的特点都决定了他们不可能通过继承或者别的方式重写其他版本（注：前面一篇文章中已经指出父类的private成员是不会被子类继承的），因此他们是和在类加载阶段解析（将符号引用解析为直接引用）。与之对应的是，在Java虚拟机中提供了5条调用字节码指令，分别如下：
a) invokestatic：调用静态方法；
b) invokespecial：调用实例构造器<init>方法、私有方法和父类方法
c) invokevirtual：调用所有的虚方法
d) invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象
e) invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。
只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段确定唯一的调用版本，符合这个条件的有：静态方法，私有方法，实例构造器(也属于static方法)、父类方法。他们也被称为非虚方法。
看一个例子：
public class StaticResolution {
public static void sayHello() {
System.out.println("Hello");
}
public static void main(String[] args) {
StaticResolution.sayHello();
}
}
使用javap命令反汇编之后的字节码如下：命令：javap -verbose StaticResolution;
Classfile /C:/Users/Administrator/Desktop/TempFiles/StaticResolution.class
Last modified 2016-7-21; size 498 bytes
MD5 checksum 6843913113abaaced35c02b2c718f3f6
Compiled from "StaticResolution.java"
public class StaticResolution
SourceFile: "StaticResolution.java"
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #7.#17 // java/lang/Object."<init>":()V
#2 = Fieldref #18.#19 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #20 // Hello
#4 = Methodref #21.#22 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = Methodref #6.#23 // StaticResolution.sayHello:()V
#6 = Class #24 // StaticResolution
#7 = Class #25 // java/lang/Object
#8 = Utf8 <init>
#9 = Utf8 ()V
#10 = Utf8 Code
#11 = Utf8 LineNumberTable
#12 = Utf8 sayHello
#13 = Utf8 main
#14 = Utf8 ([Ljava/lang/String;)V
#15 = Utf8 SourceFile
#16 = Utf8 StaticResolution.java
#17 = NameAndType #8:#9 // "<init>":()V
#18 = Class #26 // java/lang/System
#19 = NameAndType #27:#28 // out:Ljava/io/PrintStream;
#20 = Utf8 Hello
#21 = Class #29 // java/io/PrintStream
#22 = NameAndType #30:#31 // println:(Ljava/lang/String;)V
#23 = NameAndType #12:#9 // sayHello:()V
#24 = Utf8 StaticResolution
#25 = Utf8 java/lang/Object
#26 = Utf8 java/lang/System
#27 = Utf8 out
#28 = Utf8 Ljava/io/PrintStream;
#29 = Utf8 java/io/PrintStream
#30 = Utf8 println
#31 = Utf8 (Ljava/lang/String;)V
{
public StaticResolution();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
public static void sayHello();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hello
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 3: 0
line 4: 8
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=0, locals=1, args_size=1
0: invokestatic #5 // Method sayHello:()V
3: return
LineNumberTable:
line 6: 0
line 7: 3
}
在main()方法中使用invokestatic指令调用了static方法。
注：Java中的非虚方法除了使用invokestatic、invokespecial调用的方法之外还有另外一种，就是被final修饰的方法，虽然它是使用invokevirtual指令调用的，但是由于无法被覆盖，没有其他版本，所以也无需对方法进行多态选择，所以也是非虚方法。。
总的来说：解析调用一定是一个静态的过程。在编译期间就完全确定，在类装载的解析阶段就把涉及的所有符号引用全部转换称为可确定的直接引用，不会到运行期再去完成。
与之不同的是，分派既可能是静态的也可能是动态的。
我们先来看一下静态分派：下面是一段程序代码，并猜一下输出是什么：
package com.demo.org;
public class StaticDispatch {
static abstract class Human {}
static class Man extends Human {}
static class Woman extends Human {}
public void sayHello(Human guy) {
System.out.println("Hello, guy");
}
public void sayHello(Man man) {
System.out.println("Hello, gentleman");
}
public void sayHello(Woman woman) {
System.out.println("Hello, lady");
}
public static void main(String[] args) {
Human man = new Man();
Human woman = new Woman();
StaticDispatch sr = new StaticDispatch();
sr.sayHello(man);
sr.sayHello(woman);
}
}
输出结果：
Hello, guy
Hello, guy
有些人感觉很奇怪，不应该是根据引用实际指向的对象类型去调用不同的方法吗？在解决这两个问题之前，我们要先了解两个重要概念：
Human man = new Man();
上面的Human称为变量的静态类型，或者叫做外观类型；后面的Man则称为变量的实际类型。静态类型和实际类型在程序中都可以发生一些变化，区别是：静态类型的变化仅仅在使用时发生，变量本身的静态类型不会改变，并且最终的静态类型是在编译期可知的；而实际类型变化的结果是在运行期才可确定，编译的时候是不知道实际类型是什么的。
// 实际类型变化
Human man = new Man();
man = new Woman();
// 静态类型变化
sr.sayHello((Man) man);
sr.sayHello((Woman) man);
了解了这两个概念，再回头看前面的两次方法调用，在已经确定接收者是sr的前提下，使用哪个重载版本，就完全取决于传入参数的数量和数据类型。
代码中可以定义了两个静态类型相同但实际类型不同的变量，但虚拟机（准确的说是编译器）在重载时是通过静态类型而不是实际类型作为依据的。并且静态类型是在编译期已经确定的，因此调用哪个重载方法已经是在编译期间确定了的（根据静态类型选择）。
我们再从字节码的角度看下：
Constant pool:
#1 = Methodref #14.#32 // java/lang/Object."<init>":()V
#2 = Fieldref #33.#34 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #35 // Hello, guy
#4 = Methodref #36.#37 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = String #38 // Hello, gentleman
#6 = String #39 // Hello, lady
#7 = Class #40 // StaticDispatch$Man
#8 = Methodref #7.#32 // StaticDispatch$Man."<init>":()V
#9 = Class #41 // StaticDispatch$Woman
#10 = Methodref #9.#32 // StaticDispatch$Woman."<init>":()V
#11 = Class #42 // StaticDispatch
#12 = Methodref #11.#32 // StaticDispatch."<init>":()V
#13 = Methodref #11.#43 // StaticDispatch.sayHello:(LStaticDispatch$Human;)V
#14 = Class #44 // java/lang/Object
#15 = Utf8 Woman
#16 = Utf8 InnerClasses
#17 = Utf8 Man
#18 = Class #45 // StaticDispatch$Human
#19 = Utf8 Human
#20 = Utf8 <init>
#21 = Utf8 ()V
#22 = Utf8 Code
#23 = Utf8 LineNumberTable
#24 = Utf8 sayHello
#25 = Utf8 (LStaticDispatch$Human;)V
#26 = Utf8 (LStaticDispatch$Man;)V
#27 = Utf8 (LStaticDispatch$Woman;)V
#28 = Utf8 main
#29 = Utf8 ([Ljava/lang/String;)V
#30 = Utf8 SourceFile
#31 = Utf8 StaticDispatch.java
#32 = NameAndType #20:#21 // "<init>":()V
#33 = Class #46 // java/lang/System
#34 = NameAndType #47:#48 // out:Ljava/io/PrintStream;
#35 = Utf8 Hello, guy
#36 = Class #49 // java/io/PrintStream
#37 = NameAndType #50:#51 // println:(Ljava/lang/String;)V
#38 = Utf8 Hello, gentleman
#39 = Utf8 Hello, lady
#40 = Utf8 StaticDispatch$Man
#41 = Utf8 StaticDispatch$Woman
#42 = Utf8 StaticDispatch
#43 = NameAndType #24:#25 // sayHello:(LStaticDispatch$Human;)V
#44 = Utf8 java/lang/Object
#45 = Utf8 StaticDispatch$Human
#46 = Utf8 java/lang/System
#47 = Utf8 out
#48 = Utf8 Ljava/io/PrintStream;
#49 = Utf8 java/io/PrintStream
#50 = Utf8 println
#51 = Utf8 (Ljava/lang/String;)V
{
public StaticDispatch();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
line 4: 4
public void sayHello(StaticDispatch$Human);
descriptor: (LStaticDispatch$Human;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hello, guy
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 7: 0
line 8: 8
public void sayHello(StaticDispatch$Man);
descriptor: (LStaticDispatch$Man;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #5 // String Hello, gentleman
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 11: 0
line 12: 8
public void sayHello(StaticDispatch$Woman);
descriptor: (LStaticDispatch$Woman;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String Hello, lady
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 15: 0
line 16: 8
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=4, args_size=1
0: new #7 // class StaticDispatch$Man
3: dup
4: invokespecial #8 // Method StaticDispatch$Man."<init>":()V
7: astore_1
8: new #9 // class StaticDispatch$Woman
11: dup
12: invokespecial #10 // Method StaticDispatch$Woman."<init>":()V
15: astore_2
16: new #11 // class StaticDispatch
19: dup
20: invokespecial #12 // Method "<init>":()V
23: astore_3
24: aload_3
25: aload_1
26: invokevirtual #13 // Method sayHello:(LStaticDispatch$Human;)V
29: aload_3
30: aload_2
31: invokevirtual #13 // Method sayHello:(LStaticDispatch$Human;)V
34: return
LineNumberTable:
line 18: 0
line 19: 8
line 20: 16
line 21: 24
line 22: 29
line 23: 34
}
0-23行属于准备阶段，主要是执行构造器方法，创建变量（从虚拟机的角度是作用是建立man和woman的内存空间、调用Man和Woman以及StaticDispatch类型的构造器，然后将这三个实例的引用存放在第1、2、3个局部变量表slot中），第24行将栈顶元素出栈，然后再将第一个对象出栈，然后使用invokevirtual指令调用方法，该方法指向常量池中第13行的记录，也即Human中的方法。
下面再说一下动态分派，他和多态的另外一个重要体现——重写有着密切的关联。接着看下面的一个演示示例：
public class DynamicDispatch {
static abstract class Human {
public abstract void sayHello();
}
static class Man extends Human {
@Override
public void sayHello() {
System.out.println("Hello man");
}
}
static class Woman extends Human {
@Override
public void sayHello() {
System.out.println("Hello woman");
}
}
public static void main(String[] args) {
Human man = new Man();
Human woman = new Woman();
man.sayHello();
woman.sayHello();
man = new Woman();
man.sayHello();
}
}
// 输出结果：
Hello man
Hello woman
Hello woman
看到这个结果，有些人可能感觉理所当然，这符合多态的特点。但是有些人可能还是会觉得有些不对。从结果中也可以看出，这里不可能再是根据静态类型来决定，因为静态类型的man和woman在调用sayHello()方法的时候体现了不同的行为，并且变量man在两次调用中执行了不同的方法。导致这个的原因很明显，他们的实际类型不同。我们再次使用javap命令将代码进行反汇编：
Constant pool:
#1 = Methodref #8.#22 // java/lang/Object."<init>":()V
#2 = Class #23 // DynamicDispatch$Man
#3 = Methodref #2.#22 // DynamicDispatch$Man."<init>":()V
#4 = Class #24 // DynamicDispatch$Woman
#5 = Methodref #4.#22 // DynamicDispatch$Woman."<init>":()V
#6 = Methodref #12.#25 // DynamicDispatch$Human.sayHello:()V
#7 = Class #26 // DynamicDispatch
#8 = Class #27 // java/lang/Object
#9 = Utf8 Woman
#10 = Utf8 InnerClasses
#11 = Utf8 Man
#12 = Class #28 // DynamicDispatch$Human
#13 = Utf8 Human
#14 = Utf8 <init>
#15 = Utf8 ()V
#16 = Utf8 Code
#17 = Utf8 LineNumberTable
#18 = Utf8 main
#19 = Utf8 ([Ljava/lang/String;)V
#20 = Utf8 SourceFile
#21 = Utf8 DynamicDispatch.java
#22 = NameAndType #14:#15 // "<init>":()V
#23 = Utf8 DynamicDispatch$Man
#24 = Utf8 DynamicDispatch$Woman
#25 = NameAndType #29:#15 // sayHello:()V
#26 = Utf8 DynamicDispatch
#27 = Utf8 java/lang/Object
#28 = Utf8 DynamicDispatch$Human
#29 = Utf8 sayHello
{
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=3, args_size=1
0: new #2 // class DynamicDispatch$Man
3: dup
4: invokespecial #3 // Method DynamicDispatch$Man."<init>":()V
7: astore_1
8: new #4 // class DynamicDispatch$Woman
11: dup
12: invokespecial #5 // Method DynamicDispatch$Woman."<init>":()V
15: astore_2
16: aload_1
17: invokevirtual #6 // Method DynamicDispatch$Human.sayHello:()V
20: aload_2
21: invokevirtual #6 // Method DynamicDispatch$Human.sayHello:()V
24: new #4 // class DynamicDispatch$Woman
27: dup
28: invokespecial #5 // Method DynamicDispatch$Woman."<init>":()V
31: astore_1
32: aload_1
33: invokevirtual #6 // Method DynamicDispatch$Human.sayHello:()V
36: return
LineNumberTable:
line 18: 0
line 19: 8
line 20: 16
line 21: 20
line 22: 24
line 23: 32
line 24: 36
}
0-15行的字节码是准备动作，作用是建立man和woman的内存空间、调用Man和Woman类型的构造器，将这两个实例的引用存放在第1、2个局部变量表slot中。（注：他其实对应了两个创建对象的语句）；
接下来的16-21行是最关键的地方，16、20两行将刚创建的两个对象的引用压到栈顶，这两个对象是即将执行的sayHello方法的所有者，称为接收者。17和21行是方法调用指令，无论是指令（都是invokevirtual）还是参数（都是常量池中第6项中的常量，注释显示了这个常量是Human.sayHello()的符号引用）完全一样的，但是这两句指令最终执行的目标方法不同。原因要从invokevirtual指令的多态查找过程开始说起。
invokevirtual指令的运行时解析过程大概是分为以下几个步骤：
a) 找到操作数栈顶的第一个元素所指向的对象的实际类型，记作C；
b) 如果在类型C中找到与常量中的描述符和简单名称都相同的方法，则进行访问权限的校验，如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError异常；
c) 否则按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
d) 如果始终没找到合适的方法，则抛出java.lang.AbstractMethodError.
由于invokevirtual指令的第一步就是在运行时期确定接受者的实际类型，所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上，这个过程就是Java语言中方法重写的本质。
注：以上绝大部分内容都是参照或直接引用深入理解Java虚拟机一书中的内容，在此表示感谢。
上一篇： 重载+运算符 javaString
下一篇： SQL 中的exists关键字