认真学习JVM的方法调用(方法重载和重写)

深入浅出JVM虚拟机 专栏收录该内容
36 篇文章 7 订阅

方法的重载与重写

  • 重载是指不同bai的函数使用相同的函数名,但du是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。

  • 覆盖(也叫重写)是指在派生类中重新对基类中的虚函数(注意是虚函数)重新实现。即函数名和参数都一样,只是函数的实现体不一样。

方法调用并不等同于方法执行,方法调用阶段唯一的任务就是确定被调用方法的版本(即调用哪一个方法),暂时还不涉及方法内部的具体运行过程。Class文件的编译过程中不包含传统编译中的连接步骤,一切方法调用在Class文件里面存储的都只是符号引用,而不是方法在实际运行时内存布局中的入口地址(相当于直接引用)。这个特性给Java带来了更强大的动态扩展能力,但也使得Java方法调用过程变得相对复杂起来,需要在类加载期间甚至到运行期间才能确定目标方法的直接引用。

方法调用主要有解析调用和分派调用两块。

【1】解析

所有方法调用中的目标方法在Class文件里面都是一个常量池的符号引用,在类加载的解析阶段,会将其中的一部分符号引用转化为直接引用,这种解析能成立的前提是:方法在程序真正运行之前就有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的。换句话说,调用目标在程序代码写好、编译器进行编译时就必须确定下来。这类方法的调用称为解析。

关于类加载过程参考博文: Java类的加载过程详解(加载验证准备解析初始化使用卸载)

在Java语言中符合“编译期可知,运行期不可变”这个要求的方法,主要包括静态方法和私有方法两大类,前者与类型直接关联,后者在外部不可被访问,这两种方法各自的特点决定了它们都不可能通过继承或别的方式重写其他版本,因此它们都适合在类加载阶段进行解析。

5条方法调用字节码指令

在Java虚拟机里面提供了5条方法调用字节码指令,分别如下:

  • invokestatic:调用静态方法。
  • invokespecial:调用实例构造器<init>方法、私有方法和父类方法。
  • invokevirtual:调用所有的虚方法。
  • invokeinterface:调用接口方法,会在运行时再确定一个实现此接口的对象。
  • invokedynamic:先在运行时动态解析出调用点限定符所引用的方法,然后再执行该方法,在此之前的4条调用指令,分派逻辑是固化在Java虚拟机内部的,而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

非虚方法

只能能被invokestatic和invokespecial指令调用的方法,都可以在解析阶段中确定唯一的调用版本,符合这个条件的有静态方法、私有方法、实例构造器、父类方法4类,它们在类加载的时候就会把符号引用解析为该方法的直接引用。这些方法可以称为非虚方法,与之相反,其他方法称为虚方法(除去final方法)。

代码示例如下:

public class StaticResolution {

    public static void sayHello(){
        System.out.println("hello world");
    }

    public static void main(String[] args){
        StaticResolution.sayHello();
    }
}

使用javap命令查看其字节码:

C:\Users\12746\Desktop>javap -verbose StaticResolution.class
Classfile /C:/Users/12746/Desktop/StaticResolution.class
  Last modified 2019-3-6; size 670 bytes
  MD5 checksum 1ba13aa82518e20fb32f19e01531877c
  Compiled from "StaticResolution.java"
