JVM之方法调用(重写、重载的本质)（基于《深入理解Java虚拟机》之第八章虚拟机字节码执行引擎）（中）

slow is fast.

已于 2022-04-05 18:47:29 修改

阅读量548

点赞数 3

分类专栏： # 重拳出击之《JVM》篇文章标签： java jvm 方法调用动态语言

于 2021-07-22 13:46:52 首次发布

本文链接：https://blog.csdn.net/wwj17647590781/article/details/118996720

版权

重拳出击之《JVM》篇专栏收录该内容

21 篇文章 15 订阅

订阅专栏

aas 方法调用并不等同于方法中的代码被执行，方法调用阶段唯一的任务就是确定被调用方法的版本（即调用哪一个方法），暂时还未涉及方法内部的具体运行过程。
asdsadasdasdasdsadasdasdasdsadassdasdsasdsadsdasdasdsadasdasdsadasdsadassadasdas————《Java虚拟机规范》

方法调用之方法解析
方法调用之方法分派

方法调用之方法解析

方法调用到底指什么呢？
aa
aas 就如文章开头所言，方法调用阶段的唯一任务就是确定被调用哪个方法。并没有涉及到方法内部的具体运行过程。
aa
方法调用到为什么复杂呢？为什么具有动态扩展能力呢？
aa
aas 因为一切方法的调用在Class文件里面存储的都只是符号引用(间接引用)，而不是方法在实际运行时内存布局中的入口地址。某些调用需要在类加载时期甚至运行期间才能确定目标方法的直接引用。
aas[注]： Class文件的编译过程中不包含传统编译中的连接步骤。
aa
类加载的哪个阶段可以进行方法调用呢(间接引用—>直接引用)？
aa
aas上面的问题我们可以得知，所有方法调用的目标方法在Class文件里面都是一个常量池的符号引用。在类加载的解析阶段，我们会将其中的一部分符号引用转化为直接引用( 另一部分需要到运行阶段才能确定)。
aas[注]：在解析阶段能够进行转化的前提条件：方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。换句话说，调用目标在程序代码写好、编译器进行编译那一刻就已经确定下来。这类方法的调用被称为解析。
aa
在JVM中支持几种方法调用的字节码指令？ (五种)
aa
aas①、invokestatic: 调用静态方法：
aas②、invokespecial：用于调用实例构造器< init >()方法、私有方法和父类中的方法。
aas③、invokevirtual：调用所有的虚方法；
aas④、invokeinterface：调用接口方法，会在运行时再确定一个实现该接口的对象。
aas⑤、invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。
aas[注]：
aas①、前面4条调用指令、分派逻辑都固化在JVM内部，最后一条的分派逻辑由用户设定的引导方法来决定。
aas②、只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段中确定唯一的调用版本。
aa
什么样的方法适合在类加载的解析阶段进行解析呢？(五种)
aa
aas只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段中确定唯一的调用版本。
aas①、静态方法 ②、私有方法。
aas前者与类型直接关联，后者在外部不能访问，因此它们都不能通过继承或别的方式重写出其他版本，因此都适合在类加载阶段进行解析。
aas③、实例构造器 ④、父类方法
aas⑤、被final修饰的方法(尽管它使用invokevirtual指令调用)
aas[注]：
aas①、这五种方法调用都能在类加载的解析阶段把符号引用解析为该方法的直接引用。
aas②、虚拟机层面：这五种方法统称为"非虚"方法。而Java语言层面：Java对象里面的方法默认（即不使用final修饰）就是虚方法(还是记前者吧)。

静态方法调用如下：

/**
* 方法静态解析演示
*/
public class StaticResolution {
	public static void sayHello() {
		System.out.println("hello world");
	}
	public static void main(String[] args) {
	StaticResolution.sayHello();
	}
}

使用javap命令查看这段程序对应的字节码：

javap -verbose StaticResolution
public static void main(java.lang.String[]);
	Code:
		Stack=0, Locals=1, Args_size=1
		0: invokestatic 	#31; //Method sayHello:()V
		3: return
		LineNumberTable:
		line 15: 0
		line 16: 3

