Java方法调用解析静态分派动态分派执行过程

方法调用

在程序运行时,进行方法调用是最普遍,最频繁的操作

方法调用不等于方法执行:

方法调用阶段唯一的任务就是确定被调用的方法版本,即调用哪一个方法

不涉及方法内部的具体运行过程

Class文件的编译过程不包括传统编译中的连接步骤

Class文件中的一切方法调用在Class文件里面存储的都是符号引用,而不是方法在在实际运行时内存布局中的入口地址,即之前的直接引用:

这样使得Java具有更强大的动态扩展能力

同时也使得Java方法调用过程变得相对复杂

需要在类加载期间,甚至会到运行期间才能确定目标方法的直接引用

方法解析

所有方法调用中的目标方法在Class文件里都是一个常量池的引用

在类的加载解析阶段,会将其中的一部分符号引用转化为直接引用:

方法在程序真正执行之前就有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的

也就是说,调用目标在程序代码中完成,编译器进行编译时就必须确定下来,这也叫做方法解析

Java方法分类

在Java中符合 "编译期可知,运行期不可变" 的方法有两大类:

静态方法: 与类型直接关联

私有方法: 在外部不可被访问

这两种方法各自的特点决定这两种方法都不可能通过继承或者别的方式重写版本,因此适合在类加载阶段进行解析

非虚方法: 在类加载阶段会把符号引用解析为该方法的直接引用

静态方法

私有方法

实例构造器

父类方法

虚方法: 在类加载阶段不会将符号引用解析为该方法的直接引用

除去以上的非虚方法,其它的方法均为虚方法

静态分派

public class StaticDispatch {
static abstract class Human {
}
static class Man extends Human {
}
static class Woman extends Human {
}
public static void sayHello(Human guy) {
System.out.println("Hello, Guy!");
}
public static void sayHello(Man guy) {
System.out.println("Hello, Gentleman!");
}
public static void sayHello(woman guy) {
System.out.println("Hello, Lady!");
}
public static void main(String[] args) {
Human man = new Man();
Human women = new Woman();
sayHello(man);
sayHello(woman);
}
}

Human man = new Human();

Human为变量的静态类型

Man为变量的实际类型

静态类型和实际类型在程序中都会放生变化:

静态类型:

静态类型的变化仅仅在使用时发生

变量本身的静态类型不会被改变

最终的静态类型在编译器中可知

实际类型:

实际类型变化的结果在运行期才确定下来

编译器在编译期间并不知道一个对象的实际类型是什么

Human human = new Man();
sayHello(man);
sayHello((Man)man);// 类型转换,静态类型变化,转型后的静态类型一定是Man
man = new woman();// 实际类型变化,实际类型是不确定的
sayHello(man);
sayHello((Woman)man);// 类型转换,静态类型变化

编译器在重载时是通过参数的静态类型而不是实际类型作为判断依据,静态类型在编译期间可以知道:

编译阶段,Javac编译器会根据参数的静态类型决定使用哪个重载版本

静态分派:

所有依赖静态类型来定位方法的执行版本的分派动作

典型应用 :方法重载

静态分派发生在编译阶段,因此确定静态分派的的动作不是由虚拟机执行的,而是由编译器完成的

由于字面量没有显示静态类型,只能通过语言上的规则去理解和推断

public class LiteralTest {
public static void sayHello(char arg) {
System.out.println("Hello, char!");
}
public static void sayHello(int arg) {
System.out.println("Hello, int!");
}
public static void sayHello(long arg) {
System.out.println("Hello, long!");
}
public static void sayHello(Character arg) {
System.out.println("Hello, Character!");
}
public static void main(String[] arg) {
sayHello('a');
}
}

编译器将重载方法从上向下依次注释,得到不同的输出

如果编译器无法确定要自定转型为哪种类型,会提示类型模糊,拒绝编译

public class LiteralTest {
public static void sayHello(String arg) {// 新增重载方法
System.out.println("Hello, String!");
}
public static void sayHello(char arg) {
System.out.println("Hello, char!");
}
public static void sayHello(int arg) {
System.out.println("Hello, int!");
}
public static void sayHello(long arg) {
System.out.println("Hello, long!");
}
public static void sayHello(Character arg) {
System.out.println("Hello, Character!");
}
public static void main(String[] args) {
Random r = new Random();
String s = "abc";
int i = 0;
sayHello(r.nextInt() % 2 != 0 ? s : 1 );// 编译错误
sayHello(r.nextInt() % 2 != 0 ? 'a' : false);//编译错误
}
}

动态分派

public class DynamicDispatch {
static abstract class Human {
protected abstract void sayHello();
}
static class Man extends Human {
@override
protected void sayHello() {
System.out.println("Man Say Hello!");
}
}
static class Woman extends Human {
@override
protected void sayHello() {
System.out.println("Woman Say Hello!");
}
}
public static void main(String[] args) {
Human man = new Man();
Human women = new Woman();
man.sayHello();
woman.sayHello();
man = new Woman();
man.sayHello();
}
}

这里不是根据静态类型决定的

静态类型的Human两个变量man和woman在调用sayHello() 方法时执行了不同的行为

变量man在两次调用中执行了不同的方法

导致这个现象的额原因 :这两个变量的实际类型不同

Java虚拟机是如何根据实际类型分派方法的执行版本的: 从invokevirtual指令的多态查找过程开始 ,invokevirtual指令运行时解析过程大致分为以下几个步骤:

找到操作数栈顶的第一个元素所指向的对象的实际类型,记作C

如果在类型C中找到与常量中的描述符和简单名称相符合的方法,然后进行访问权限验证,如果验证通过则返回这个方法的直接引用,查找过程结束;如果验证不通过,则抛出java.lang.illegalAccessError异常

如果未找到,就按照继承关系从下往上依次对类型C的各个父类进行第二步的搜索和验证过程

如果始终没有找到合适的方法,则抛出java.lang.AbstractMethodError异常

Java语言方法重写的本质:

invokevirtual指令执行的第一步就是在运行时期确定接收者的实际类型,所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上

这种在运行时期根据实际类型确定方法执行版本的分派过程就叫做动态分派