public class com.boot.redis.controller.StaticResolution
  minor version: 0 //版本号
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool: //常量池
   #1 = Methodref          #7.#22         // java/lang/Object."<init>":()V //方法符号引用
   #2 = Fieldref           #23.#24        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #25            // hello world
   #4 = Methodref          #26.#27        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Methodref          #6.#28         // com/boot/redis/controller/StaticResolution.sayHello:()V
   #6 = Class              #29            // com/boot/redis/controller/StaticResolution
   #7 = Class              #30            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Lcom/boot/redis/controller/StaticResolution;
  #15 = Utf8               sayHello
  #16 = Utf8               main
  #17 = Utf8               ([Ljava/lang/String;)V
  #18 = Utf8               args
  #19 = Utf8               [Ljava/lang/String;
  #20 = Utf8               SourceFile
  #21 = Utf8               StaticResolution.java
  #22 = NameAndType        #8:#9          // "<init>":()V
  #23 = Class              #31            // java/lang/System
  #24 = NameAndType        #32:#33        // out:Ljava/io/PrintStream;
  #25 = Utf8               hello world
  #26 = Class              #34            // java/io/PrintStream
  #27 = NameAndType        #35:#36        // println:(Ljava/lang/String;)V
  #28 = NameAndType        #15:#9         // sayHello:()V
  #29 = Utf8               com/boot/redis/controller/StaticResolution
  #30 = Utf8               java/lang/Object
  #31 = Utf8               java/lang/System
  #32 = Utf8               out
  #33 = Utf8               Ljava/io/PrintStream;
  #34 = Utf8               java/io/PrintStream
  #35 = Utf8               println
  #36 = Utf8               (Ljava/lang/String;)V
{
  public com.boot.redis.controller.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 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/boot/redis/controller/StaticResolution;

  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 world
             //虚方法调用
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V 
         8: return
      LineNumberTable:
        line 9: 0
        line 10: 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 13: 0
        line 14: 3
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       4     0  args   [Ljava/lang/String;
}
SourceFile: "StaticResolution.java"

可以发现,的确是通过invokestatic命令来调用sayHello()方法的。

final方法

Java中的非虚方法除了使用invokestatic、invokespecial调用的方法之外还有一种,就是被final修饰的方法。虽然final方法是使用invokevirtual指令来调用的,但是由于它无法被覆盖,没有其他版本,所以也无须对方法接收者进行多态选择,又或者说多态选择的结果肯定是唯一的。

在Java语言规范中明确说明了final方法是一种非虚方法。

解析调用一定是个静态的过程,在编译期间就会完全确定,在类装载的解析阶段就会把涉及的符号引用全部转变为可确定的直接引用,不会延迟到运行期再去完成。而分派(dispatch)调用则可能是静态的也可能是动态的,根据分派依据的宗量数可分为单分派和多分派。这两类分派方式的两两组合就构成了静态单分派、静态多分派、动态单分派、动态多分派4种分派组合情况。


【2】静态分派

想知道“重载”和“重写”的底层原理吗?就在分派调用里。静态分派解决的是方法重载原理。先看一个面试题常见实例:

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(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!

为什么会选择执行参数类型为Human的重载呢?继续往下看。

按如下代码定义两个重要概念:

Human man = new Man();

我们把上面代码中的“Human”称为变量的静态类型(Static Type),或者叫做外观类型(Apparent Type),后面的“Man”则称为变量的实际类型(Actual Type),静态类型和实际类型在程序中都可以发生一些变化,区别是静态类型的变化仅仅在使用时发生,变量本身的静态类型不会被改变,并且最终的静态类型是在编译期可知的。而实际类型变化的结果在运行期才可确定,编译器在编译程序的时候并不知道一个对象的实际类型是什么。例如下面的代码:

//实际类型变化
Human man=new Man();
man=new Woman();
//静态类型变化
sr.sayHello((Man)man);
sr.sayHello((Woman)man);

继续回到上述代码实例中,main()里面的两次sayHello()方法调用,在方法接收者已经确定是对象“sr”的前提下,使用哪个重载版本,就完全取决于传入参数的数量和数据类型。代码中刻意定义了两个静态类型相同但实际类型不同的变量,但虚拟机(准备地说是编译器)在重载时是通过参数的静态类型而不是实际类型作为判定依据的。并且静态类型是编译期可知的,因此在编译阶段,Javac编译器会根据参数的静态类型决定使用哪个重载版本,所以选择了sayHello(Human)作为调用目标,并把这个方法的符号引用写到main()方法里的两条invokevirtual指令的参数中。


是不是感觉方法重载原理掌握了?还没完!

所有依赖静态类型来定位方法执行版本的分派动作称为静态分派。静态分派的典型应用是方法重载。静态分派发生在编译阶段,因此确定静态分派的动作实际上不是由虚拟机来执行的。另外,编译器虽然能确定出方法的重载版本,但在很多情况下整个重载版本并不是“唯一的”,往往只能确定一个“更加合适的”版本。

如下代码示例:

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');
        sayHello("a");
    }
}