分析：通过invokestatic命令来调用sayHello()方法，而且其调用的方法版本已经在编译时就明确以常量池项的形式固化在字节码指令的参数(操作数)之中。
aa
类加载的解析阶段是动态还是静态的？
aa
aas解析调用一定是个静态的过程，在编译期间就完全确定，在类加载的解析阶段就会把涉及的符号引用全部转变为明确的直接引用，不必延迟到运行期再去完成。
aas而另一种主要的方法调用形式：分派。
aa
分派是静态的还是动态的？
aa
aas它可能是静态的也可能是动态的，按照分派依据的宗量数可分为单分派和多分派。这两类分派方式两两组合就构成了静态单分派、静态多分派、动态单分派、动态多分派4种分派组合情况。

方法调用之方法分派

aasJava具备面向对象的三个基本特征：继承、封装、多态。而我们将要分析的方法分派将会体现出一些多态性特征(“重载”、“重写”)。

静态分派

aas所有依赖静态类型来决定方法执行版本的分派动作，都称为静态分派。
aas静态分派的最典型应用表现就是方法重载。因此虚拟机(准确的说是编译器)在重载时是通过参数的静态类型而不是实际类型作为判断依据的。
aas静态分派发生在编译阶段，因此确定静态分派的动作实际上不是由虚拟机来执行的。
aasdasdsadasdsadasdsadsadsadasddasdsadas方法静态分派演示(重载)

package org.fenixsoft.polymorphic;

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 guy) {
		System.out.println("hello,gentleman!");
	}
	public void sayHello(Woman guy) {
		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!

aas 在分析前我们先看两个关键概念：
aasdasdsadasdsadasdsadsadsadasddasdsadasHuman man = new Man()
aas
aasdasdsaddasddassadsds“Human”称为变量的“静态类型”，“Man”则被称为变量的“实际类型(运行时类型)”
aas静态类型和实际类型在程序中都可能会发生变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且 最终的静态类型是在编译期可知的；而实际类型变化的结果在运行期才可确定，编译器在编译程序的时候并不知道一个对象的实际类型是什么。
aas通过一个例子我们进一步分析：

// 实际类型变化
Human human = (new Random()).nextBoolean() ? new Man() : new Woman();
// 静态类型变化
sr.sayHello((Man) human)  //输出：hello,gentleman!
sr.sayHello((Woman) human) //输出：hello,lady!

aas对象human的实际类型是可变的，它的实际类型就是"薛定谔的猫"我们无法确定它到底是Man()还是Women()，只有等到程序运行起来我们才能确定。但是我们可以在编译期间对静态类型进行强制转型。说到这里我们就可以知道上述结果了。
aas
结果分析： Javac编译器根据参数的静态类型决定了会使用哪个重载版本，因此选择了sayHello(Human)作为调用目标，并把这个方法的符号引用写到main()方法里的两条invokevirtual指令的参数中。
aas【注】：
aasdasas①、Javac编译器虽然能确定出方法的重载版本，但在很多情况下这个重载版本并不是“唯一”的，往往只能确定一个“相对更合适的”版本。
aasdasas②、重载方法匹配优先级：（代码演示）

package org.fenixsoft.polymorphic;
public class Overload {
	public static void sayHello(Object arg) {
		System.out.println("hello Object");
	}
	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 sayHello(char arg) {
		System.out.println("hello char");
	}
	public static void sayHello(char... arg) {
		System.out.println("hello char ...");
	}
	public static void sayHello(Serializable arg) {
		System.out.println("hello Serializable");
	}
	public static void main(String[] args) {
	sayHello('a');
	}
}

as输出顺序：⒈hello char
aasdasdasd s⒉hello int（‘a’除了表示字符还有字符串和数值，符’a’的Unicode数值为十进制数字97）
aasdasdasd s⒊hello long（'a’转型为整数97之后，进一步转型为长整数97L，匹配了参数类型为long的重载，按照char>int>long>float>double的顺序转型进行匹配，但不会匹配到byte和short类型的重载，因为char到byte或short的转型是不安全的）
aasdasdasd s⒋hello Character（自动装箱，'a’被包装为它的封装类型java.lang.Character）
aasdasdasd s⒌hello Serializable（输出序列化，因为java.lang.Serializable是 java.lang.Character类实现的一个接口，当自动装箱之后发现还是找不到装箱类，但是找到了装箱类所实现的接口类型，所以紧接着又发生一次自动转型。注意两点：
aasdasasddasd s㈠、Character不会转型为Integer的，它只能安全地转型为它实现的接口或父类。
aasdasasddasd s㈡、如果同时出现两个参数分别为SerializableComparable< Character >的重载方法，那它们在此时的优先级是一样的。编译器无法确定要自动转型为哪种类型，会提示“类型模糊”（Type Ambiguous），并拒绝编译。程序必须在调用时显式地指定字面量的静态类型，如：sayHello((Comparable< Character >)‘a’)。但是如果绕过编译器，构造出语义相同的字节码，是能通过类加载校验的并且能被正常执行，但是会选择谁并不能事先确定）。
aasdasdasd s⒍hello Object （这时是char装箱后转型为父类了，如果有多个父类，那将在继承关系中从下往上开始搜索，越接上层的优先级越低。）
aasdasdasd s⒎hello char … （可见变长参数的重载优先级是最低的，这时候字符’a’被当作了一个char[]数组的元素，有一些在单个参数中能成立的自动转型，如char转型为int，在变长参数中是不成立的。）
aas
as总结：单个参数的重载方法优先级为：当前参数类型的类型>往大转型>封装>装箱类的接口方法>装箱后的父类>可见变长参数。
aas
s解析与分派之间的关系：
aas
aas不是对立关系，而是在不同角度去筛选、确定目标方法的过程。例如前面说过静态方法会在编译器确定、在类加载阶段进行解析，而静态方法显然也是可以拥有重载版本的，选择重载版本的过程也是通过静态分派完成的。

动态分派

aas在运行期根据实际类型确定方法执行版本的分派过程称为动态分派。
aas动态分派的最典型应用表现就是方法重写(Override)。
aasdasdsadasdsadasdsadsadsadasddasdsadas方法动态分派演示(重写)

package org.fenixsoft.polymorphic;

	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 woman = new Woman();
		man.sayHello();
		woman.sayHello();
		man = new Woman();
		man.sayHello();
	}
}

