方法调用(方法解析、分派)

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

1. 解析

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

　　在java中，符合"编译期可知道，运行期不可变" 的方法主要包括：静态方法和私有方法两大类，静态方法和类型直接关联，私有方法在外部不可访问，这两种方法的特点决定了它们不可通过继承或别的方式重写其他版本，因此它们都适合在类加载阶段进行解析。

　　与之对应的是，在Java虚拟机里面提供了五条方法调用字节码指令，分别如下：

invokestatic:调用静态方法

invokespecial：调用实例构造器<init>方法、私有方法和类方法

invokevirtual：调用所有的虚方法。(虚方法出现在java的多态特性中，可以理解为java里所有被overriding的方法都是virtual的,所有重写的方法都是override的)

invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象。

invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法，在此之前的4条调用指令，分派逻辑是固化在java虚拟机内部的，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

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

　　如下是一个最常用的解析调用的例子：

public class Client {

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

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

　　用javap命令查看这段程序的字节码，会发现是通过 invokestatic命令来调用sayHello()方法的。

PS C:UsersAdministratorDesktop新建文件夹> javap -c Client
Compiled from "Client.java"
public class Client {
  public Client();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void sayHello();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String hello
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void main(java.lang.String[]);
    Code:
       0: invokestatic  #5                  // Method sayHello:()V
       3: return
}

　　更详细的如下：

PS C:UsersAdministratorDesktop新建文件夹> javap -verbose Client
Classfile /C:/Users/Administrator/Desktop/新建文件夹/Client.class
  Last modified 2019-11-5; size 478 bytes
  MD5 checksum c54103a6d56708bd2757c449315ebe03
  Compiled from "Client.java"
public class Client
  SourceFile: "Client.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#17         //  java/lang/Object."<init>":()V
   #2 = Fieldref           #18.#19        //  java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #20            //  hello
   #4 = Methodref          #21.#22        //  java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Methodref          #6.#23         //  Client.sayHello:()V
   #6 = Class              #24            //  Client
   #7 = Class              #25            //  java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               sayHello
  #13 = Utf8               main
  #14 = Utf8               ([Ljava/lang/String;)V
  #15 = Utf8               SourceFile
  #16 = Utf8               Client.java
  #17 = NameAndType        #8:#9          //  "<init>":()V
  #18 = Class              #26            //  java/lang/System
  #19 = NameAndType        #27:#28        //  out:Ljava/io/PrintStream;
  #20 = Utf8               hello
  #21 = Class              #29            //  java/io/PrintStream
  #22 = NameAndType        #30:#31        //  println:(Ljava/lang/String;)V
  #23 = NameAndType        #12:#9         //  sayHello:()V
  #24 = Utf8               Client
  #25 = Utf8               java/lang/Object
  #26 = Utf8               java/lang/System
  #27 = Utf8               out
  #28 = Utf8               Ljava/io/PrintStream;
  #29 = Utf8               java/io/PrintStream
  #30 = Utf8               println
  #31 = Utf8               (Ljava/lang/String;)V
{
  public Client();
    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 2: 0

  public static void sayHello();
    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
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8

  public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: invokestatic  #5                  // Method sayHello:()V
         3: return
      LineNumberTable:
        line 9: 0
        line 10: 3
}

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

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

2.分派　　

 　　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)作为调用目标。

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

用javap查看上述代码编译后的字节码指令如下：

PS C:UsersAdministratorDesktop新建文件夹> javap -c StaticDispatch
Compiled from "StaticDispatch.java"
public class StaticDispatch {
  public StaticDispatch();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void sayHello(StaticDispatch$Human);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String human
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void sayHello(StaticDispatch$Man);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #5                  // String man
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void sayHello(StaticDispatch$Woman);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #6                  // String woman
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #7                  // class StaticDispatch$Man
       3: dup
       4: invokespecial #8                  // Method StaticDispatch$Man."<init>":()V
       7: astore_1
       8: new           #9                  // class StaticDispatch$Woman
      11: dup
      12: invokespecial #10                 // Method StaticDispatch$Woman."<init>":()V
      15: astore_2
      16: aload_1
      17: invokestatic  #11                 // Method sayHello:(LStaticDispatch$Human;)V
      20: aload_2
      21: invokestatic  #11                 // Method sayHello:(LStaticDispatch$Human;)V
      24: return
}

　　可以看到是通过invokestatic调用静态方法啊，而且参数类型是  LStaticDispatch$Human，代表引用类型  StaticDispatch$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:xiangmuzdconprouildclasseszddms	est> 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的数据类型。

补充：方法和字段的描述符用来描述字段的数据类型、方法的参数列表(包括数量、类型以及顺序)和返回值，规则如下

 　　对于数组类型，每一维度将使用一个前置的"["字符来描述，如描述一个"String[][]"将被记录为"[[Ljava/lang/String",一个int型数组将被记录为"[I"。

　　描述方法时，按照先参数后返回值的顺序描述，参数列表按照参数顺序放在一组括号内，如下:

public class client {

    public String[] toStringArrays(String str, int num) {
        return null;
    }

    public boolean hasValue(String[] strs, String str) {
        return false;
    }

}

　　用javap查看如下：

PS C:UsersAdministratorDesktop新建文件夹> javap -v Client
警告: 二进制文件Client包含client
Classfile /C:/Users/Administrator/Desktop/新建文件夹/Client.class
  Last modified 2019-11-5; size 380 bytes
  MD5 checksum f254abfdb23818c7259fe5d507c2c005
  Compiled from "Client.java"
public class client
  SourceFile: "Client.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #3.#14         //  java/lang/Object."<init>":()V
   #2 = Class              #15            //  client
   #3 = Class              #16            //  java/lang/Object
   #4 = Utf8               <init>
   #5 = Utf8               ()V
   #6 = Utf8               Code
   #7 = Utf8               LineNumberTable
   #8 = Utf8               toStringArrays
   #9 = Utf8               (Ljava/lang/String;I)[Ljava/lang/String;
  #10 = Utf8               hasValue
  #11 = Utf8               ([Ljava/lang/String;Ljava/lang/String;)Z
  #12 = Utf8               SourceFile
  #13 = Utf8               Client.java
  #14 = NameAndType        #4:#5          //  "<init>":()V
  #15 = Utf8               client
  #16 = Utf8               java/lang/Object
{
  public client();
    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 2: 0

  public java.lang.String[] toStringArrays(java.lang.String, int);
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=3, args_size=3
         0: aconst_null
         1: areturn
      LineNumberTable:
        line 5: 0

  public boolean hasValue(java.lang.String[], java.lang.String);
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=3, args_size=3
         0: iconst_0
         1: ireturn
      LineNumberTable:
        line 9: 0
}