运行结果如下:

hello char
hello Serializable

如果依次注释掉sayHello(char arg)、sayHello(int arg)…sayHello(Object arg)呢?

下面开始分析

输出:hello char

这个很好理解,'a’是一个char类型的数据,自然会寻找参数类型为char的重载方法,如果注释掉sayHello(char arg)方法呢?

输出:hello int

这里发生了一次自动类型转换,'a’除了可以代表一个字符串,还可以代表数字97,因此参数类型为int的重载也是合适的。如果注释掉sayHello(int arg)呢?

输出:hello long

这里发生了两次自动类型转换,'a’转型为整数97之后,进一步转型为长整数97L,匹配了参数类型为long的重载。实际上如果有float、double等的重载,自动转型还能发生多次,按照char->int->long->float->double的顺序转型进行匹配。但不会匹配到byte和short类型的重载,因为char到byte或short的转型是不安全的(参考博文:Java中基本数据类型所占字节与取值范围)。如果注释掉sayHello(long arg)呢?

输出:hello Character

这里发生了一次自动装箱,‘a’被包装为它的封装类型java.lang.Character,所以匹配到了参数类型为Character的重载。继续注释掉sayHello(Character arg)呢?

输出:hello Serializable

出现hello Serializable是因为java.lang.Serializable是java.lang.Character类实现的一个接口,当自动装箱之后发现还是找不到装箱类,但是找到了装箱类实现了的接口类型,所以紧接着又发生一次自动转型。char可以转型为int,但是Character是绝对不会转型为Integer的。即使存在sayHello(Integer arg),也不会调用该方法。它只能安全地转型为它实现的接口或父类。Character还实现了另外一个接口java.lang.Comparable<Character>,如果同时出现两个参数分别为Serializable和Comparable<Character>的重载方法,那它们在此时的优先级是一样的。编译器无法确定要自动转型为哪种类型,会提示类型模糊,拒绝编译。程序必须在调用时显示地指定字面量的静态类型,如sayHello((Comparable<Character>)'a')才能编译通过。

下面继续注释掉sayHello(Serializable arg)方法。

输出:hello Object

这里是char装箱后转型为父类了,如果有多个父类,那将在继承关系中从下往上开始搜索,越接近上层的优先级越低。即使方法调用传入的参数值为null时,这个规则仍然适用。

下面继续注释掉sayHello(Object arg)方法。

输出:hello char...

变长参数的重载优先级是最低的,这时候字符’a’被当做了一个数组元素。

总结

javac编译器在编译阶段会根据参数的静态类型来决定选择哪个重载版本。重载优先级,先匹配参数个数;再匹配参数类型的直接所属类。如果没有给静态类型而是一个字面量,那么参考上面的优先级:参数数量->基本类型->基本类型转换->参数包装类型->包装类型实现接口->Object父类->变长参数

上面没有提到父类,那么父类和子类实现的接口优先级呢?

如下示例:

public class StaticDispatch {
    static abstract  class Human {}

    static class Man extends Human implements Serializable{}

    static  class Woman extends  Human implements Serializable{}

//    public void sayHello(Human guy){
//        System.out.println("hello,Human!");
//    }
    public void sayHello(Object guy){
        System.out.println("hello,Object!");
    }
    public void sayHello(Serializable guy){
        System.out.println("hello,Serializable!");
    }
    public void sayHello(Woman guy){
        System.out.println("hello,Woman!");
    }
    public static void main(String[] args){

        Human man = new Man();
        Human woman=new Woman();
        StaticDispatch sr = new StaticDispatch();
        sr.sayHello(man);
        sr.sayHello(new Man());
        sr.sayHello(new Woman());
    }
}

运行结果如下:

hello,Object! //静态类型Human,该重载方法被注销往上找--Object
hello,Serializable! //不存在Man,不存在Human,存在Serializable
hello,Woman! //存在sayHello(Woman gug);

如果同时存在sayHello(Human guy)和sayHello(Serializable guy)呢?提示类型模糊,拒绝编译!
在这里插入图片描述