运行结果：

man say hello
woman say hello
woman say hello

结果分析： 导致这个现象的原因很明显，是因为这两个变量的实际类型不同，Java虚拟机是如何根据实际类型来分派方法执行版本的呢？我们使用javap命令输出main()方法的字节码：

public static void main(java.lang.String[]);
	Code:
		Stack=2, Locals=3, Args_size=1
		0: new #16; //class org/fenixsoft/polymorphic/DynamicDispatch$Man
		3: dup
		4: invokespecial #18; //Method org/fenixsoft/polymorphic/Dynamic Dispatch$Man."<init>":()V
		7: astore_1
		-----------------------------------------------------------------------------------------------
		8: new #19; //class org/fenixsoft/polymorphic/DynamicDispatch$Woman
		11: dup
		12: invokespecial #21; //Method org/fenixsoft/polymorphic/DynamicDispatch$Woman."<init>":()V
		15: astore_2
		-----------------------------------------------------------------------------------------------
		16: aload_1
		17: invokevirtual #22; //Method org/fenixsoft/polymorphic/Dynamic Dispatch$Human.sayHello:()V
		20: aload_2
		21: invokevirtual #22; //Method org/fenixsoft/polymorphic/Dynamic Dispatch$Human.sayHello:()V
		-----------------------------------------------------------------------------------------------
		24: new #19; //class org/fenixsoft/polymorphic/DynamicDispatch$Woman
		27: dup
		28: invokespecial #21; //Method org/fenixsoft/polymorphic/DynamicDispatch$Woman."<init>":()V
		31: astore_1
		-----------------------------------------------------------------------------------------------
		32: aload_1
		33: invokevirtual #22; //Method org/fenixsoft/polymorphic/Dynamic Dispatch$Human.sayHello:()V
		36: return

字节码分析：
aas①、0~15行：建立man和woman的内存空间、调用Man和Woman类型的实例构造器，将这两个实例的引用存放在第1、2个局部变量表的变量槽中，对应于源码中的：

		Human man = new Man();
		Human woman = new Woman();

