JVM中的方法分派

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

分派　　

 　　Java面向对象的3个基本特征:封装、继承、多态。分派调用的过程会揭示多态特性的一些基本体现，如重载和重写。这里可以帮助我们理解虚拟机是如何正确的调用目标方法。

1.静态分派--重载

 　　下面是一段简单的重载的代码:

package zd.dms.test;

/**
 * 静态分配例子
 * 
 * @author Administrator
 *
 */
public class StaticDispatch {
    static abstract class Human {

    }

    static class Man extends Human {

    }

    static class Woman extends Human {

    }

    public static void sayHello(Human human) {
        System.out.println("human");
    }

    public static void sayHello(Man man) {
        System.out.println("man");
    }

    public static void sayHello(Woman woman) {
        System.out.println("woman");
    }

    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        sayHello(man);
        sayHello(woman);
    }
}

 结果:

human
human

 

解释:从结果看出执行的参数类型是Human，为什么会选择Human的重载?

Human man = new Man();

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

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

　　解释了这两个概念，main()方法的两次sayHello()方法调用，使用哪个重载版本完全取决于传入参数的数量和数据类型。代码中定义了 两个静态类型相同但实际类型不同的变量，但虚拟机(准确地说是编译器)在重载时是通过参数的静态类型而不是实际类型来作为判定依据的。并且静态类型是编译器可知的，因此，在编译阶段，Javac编译器会根据参数的静态类型决定使用哪个重载版本，所以选择了sayHello(Human)作为调用目标。

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

 

例如，下面的重载方法匹配优先级:

package zd.dms.test;

import java.io.Serializable;

public class Overload {
    // 1
    public static void sayHello(char arg) {
        System.out.println("char");
    }

    // 2
    public static void sayHello(int arg) {
        System.out.println("int");
    }

    // 3
    public static void sayHello(long arg) {
        System.out.println("long");
    }

    // 4
    public static void sayHello(float arg) {
        System.out.println("float");
    }

    // 5.
    public static void sayHello(double arg) {
        System.out.println("double");
    }

    // 6.
    public static void sayHello(Character arg) {
        System.out.println("Character");
    }

    // 7.
    public static void sayHello(Serializable arg) {
        System.out.println("Serializable");
    }

    // 8.
    public static void sayHello(Object arg) {
        System.out.println("Object");
    }

    // 9.
    public static void sayHello(char... arg) {
        System.out.println("char ...");
    }

    public static void main(String[] args) {
        sayHello('a');
    }
}

　　实际会按照上面标注的顺序进行匹配，如果注释掉前面的代码，会依次匹配后面的部分。

　　可变数组的优先级最低。

　　上面的顺序解释为:char先匹配，不存在会自动转为int(ASCII码进行转换),接着会按照数字类型进行转换 int -> long ->float -> double。如果还没匹配到会转为Character(发生一次自动装箱),Character不会发生转型到Integer。如果Character的参数类型也不存在，会转为Serializable，因此Character实现了Serializable接口，所以会转为其父接口。

　　Character还实现了一个Comparable<Character>接口，如果同时存在参数类型为Comparable<Character>和Serializable接口的方法，编译器无法确定要转为哪种类型，会提示类型模糊，拒绝编译，解决办法是调用时显示地指定字面量的静态类型，如:  sayHello((Comparable<Character>)'a');

 

 　　如果注释掉sayHello(Serializable arg)  会调用Object方法，这时char装箱后转型为父类了，如果有多个父类，会从下往上开始搜索，越接近上层的优先级越低。即使传入参数为null时，这个规则仍然试用sayHello(Object obj)；优先级最低的就是可变长参数。

 

2.动态分派 --重写

　　动态分派和多态的另一个特性----重写有着密切的联系。如下:

package zd.dms.test;

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类，所以是根据实际类型进行确定的。

我们采用Javap命令输出字节码查看:

PS E:\xiangmu\zdconpro\build\classes\zd\dms\test> javap -c '.\DynamicDispatch.class'
Compiled from "DynamicDispatch.java"
public class zd.dms.test.DynamicDispatch {
  public zd.dms.test.DynamicDispatch();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #16                 // class zd/dms/test/DynamicDispatch$Man
       3: dup
       4: invokespecial #18                 // Method zd/dms/test/DynamicDispatch$Man."<init>":()V
       7: astore_1
       8: new           #19                 // class zd/dms/test/DynamicDispatch$Woman
      11: dup
      12: invokespecial #21                 // Method zd/dms/test/DynamicDispatch$Woman."<init>":()V
      15: astore_2
      16: aload_1
      17: invokevirtual #22                 // Method zd/dms/test/DynamicDispatch$Human.sayHello:()V
      20: aload_2
      21: invokevirtual #22                 // Method zd/dms/test/DynamicDispatch$Human.sayHello:()V
      24: new           #19                 // class zd/dms/test/DynamicDispatch$Woman
      27: dup
      28: invokespecial #21                 // Method zd/dms/test/DynamicDispatch$Woman."<init>":()V
      31: astore_1
      32: aload_1
      33: invokevirtual #22                 // Method zd/dms/test/DynamicDispatch$Human.sayHello:()V
      36: return
}

　　0-15行的字节码是准备动作，作用是建立man和woman的内存空间、调用Man和Woman类型的实例构造器，将这两个实例的引用存放在第1、2个局部变量表Slot之中，对应下面代码:

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

 

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

　　原因就需要从invokevirtual的多态查找过程开始，invokevirtual指令的运行时解析过程大致分为以下几步:

1)找到操作数栈顶的第一个元素所指向的实际类型，记作C

2)如果在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回Java.lang.IllegalAccessError异常。

3)否则，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。

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

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

 

3. 单分派与多分派 

　　方法的接收者与方法的参数统称为方法的宗量。根据分派基于多少种宗量，可以将分派划分为单分派和多分派。单分派是根据一个宗量对目标方法进行选择，多分派是根据多于一个宗量对目标方法进行选择。

如下:

package zd.dms.test;

public class Dispatch {
    static class QQ {
    }

    static class _360 {
    }

    public static class Father {
        public void hardChoice(QQ qq) {
            System.out.println("father qq");
        }

        public void hardChoice(_360 ars) {
            System.out.println("father _360");
        }
    }

    public static class Son extends Father {
        public void hardChoice(QQ qq) {
            System.out.println("Son qq");
        }

        public void hardChoice(_360 ars) {
            System.out.println("Son _360");
        }
    }

    public static void main(String[] args) {
        Father father = new Father();
        Father son = new Son();

        father.hardChoice(new _360());
        son.hardChoice(new QQ());
    }
} 

结果:

father _360
Son qq

 

　　首先查看编译阶段编译器的选择过程，也就是静态分派的过程:这时选择目标方法的依据有两点:一是静态类型是Father还是Son，二是方法参数是QQ还是_360。这次选择的结果是产生了两条invokevirtual指令，两条指令分别指向Father.hardChoice(_360)和Father.hardChoice(QQ)方法的符号引用。因为是根据两个宗量进行选择，所以Java语言的静态分派属于多分派类型。

　　再看运行阶段虚拟机的选择，也就是动态分派的过程，在执行son.hardChoice(new QQ());  代码，更准确的说是执行代码对应的invokevirtual指令时，由于编译器已经决定目标方法的签名必须为hardChoice(QQ),所以决定虚拟机选择方法的因素只有此方法的接收者的实际类型是Father还是Son。因为只有一个宗量作为选择依据，所以Java语言的动态分派属于单分派类型。

　　所以上面结果可以总结为:Java是一门静态多分派、动态单分派的语言。

 

上面对应的虚方法表如下:

　　虚方法表中存放着各个方法的实际入口地址。如果某个方法在子类没有被重写，那么子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的，都指向父类的实现入口；如果子类重写了这个方法，子类方法表中的地址将会转换为指向子类实现版本的入口地址。

　　正如上面所示，子类重写了父类的全部方法，所以Son的方法表中没有指向Father类数据的箭头。但是Son和Father都没有重写来自Object的方法，所以他们的方法表中所有从Object继承来的方法都指向了Object的数据类型。

 

转载于:https://www.cnblogs.com/qlqwjy/p/10724776.html