方法调用是不是很熟悉?那你真的了解它吗?今天就让我们来盘一下它。

首先大家要明确一个概念,此处的方法调用并不是方法中的代码被执行,而是要确定被调用方法的版本,即最终会调用哪一个方法。

上篇文章中我们了解到,class字节码文件中的方法的调用都只是符号引用,而不是直接引用D ? m [ m E 1 R $(方法在实际运行时内存布局中的入口地址),要实现两者的转化,就不得不提到解析和分派了。

解析

我们之前说过在类加载的解析阶段,会将一部分的符号引用转化为直接引用,该解析成立的前提是:方; ? j p z $ O法在程序真正运行之前就已经有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的。我们把这类方法的调用称为解析(ResoluM & vtion)。

看到这个前提条件,有没有小伙伴联想到对象的多态性?图片没错,就是这样,在java中能满足不被重写的方法有静态方法、私有方法(不能被外部访问)、实例构造器和被final修饰的方法,因此它们都适合在类加载阶段进行解析,另外通过this或者super调用的父类方法也是在类加载阶段进行解析1 ^ d x的。

指令集

调用不同类型的方法,字节码指令集里设置了不同的指令,在jvm里面提供了5条方法调用\ ? H q +字节码指令:

  • invokestatic:调用静态方法,解析阶段确定唯一方法版本
  • invo@ ^ U J ? i gkespecial:实例构造器init方法、私有及父类方法,解析阶段确定唯一方法版本
  • invok{ R jevirtual:调用所有虚方法
  • i? d r F c % E ^nvokeinterface:调用接口方法,在运行时再确定一个实现该接口的对象

invokedynamics 2 D z k a } I }:先在运行时动态解析出调用点i J T R % , D O限定符所引用的方法,然后再执行0 U 9 ~ #该方法,在此之前的4条调用指令,分派逻辑是固化在Ja& x f o K : *va虚拟机内部的,而invokedynamiz y g L & o 2c指令的分派逻辑是由用户所设定的引导方法决定的。

invo7 c ^ akedynamic指令是Java7中增加的,是为实现动态类型的语言做的一种改进,但是在java7中并没有直接提供生成该指令的方法,需要借助ASM底层字节码工具来产生指令,直到java8的lambda表达式的出现,x w + ! R P H 1 \该指令才有了直接的生@ l 9 d u p 0成方式。

「小知识点:静态类型语言与动态类型语言」