aas②、第16、20行：16和20行的aload指令分别把刚刚创建的两个对象的引用压到栈顶，这两个对象是将要执行的sayHello()方法的所有者，称为接收者（Receiver）；
aas③、第17、21行：方法调用指令，这两条调用指令单从字节码角度来看，无论是指令（都是invokevirtual）还是参数（都是常量池中第22项的常量，注释显示了这个常量是Human.sayHello() 的符号引用）都完全一样，但是这两句指令最终执行的目标方法并不相同。因此要弄清楚它们的不同，还是要看 invokevirtual 指令。
aa
invokevirtual指令的运行时解析过程大致分为以下几步：
aasa①、找到操作数栈顶的第一个元素所指向的对象的实际类型，记作C。
aasa②、如果在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束；不通过则返回java.lang.IllegalAccessError异常。
aasa③、否则，按照继承关系从下往上依次对C的各个父类进行第二步的搜索和验证过程。
aasa④、如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。
aa
aasa正是因为invokevirtual指令执行的第一步就是在运行期确定接收者的实际类型，所以两次调用中的invokevirtual指令并不是把常量池中方法的符号引用解析到直接引用上就结束了，还会根据方法接收者的实际类型来选择方法版本，这个过程就是Java语言中 方法重写的本质。
aasa【注】：既然这种多态性的根源在于虚方法调用指令invokevirtual的执行逻辑，那自然我们得出的结论就只会对方法有效，对字段是无效的，因为字段不使用这条指令。并且只有虚方法的存在，没有虚字段的存在。即，字段永远不参与多态。当子类声明了与父类同名的字段时，虽然在子类的内存中两个字段都会存在，但是子类的字段会遮蔽父类的同名字段。
aas
aasdasdsadasdsadasdsadsadsadasddasdsadas字段没有多态性

package org.fenixsoft.polymorphic;

public class FieldHasNoPolymorphic {
	static class Father {
		public int money = 1;
		public Father() {
			money = 2;
			showMeTheMoney();
		}
		public void showMeTheMoney() {
			System.out.println("I am Father, i have $" + money);
		}
	}
	static class Son extends Father {
		public int money = 3;
			public Son() {
				money = 4;
				showMeTheMoney();
			}
		public void showMeTheMoney() {
			System.out.println("I am Son, i have $" + money);
		}
	}
	public static void main(String[] args) {
		Father gay = new Son();
		System.out.println("This gay has $" + gay.money);
	}
}

运行结果：

I am Son, i have $0
I am Son, i have $4
This gay has $2

结果分析：
aasa①、两句都是“I am Son”，这是因为Son类在创建的时候，首先隐式调用了Father的构造函数，而Father构造函数中对showMeTheMoney()的调用是一次虚方法调用，实际执行的版本是Son::showMeTheMoney()方法，所以输出的是“I am Son”。
aasa②、这时候虽然父类的money字段已经被初始化成2了，但Son::showMeTheMoney()方法中访问的却是子类的money字段，这时候结果自然还是0，因为它要到子类的构造函数执行时才会被初始化。main()的最后一句通过静态类型访问到了父类中的money，输出了2。

单分派与多分派

aas方法的接收者(实际类型)与方法的参数统称为方法的宗量
在这里插入图片描述
aas单分派：根据一个宗量对目标进行选择；
aas多分派：根据多于一个宗量对目标进行选择；
aas
aasdasdsadasdsadasdsadsadsadasddasdsadas单分派和多分派

public class Dispatch {
	static class QQ {}
	static class _360 {}
	public static class Father {
		public void hardChoice(QQ arg) {
			System.out.println("father choose qq");
		}
		public void hardChoice(_360 arg) {
			System.out.println("father choose 360");
		}
	}
	public static class Son extends Father {
		public void hardChoice(QQ arg) {
			System.out.println("son choose qq");
		}
		public void hardChoice(_360 arg) {
			System.out.println("son choose 360");
		}
	}
	public static void main(String[] args) {
		Father father = new Father();
		Father son = new Son();
		father.hardChoice(new _360());
		son.hardChoice(new QQ());
	}
}

运行结果：

father choose 360
son choose qq