另外需要注意的是,解析与分派这两者之间的关系并不是二选一的排他关系,它们是在不同层次上去筛选、确定目标方法的过程。例如静态方法会在类加载期就进行解析,而静态方法显然也是可以拥有重载版本的,选择重载版本的过程也是通过静态分派完成的。


【3】动态分派

动态分派和方法重写有着很密切的关联,先看代码示例:

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

问题来了,虚拟机是如何知道要调用哪个方法的?

显然这里不可能再根据静态类型来决定,因为静态类型同样都是Human的两个变量man和woman在调用sayHello()方法时执行了不同的行为,并且变量man在两次调用中执行了不同的方法。导致这个现象的原因很明显,是这两个变量的实际类型不同,Java虚拟机是如何根据实际类型来分派方法执行版本的呢?

使用javap命令查看上述代码字节码:

C:\Users\12746\Desktop>javap -verbose DynamicDispatch.class
Classfile /C:/Users/12746/Desktop/DynamicDispatch.class
  Last modified 2019-3-6; size 843 bytes
  MD5 checksum d1ec8bc8027c74538312f478b17402e1
  Compiled from "DynamicDispatch.java"
public class com.boot.redis.controller.DynamicDispatch
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#30         // java/lang/Object."<init>":()V
   #2 = Class              #31            // com/boot/redis/controller/DynamicDispatch$Man
   #3 = Methodref          #2.#30         // com/boot/redis/controller/DynamicDispatch$Man."<init>":()V
   #4 = Class              #32            // com/boot/redis/controller/DynamicDispatch$Woman
   #5 = Methodref          #4.#30         // com/boot/redis/controller/DynamicDispatch$Woman."<init>":()V
   #6 = Methodref          #12.#33        // com/boot/redis/controller/DynamicDispatch$Human.sayHello:()V
   #7 = Class              #34            // com/boot/redis/controller/DynamicDispatch
   #8 = Class              #35            // java/lang/Object
   #9 = Utf8               Woman
  #10 = Utf8               InnerClasses
  #11 = Utf8               Man
  #12 = Class              #36            // com/boot/redis/controller/DynamicDispatch$Human
  #13 = Utf8               Human
  #14 = Utf8               <init>
  #15 = Utf8               ()V
  #16 = Utf8               Code
  #17 = Utf8               LineNumberTable
  #18 = Utf8               LocalVariableTable
  #19 = Utf8               this
  #20 = Utf8               Lcom/boot/redis/controller/DynamicDispatch;
  #21 = Utf8               main
  #22 = Utf8               ([Ljava/lang/String;)V
  #23 = Utf8               args
  #24 = Utf8               [Ljava/lang/String;
  #25 = Utf8               man
  #26 = Utf8               Lcom/boot/redis/controller/DynamicDispatch$Human;
  #27 = Utf8               woman
  #28 = Utf8               SourceFile
  #29 = Utf8               DynamicDispatch.java
  #30 = NameAndType        #14:#15        // "<init>":()V
  #31 = Utf8               com/boot/redis/controller/DynamicDispatch$Man
  #32 = Utf8               com/boot/redis/controller/DynamicDispatch$Woman
  #33 = NameAndType        #37:#15        // sayHello:()V
  #34 = Utf8               com/boot/redis/controller/DynamicDispatch
  #35 = Utf8               java/lang/Object
  #36 = Utf8               com/boot/redis/controller/DynamicDispatch$Human
  #37 = Utf8               sayHello
{
  public com.boot.redis.controller.DynamicDispatch();
    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 8: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/boot/redis/controller/DynamicDispatch;

  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 com/boot/redis/controller/DynamicDispatch$Man
         3: dup
         4: invokespecial #3                  // Method com/boot/redis/controller/DynamicDispatch$Man."<init>":()V
         7: astore_1
         8: new           #4                  // class com/boot/redis/controller/DynamicDispatch$Woman
        11: dup
        12: invokespecial #5                  // Method com/boot/redis/controller/DynamicDispatch$Woman."<init>":()V
        15: astore_2
        16: aload_1
        17: invokevirtual #6                  // Method com/boot/redis/controller/DynamicDispatch$Human.sayHello:()V
        20: aload_2
        21: invokevirtual #6                  // Method com/boot/redis/controller/DynamicDispatch$Human.sayHello:()V
        24: new           #4                  // class com/boot/redis/controller/DynamicDispatch$Woman
        27: dup
        28: invokespecial #5                  // Method com/boot/redis/controller/DynamicDispatch$Woman."<init>":()V
        31: astore_1
        32: aload_1
        33: invokevirtual #6                  // Method com/boot/redis/controller/DynamicDispatch$Human.sayHello:()V
        36: return
      LineNumberTable:
        line 28: 0
        line 29: 8
        line 30: 16
        line 31: 20
        line 32: 24
        line 33: 32
        line 34: 36
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      37     0  args   [Ljava/lang/String;
            8      29     1   man   Lcom/boot/redis/controller/DynamicDispatch$Human;
           16      21     2 woman   Lcom/boot/redis/controller/DynamicDispatch$Human;
}
SourceFile: "DynamicDispatch.java"
InnerClasses:
     static #9= #4 of #7; //Woman=class com/boot/redis/controller/DynamicDispatch$Woman of class com/boot/redis/controller/DynamicDispatch
     static #11= #2 of #7; //Man=class com/boot/redis/controller/DynamicDispatch$Man of class com/boot/redis/controller/DynamicDispatch
     static abstract #13= #12 of #7; //Human=class com/boot/redis/controller/DynamicDispatch$Human of class com/boot/redis/controller/DynamicDispatch

这里主要分析main方法的字节码:
在这里插入图片描述
0-15行的字节码是准备动作,作用是建立man和woman的内存空间、调用Man和Woman类型的实例构造器,将这两个实例的引用存放在第1、2个局部变量表Slot之中,这个动作也就对应了代码中的这两句:

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

接下来的16-21句是关键部分,16、20两句分别把刚刚创建的两个对象的引用压倒栈顶,这两个对象是将要执行的sayHello()方法的所有者,称为接收者(Receiver);17和21句是方法调用指令,这两条调用指令单从字节码角度来看,无论是指定(都是invokevirtual)还是参数(都是常量池中第6项的常量,这个常量是Human.sayHello()的符号引用)完全一样的,但是这两句指令最终执行的目标方法并不相同。

invokevirtual指令的运行时解析过程

原因就需要穿那个invokevirtual指令的多态查找过程开始说起,invokevirtual指令的运行时解析过程大致分为以下几个步骤:

  • 找到操作数栈顶的第一个元素所指向的对象的实际类型,记作C。
  • 如果在类型C中找到与常量中的描述符和简单名称都相符的方法,则进行访问权限校验,如果通过则返回这个方法的直接引用,查找过程结束;如果不通过,则返回java.lang.IllegalAccessError异常。
  • 否则,按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
  • 如果始终没有找到合适的方法,则抛出java.lang.AbstractMethodError异常。

由于invokevirtual指令执行的第一步就是在运行期确定接收者的实际类型,所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上,这个过程就是Java语言中方法重写的本质。我们把这种在运行期根据实际类型确定方法执行版本到的分派过程称为动态分派。


【4】单分派与多分派

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

实例代码如下:

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

字节码指令

C:\Users\12746\Desktop>javap -verbose Dispatch.class
Classfile /C:/Users/12746/Desktop/Dispatch.class
  Last modified 2019-3-6; size 960 bytes
  MD5 checksum 56410c23412bff26978e491a6b11ebb3
  Compiled from "Dispatch.java"
public class com.boot.redis.controller.Dispatch
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #13.#35        // java/lang/Object."<init>":()V
   #2 = Class              #36            // com/boot/redis/controller/Dispatch$Father
   #3 = Methodref          #2.#35         // com/boot/redis/controller/Dispatch$Father."<init>":()V
   #4 = Class              #37            // com/boot/redis/controller/Dispatch$Son
   #5 = Methodref          #4.#35         // com/boot/redis/controller/Dispatch$Son."<init>":()V
   #6 = Class              #38            // com/boot/redis/controller/Dispatch$_360
   #7 = Methodref          #6.#35         // com/boot/redis/controller/Dispatch$_360."<init>":()V
   #8 = Methodref          #2.#39         // com/boot/redis/controller/Dispatch$Father.hardChoice:(Lcom/boot/redis/controller/Dispatch$_360;)V
   #9 = Class              #40            // com/boot/redis/controller/Dispatch$QQ
  #10 = Methodref          #9.#35         // com/boot/redis/controller/Dispatch$QQ."<init>":()V
  #11 = Methodref          #2.#41         // com/boot/redis/controller/Dispatch$Father.hardChoice:(Lcom/boot/redis/controller/Dispatch$QQ;)V
  #12 = Class              #42            // com/boot/redis/controller/Dispatch
  #13 = Class              #43            // java/lang/Object
  #14 = Utf8               Son
  #15 = Utf8               InnerClasses
  #16 = Utf8               Father
  #17 = Utf8               _360
  #18 = Utf8               QQ
  #19 = Utf8               <init>
  #20 = Utf8               ()V
  #21 = Utf8               Code
  #22 = Utf8               LineNumberTable
  #23 = Utf8               LocalVariableTable
  #24 = Utf8               this
  #25 = Utf8               Lcom/boot/redis/controller/Dispatch;
  #26 = Utf8               main
  #27 = Utf8               ([Ljava/lang/String;)V
  #28 = Utf8               args
  #29 = Utf8               [Ljava/lang/String;
  #30 = Utf8               father
  #31 = Utf8               Lcom/boot/redis/controller/Dispatch$Father;
  #32 = Utf8               son
  #33 = Utf8               SourceFile
  #34 = Utf8               Dispatch.java
  #35 = NameAndType        #19:#20        // "<init>":()V
  #36 = Utf8               com/boot/redis/controller/Dispatch$Father
  #37 = Utf8               com/boot/redis/controller/Dispatch$Son
  #38 = Utf8               com/boot/redis/controller/Dispatch$_360
  #39 = NameAndType        #44:#45        // hardChoice:(Lcom/boot/redis/controller/Dispatch$_360;)V
  #40 = Utf8               com/boot/redis/controller/Dispatch$QQ
  #41 = NameAndType        #44:#46        // hardChoice:(Lcom/boot/redis/controller/Dispatch$QQ;)V
  #42 = Utf8               com/boot/redis/controller/Dispatch
  #43 = Utf8               java/lang/Object
  #44 = Utf8               hardChoice
  #45 = Utf8               (Lcom/boot/redis/controller/Dispatch$_360;)V
  #46 = Utf8               (Lcom/boot/redis/controller/Dispatch$QQ;)V
{
  public com.boot.redis.controller.Dispatch();
    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 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/boot/redis/controller/Dispatch;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=3, args_size=1
         0: new           #2                  // class com/boot/redis/controller/Dispatch$Father
         3: dup
         4: invokespecial #3                  // Method com/boot/redis/controller/Dispatch$Father."<init>":()V
         7: astore_1
         8: new           #4                  // class com/boot/redis/controller/Dispatch$Son
        11: dup
        12: invokespecial #5                  // Method com/boot/redis/controller/Dispatch$Son."<init>":()V
        15: astore_2
        16: aload_1
        17: new           #6                  // class com/boot/redis/controller/Dispatch$_360
        20: dup
        21: invokespecial #7                  // Method com/boot/redis/controller/Dispatch$_360."<init>":()V
        24: invokevirtual #8                  // Method com/boot/redis/controller/Dispatch$Father.hardChoice:(Lcom/boot/redis/controller/Dispatch$_360;)V
        27: aload_2
        28: new           #9                  // class com/boot/redis/controller/Dispatch$QQ
        31: dup
        32: invokespecial #10                 // Method com/boot/redis/controller/Dispatch$QQ."<init>":()V
        35: invokevirtual #11                 // Method com/boot/redis/controller/Dispatch$Father.hardChoice:(Lcom/boot/redis/controller/Dispatch$QQ;)V
        38: return
      LineNumberTable:
        line 28: 0
        line 29: 8
        line 30: 16
        line 31: 27
        line 32: 38
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      39     0  args   [Ljava/lang/String;
            8      31     1 father   Lcom/boot/redis/controller/Dispatch$Father;
           16      23     2   son   Lcom/boot/redis/controller/Dispatch$Father;
}
SourceFile: "Dispatch.java"
InnerClasses:
     public static #14= #4 of #12; //Son=class com/boot/redis/controller/Dispatch$Son of class com/boot/redis/controller/Dispatch
     public static #16= #2 of #12; //Father=class com/boot/redis/controller/Dispatch$Father of class com/boot/redis/controller/Dispatch
     static #17= #6 of #12; //_360=class com/boot/redis/controller/Dispatch$_360 of class com/boot/redis/controller/Dispatch
     static #18= #9 of #12; //QQ=class com/boot/redis/controller/Dispatch$QQ of class com/boot/redis/controller/Dispatch

先分析静态分派的过程。编译阶段编译器的选择过程中选择目标方法的依据有两点:一是静态类型是Father还是Son,二是方法参数是QQ还是360。这次选择结果的最终产物是产生了两条invokevirtual指令,两条指令的参数分别为常量池中指向Father.hardChoice(360)及Father.hardChoice(QQ)方法的符号引用。因为是根据两个宗量进行选择,所以Java语言的静态分派属于多分派类型

再分析运行阶段虚拟机的选择,也就是动态分派的过程。在执行“son.hardChoice(new QQ())”这句代码时,更准确地说,是在执行这句代码所对应的invokevirtual指令时,由于编译器已经决定了目标方法的签名必须为hardChoice(QQ),虚拟机此时不会关心传递过来的参数“QQ”到底是腾讯QQ还是奇瑞QQ,因为这时参数的静态类型、实际类型都对方法的选择不会构成任何影响,唯一可以影响虚拟机选择的因素只有此方法的接受者的实际类型是Father还是Son。因为只有一个宗量作为选择依据,所以Java语言的动态分派数据单分派模型


【5】虚拟机动态分派的实现

由于动态分派是分成频繁的动作,而且动态分派的方法版本选择过程需要运行时在类的方法元数据中搜索合适的目标方法,因此在虚拟机的实际实现中基于性能的考虑,大部分实现都不会真正地进行如此频繁的搜索。面对这种情况,最常用的“稳定优化”手段就是为类在方法区中建立一个虚方法表(Virtual Method Table,也称为vtable,与此对应的,在invokeinterface执行时也会用到接口方法表----Interface Method Table,简称itable),使用虚方法表索引来代替元数据查找以提高性能。

如下是Father与Son的方法表:

虚方法表中存放着各个方法的实际入口地址。如果某个方法在子类没有被重写,那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的,都指向父类的实现入口。如果子类中重写了这个方法,子类方法表中的地址将会替换为指向子类实现版本的入口地址。上图中,因为Son重写了来自Father的全部方法,因此Son的方法表没有指向Father类型数据的箭头。但是Son和Father都没有重写来自Object的方法,所以它们的方法表中所有从Object继承来的方法都指向了Object的数据类型。

为了程序实现上的方便,具有相同签名的方法,在父类、子类的虚方法表中都应当具有意义的索引序号,这样当类型变换时,仅需要变更查找的方法表,就可以从不同的虚方法表中按索引转换出所需的入口地址。

方法表一般在类加载的连接阶段进行初始化,准备了类的变量初始值后,虚拟机会把该类的方法表也初始化完毕。

上面说方法表是分配调用的“稳定优化”手段,虚拟机除了使用方法表之外,在条件允许的情况下,还会使用内联缓存(Inline Cache)和基于“类型继承关系分析(Class Hierarchy Analysis,CHA)”技术的守护内联(Guarded Inlining)两种非稳定的“激进优化”手段来获得更高的性能。

  • 2
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

打赏
文章很值,打赏犒劳作者一下
相关推荐
©️2020 CSDN 皮肤主题: 程序猿惹谁了 设计师:白松林 返回首页

打赏

流烟默

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值