它们的区别就在于2 ~ O对类型的检查是在编译期还是在运行期,满足前者就是静态类型语言,反之\ l – 1 v | n a ?是动态类型语言。即静态类型语言是判断变量自身的类型信息,动态类型语言是判断变量值的类型信息,变量没有类型信息,变量值才有类型X V ` \ { k & x X信息,这是动态语言的一个重要特征。

「例」java类中定义的基本数据类型,在声明时就已经确定了他的具体类型了;而JS中用var来定义类型,值是什么类型就会_ g i在调用时使用什么类型。

虚方法与非虚方法

字节码指令集为in+ \ H 4 b p H & RvokestaZ # 3tic、invokespeciu d v { v \ F eal或者是用final修饰的invokevirtual的方法的话,都可以在解析阶段中确定唯一的调L b E q用版本,符合这个条件的就是我们上边提到的五类方法。它们在类加载的时候就会把符号引用解析为该方法的直接引用,这些U [ | |方法可以称为「非虚方法」。与之相反,不是) C s a _非虚方法的方法是「虚方法」。图片

分派

如果我们在编译期间没有将方法的符号引用转化] | Q ,为直接引. $ W Z \ b c h a用,而是在运行期间根据方法的实际类型绑定相关的方法,我们把这种方法的调用y J w @ y 0 L @称为分派。其中分P t ~ b –派又分为静态分派和动态分派。

静态分派

不知道你\ 9 G R对重载了解多少?为了解释静态分派,我们先来个重载6 a n ;的小测试:

  1. publir ) | q a x M OcclassStaticDispatco | C E V w yh{
  2. staticabstractclassHuman{
  3. }
  4. statict \ \classManextendsHuman{
  5. }
  6. staticclassWomanextendsHuman{
  7. }
  8. publicvoidsayHello(Humanguy)( Z u ) = \ B{
  9. System.out.println("hello,guy!");
  10. }
  11. publicvoi/ p = k L V { 4dsayHello(Manguy){
  12. System.out.println("hellV / ! Do,gentleman!");
  13. }
  14. publicvoidsayHello(Womanguy){
  15. Systemw g D n 9 ; ?.out.println("hello,lady!");j 1 H n G 1
  16. }
  17. publicstaticvoidmain(String[]args){
  18. Humanman=newMan();
  19. Humanwoman=n] i e L gewWoman();
  20. StaticDispatchsr=neH E [ b D EwStaC x i c ? 2ticDispatch();
  21. sr.sayHello(man);
  22. sr.sayHello(woman);
  23. }
  24. }
  1. hello,guy!
  2. hello,guy!

你答对了嘛?首先我们来了解两个概念:静态类型和实际类型。拿Human man = new Man();来说Human称为变量的静J E 2 Q . [态类型,而Man我们称为变量的实际类型,区别如下:

  1. 静态类型的变化仅仅在使用时才发生,变量本身的静态类型是不会被改变,并且最终静态类型在编译期是可知的。
  2. 实际类型的变化是在运行期才知道,编译器在编译程序时并不知道一个对象的具体2 | L类型是什么。

此处之所以执行的是Human类型的方法,是因为编译器在重载时,会通过参数的「静态类型」来作为判定执行方法的依据,而不是使用「实际类型」。

所有依赖静态类型来定位方法执行版本的分派动作称为静态分派。静态分派的典u $ [ { ^ f ?型应用就是方法重载。静态分派发生在编译阶段,因此确定静态分派6 \ z ]的动作实际上不是由虚拟机来执行的,而是由编译器来完成。

动态分派

了解了重载之后再来了解下重写?案例走起:

  1. publicclassDynamicDi+ $ 6 - ] X pspatch{
  2. staticabstractclassHuman{
  3. protectedabstractvoidsayHello();
  4. }
  5. staticclassManextendsHuman{
  6. @Override
  7. protectedvs \ 3 koidsayHello(){
  8. System.out.println("mansayhello!");
  9. }
  10. }
  11. staticclassWomanextendsHuman{
  12. @Override
  13. protectedvoidsayK m K N f = tHello(){
  14. System.out.println("womansayhe7 w \llo!");
  15. }
  16. }
  17. publicstaticvr z k \ S q _ Doidmain(String[]args){
  18. Humanman=newMan();
  19. Humanwoman=newWoman();
  20. man.sayHello();
  21. woman.sayHello();
  22. mi 1 : x $ w 5 i [an=newWoman();
  23. man.saq { w W Q ~yHello();
  24. }
  25. }

请考虑一下输出结果,继续沉默两分钟。P d { R 0 m P答案是:

  1. mansayhello!
  2. womansayhello!
  3. wom$ h | l #ansayhello!

这次相信大家的结果都对了吧?我们先来补充一个知识点:

父类引用指向子类时,如果执行的父类方法在子类中未被重写Z n H 3 P,则调用自身的/ v & ~ 4 | I N方法;如果被子类重写了,则调用子类的方法。如果要使用子类特有的属性和方法,需要向下转型。

根据这个结论我们反向推理一下:man和women是静态类型相同的变量,它们在调用相同的方+ [ I法sayHello()时| X $ Y %返回了不同的结果,并且在变量man的两次调用中执行了不同的方法。导致这个现象的原因很明显,是这两个变量的「实A c z * E e V 2际类型」不同,Java虚拟机是如何根据实际类型来分派方法执行版本的呢?我们看下字节码文件:

  1. man.T t B @sayHello();
  2. woman.sayHello();

我们关注的是以上两行代码,他们对应的分别是17和21行的字节码指令。单从字节码指令角度来看,~ 4 & I L W @ \ y它俩的指令invokevirtual和常量$Human.sayHec F d U Vllo:()V是完全一样的,但是执行的结果确是不同的,所以我们得研究下invokevirtual指令了,操作流程如下:图片

  1. 找到操作数栈顶的第一个元素所指向的对象的实际类型,记作C。
  2. 如果在类型C中找到与常量中的描述符和简单名称都J 8 k P e 7 7 Y )相符的方法,则进行访问权限校验,如果通过则返回这个方法的直接引用,查找过: ! = d \程结* { Q b 1 $束;如果不通过,则返回java.lang.IllegalAccessError异常(假如t = ` 8 8 c v I不在一同一个jar包下就会报非法访问C 0 o F r n g异常)。
  3. 否则,按照继承关系从W 9 z 3下往上依次对C的各个父类进行第2步的搜索和验证过程。~ _ G g X 6 m w
  4. 如果始终没有找到合适的方法,则抛出java.lan^ + A qg.Abstra[ ! F 4 \ 6 m 8ctMethodError异常。

由于invokevi? u P c s 0 U R Qrtual指令执行的第一步就是在[ e R 1 [ o运行期确定接收者的实际类型,所以两次调用中的invokeviL q s –rtual指令并不是把常量池中方法的符号引用解析到直接引用上就结束了,还会根据接收者的实_ N P M际类型来选择方法版本(案例中的实际类型为Man和Woman),这个过程就是Java语言中方法重写的「本质」。

我们把这种在运行期根据实际类型确定方法执行版本的分派过程称为动态分派。

单分派与多分派

方法的接收者与方法的参数统称为方法的宗量,这个定义最早应该来源于《Java与模式》一书。根据分派基( } m T \ J于多少种宗量,可以将分派划分为单分派和多分派两种。单分派是根据一个宗量对目y h \ e )标方法进行选择,多分派则是根据多于一个宗量对目标方法进行选择。

「举例说明」

  1. publicclassDispatch{
  2. staticclassQQ{}
  3. staticclass_9 o 2360{}
  4. publicstaticclassFather{
  5. publicvoidhardChoice(QQarg){
  6. S- - System.out.println("fatherchooseqq");
  7. }
  8. publicvoidhardChoice(] _ s + H B_360arg){
  9. System.out.p- * J S + )rintln("fatherchoose360");
  10. }
  11. }
  12. publicstaticclassSonex` ] ] 9 f n +tendsFatl T ;her{
  13. publicvoidhardChoice(QQarg){
  14. SO ^ Oystem.out.prin/ + ftln("sod u i pnchooseqq");
  15. }
  16. publicvoidhardChoice(_360arg){
  17. System.out.priC U A X Q 4 # n fntln("sonchoose360");
  18. }
  19. }
  20. publicstaticvoidmain^ ( R(String[]args){
  21. Fatherfather=newFather();
  22. Fatherson=newSon();
  23. father.hardChoice(new_360());
  24. son.hardChoice(newQQ());
  25. }
  26. }

请考虑一下输出结果,继续沉默两分钟。l & o H答案是D W – Q ~ @ x ,

  1. fatherchoost y se360
  2. sonchooseqq

我们来看看编译阶段编译器的选择过程,也就是静态分派的过程。这时2 2 _ r选择目标方法的依据有两点:一是静态类型是Father还是Son,二是方法参数是QQ还是360。这次选择结果的H _ s s w ) .最终产物是产生了两条invokevirtual指令,两条r T *指令的参数分别为常量池中指向Father.hardChoice(360)及Father.hardChoice(QQ)方法的符号引J 2 # , } C M ? z用。因为是根据两个宗量进行选择,所以Java语言的静态分派属于多分派类型。

再看看运行阶段虚拟机的选择,也就是动态o ` H c a S }分派的过程。在执行“son.hardChoice(new QQ())”这句代码时,更准确地说,是在执行这句代码所对q j 6 ~ J D p . [应的ini R ` $ ] ^ { z wvokevirtual指令时,由于编译期已经决定目标方法的签名必须为hardChoice(QQ),虚拟机此时不会关心传递过来的参数“QQ”到底是“腾讯QQ”还是“奇瑞QQ”,因为这时参数的静态类型、实际类型都对方法的选择不会构成任何影响,唯一可以影响虚拟机选择的因素只R # e有此方法的接i ) { ?受者的实际类型是Father还是Son。] Q b X V ( – 2 #因为只有s Y . . I g B一个宗量作为选择依据,所以Java语言的动态分派属于单分派类型。

虚方法表

在面向对象的编程中,会, t J d C 7很频繁的使T v B # t c 6 M用到动态分派,如i Q 9 f果在每次动态分H I 2 } \ 6 S j派的过程中都要重新在类的方法元数据中搜索合适的目标的话就很可能影响到执行效率。因此,为了提高性能,jvm采用O x 8 8 b [在类的方法区建立一个虚方法表(Vritual Me9 o Q Y M ~ 7 Zthod Table,也称为vtable,与此对应的,在invokeiB + ( [ D z F p Xnterface执行时也会用到接口方法表——Inteface Method Table,简称itable)来实现,使用虚方法表索引来代替元数据查n g I E k R ] ] |找以提高性能。

每一个类中都有一个虚方法表,表中存放着各种方法的实+ t B际入口:

  • 如果某个方法在子类中没有被重写,那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的,都8 a {指向父类的实现入口。
  • 如果子类中重写了这个方法,子类方法表中的e e d , v 6 P ~地址将会替换为指向子类实现版本的入口地址。

Son重写了来自~ s d 2 C 3Father的全部方法,因此Son的方法表没有指向Father类型数据的箭头。但是Son和Father都没有重写来自Object的方法,所以它们的方法表中所有从Oo U } * y Rbject继承来的方法都指向了Object的6 S @数据类型。

为了程序实现上的L & z = X l方便,具有Q Q ; F X相同签名的方法,在父类、子类的虚方法2 B = x p表中都应当具有一样的索引序号,这样当类型变换时,仅需要变更查找的方法表,就可以从不同c / G的虚方法表中按索引转换出所需的入口地址。方法表一般在类加载的连接阶段进行初始化,准备了类的变量初始值后,1 * ` f & w J H 4虚拟机会把该6 r a类的$ = ;方法表也初始化完毕。

绑定机制

解析调用一定是个静态的过程,在编译期间就完全确定,在类装5 ^ {载的解析阶段就会把涉及的符号引z f /用全部转变为可确定的直接引用,不会延迟到运行期再去完成。分派(Dispatch)调用则可能是静态的也可能是动态的。因此我们把 「解析」 和 「静态分r d v j 4 m p D派」 这俩在编译期间就确定了被调用的方法,且在运行期间不变的调用称之为静态链接,而在运行期才确定下来调用方法的称之为动态链接。

我们把在静态链接过程中的转换成为早期绑定,将动态链接过程中的转换称之为晚期绑定。

看到这,方法的调用你搞懂了吗?如果你还有什么困惑的话,可以关注^ a 2 i :微信公众号“阿Q说代码”,也可以加阿Q好友qingqing-4132,阿Q期待你的到来!

本文转载自微信公众号「阿Q说代码」,可以通过以下二维码关注。转载本文请联系阿Q说J ~ ( p 2 F X 8代码公众号。

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注