结果分析：
aasa我们关注的首先是编译阶段中编译器的选择过程，也就是静态分派的过程。这时候选择目标方法的依据有两点：一是静态类型是Father还是Son，二是方法参数是QQ还是360。（这次选择结果的最终产物是产生了两条invokevirtual指令，两条指令的参数分别为常量池中指向Father::hardChoice(360)及Father::hardChoice(QQ)方法的符号引用。)
aasa【注】：因为是根据两个宗量进行选择，所以Java语言的静态分派属于多分派类型。
aasa再看运行阶段中虚拟机的选择，也就是动态分派的过程。在执行“son.hardChoice(new QQ())”这行代码时，更准确地说，是在执行这行代码所对应的invokevirtual指令时，由于编译期已经决定目标方法的签名必须为hardChoice(QQ)，虚拟机此时不会关心传递过来的参数“QQ”到底是“腾讯QQ”还是“奇瑞QQ”，因为这时候参数的静态类型、实际类型都对方法的选择不会构成任何影响，唯一可以影响虚拟机选择的因素只有该方法的接受者的实际类型是Father还是Son。因为只有一个宗量作为选择依据，所以Java语言的动态分派属于单分派类型。

在这里插入图片描述
aasa总结：直至jdk 13的Java语言是一门 静态多分派、动态单分派 的语言。
a
a
虚拟机动态分派到底是如何实现的呢？
a
aasa动态分派是执行非常频繁的动作，而且动态分派的方法版本选择过程需要运行时在接收者类型的方法元数据中搜索合适的目标方法，因此，Java虚拟机实现基于执行性能的考虑，真正运行时一般不会如此频繁地去反复搜索类型元数据。
aasa优化方式：在方法区中建立一个**虚方法表(vtable)，在invokeinterface**执行时也会用到接口方法表(itable)。使用虚方法表索引来代替元数据查找以提高性能。
aasa【注】：这里的“提高性能”是相对于直接搜索元数据来说的，实际上在HotSpot虚拟机的实现中，直接去查 itable 和 vtable 已经算是最慢的一种分派，只在解释执行状态时使用，在即时编译执行时，会有更多的性能优化措施）(比如呢？)。
aasa虚方法表中存放着各个方法的实际入口地址。如果某个方法在子类中没有被重写，那子类的虚方法表中的地址入口和父类相同方法的地址入口是一致的，都指向父类的实现入口。如果子类中重写了这个方法，子类虚方法表中的地址也会被替换为指向子类实现版本的入口地址。
aasa【注】：为了程序实现方便，具有相同签名的方法，在父类、子类的虚方法表中都应当具有一样的索引序号，这样当类型变换时，仅需要变更查找的虚方法表，就可以从不同的虚方法表中按索引转换出所需的入口地址。虚方法表一般在类加载的连接阶段进行初始化，准备了类的变量初始值后，虚拟机会把该类的虚方法表也一同初始化完毕（准备阶段）。

多态概念的争议：
sdas重写肯定是多态性的体现，但对于重载算不算多态，有一些概念上的争议。
sdas有观点认为必须是 多个不同类对象对同一签名的方法做出不同响应才算多态，也有观点认为只要使用同一形式的接口去实现不同类的行为就算多态。

aas
发展趋势：
sdas按照目前Java语言的发展趋势，它并没有直接变为动态语言的迹象，而是通过内置动态语言（如JavaScript）执行引擎、加强与其他Java虚拟机上动态语言交互能力的方式来间接地满足动态性的需求。
sdas但是JVM层面，在JDK 7中实现的JSR-292[7]里面就已经开始提供对动态语言的方法调用支持了。

slow is fast.

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
6
评论
JVM之方法调用(重写、重载的本质)（基于《深入理解Java虚拟机》之第八章虚拟机字节码执行引擎）（中）

aas 方法调用并不等同于方法中的代码被执行，方法调用阶段唯一的任务就是确定被调用方法的版本（即调用哪一个方法），暂时还未涉及方法内部的具体运行过程。 asdsadasdasdasdasdasdsadassdasdsadsasadasdsadsdasdasdsadasdasdsadasdsadassadasdas————《Java虚拟机规范》方法调用到底指什么呢？ aa aas 就如文章开头所言，方法调用阶段的唯一任务就是确定被调用哪个方法。并没有涉及到方法内部的具体运行过程。 aa .
复制链接

扫一扫

专栏目录