动态绑定

我们都知道多态是java的最重要的特性。

Fruit fruit = new Apple();;
fruit.say() // 调用child的say方法而不是parent的

那么在字节码层面是怎么做到的呢？
这里确定两个概念：编译时类型与运行时类型
编译时类型就是指改对象在编译后的文件里的类型也就是该对象声明时的类型，而运行时类型是指在程序运行时动态指定的类型也就是该对象定义时的类型。
我们可以从编译后的class文件看出

#4 = Class              #243          // com/meiliwu/dragon/model/Apple
#5 = Methodref          #4.#241       // com/meiliwu/dragon/model/Apple."<init>":()V
#6 = Methodref          #244.#245     // com/meiliwu/dragon/model/Fruit.say:()V

我们可以从编译后的文件看出。fruit.say方法在编译后指向的是Fruit的say方法。但是运行时类型是Apple。运行时却是调用Apple的say方法。我们从日志可以看出来。
我们再看看编译后的文件

4 = Class              #243          // com/meiliwu/dragon/model/Apple
#5 = Methodref          #4.#241       // com/meiliwu/dragon/model/Apple."<init>":()V
#6 = Methodref          #4.#244       // com/meiliwu/dragon/model/Apple.say:()V

那回到第一种情况， JVM 是怎么知道 fruit.say() 调用的是子类的方法而非父类的呢？

加载类的时候，会形成类的方法表，方法表以数组的形式记录了当前类和其所有超类的可见方法字节码在内存中的直接地址。

方法表有两个特点：

• 子类方法表继承父类的方法；
• 相同的方法（相同方法签名：方法名和参数列表）在所有类的方法表中的索引相同。

多态调用的字节码指令代码

0  new dog.test.ShepherdDog [13] //在堆中开辟一个 ShepherdDog 对象的内存空间，并将对象引用压入操作数栈
3  dup  
4  invokespecial #7 [15] // 调用初始化方法来初始化堆中的 ShepherdDog 对象 
7  astore_1 //弹出操作数栈的 ShepherdDog 对象引用压入局部变量1中
8  aload_1 //取出局部变量1中的对象引用压入操作数栈
9  invokevirtual #15 //调用 bark() 方法
12  return

• invokevirtual 指令中的#15指的是 AutoCall 类的常量池中第15个常量表的索引项。这个常量表(CONSTATN_Methodref_info ) 记录的是方法 bark() 信息的符号引用(包括 bark() 在的类名，方法名和返回类型)。 JVM 会首先根据这个符号引用找到调用方法 bark 的类的全限定名: dog.test.Dog 。这是因为调用方法 bark() 的类的对象 dog 声明为 Dog 类型。
• 在 Dog 类型的方法表中查找方法 bark() ，如果找到，则将方法 bark 在方法表中的索引项记录到 AutoCall 类的常量池中第15个常量表中(常量池解析 )。这里有一点要注意：如果 Dog 类型方法表中没有方法 bark ，那么即使 ShepherdDog 类型中方法表有，编译的时候也通过不了。因为调用方法 bark() 的类的对象 dog 的声明为 Dog 类型。
• 在调用 invokevirtual 指令前有一个 aload_1 指令，它会将开始创建在堆中的 ShepherdDog 对象的引用压入操作数栈。然后invokevirtual指令会根据这个 ShepherdDog 对象的引用首先找到堆中的 ShepherdDog 对象，然后进一步找到 ShepherdDog 对象所属类型的方法表。
• 这是通过第(2)步中解析完成的#15常量表中的方法表的索引项11，可以定位到 ShepherdDog 类型方法表中的方法 bark()，然后通过直接地址找到该方法字节码所在的内存空间。
• 那么我们发现，仅仅根据对象 dog 和声明类型 Dog 并不能确定调用方法 dark() 的位置，必须根据 dog 在堆中实际创建的对象 ShepherdDog 来确定 dark() 所在的位置。

这种在程序运行中，通过动态创建对象来定位方法的方式，就叫做动态绑定机制。

总结

• 首先根据 fruit.say() 找到fruit的常量，指向fruit的类的符号引用。通过符号引用找到fruit在方法区中的类结构，替换符号引用为直接指针（这一步在类加载的解析阶段可能已经完成），然后查找fruit的方法表，找到say方法的索引。
• 根据Fruit fruit = new Apple()，此时弹出栈顶的对象其实是Apple，所以就去找Apple的类结构中的方法索引，注意，父方法和子方法，相同方法在所有类的方法表中的索引相同。就是之前所说的方法表的特点二！这样就能正确定位到apple的say方法的定义，然后去调用实际的方法了。

静态绑定

在Java SE 5.0 以前的版本中，覆盖父类的方法时，要求返回类型必须是一样的。现在子类覆盖父类的方法时，允许其返回类型定义为原始类型的子类型。

• 如果是private、static、final 方法或者是构造器，则编译器明确地知道要调用哪儿个方法，这种调用方式成为“静态调用”。
• 上边这些调用，在字节码中不会是invokespecial ，而是invokestatic等。

转型

• 按之前所述，首先可以明确的是：JVM首先是根据对象father声明的类型Father来解析常量池的(也就是用Father方法表中的索引项来代替常量池中的符号引用)。如果Father中没有匹配到"合适" 的方法，就无法进行常量池解析，这在编译阶段就通过不了。

• 那么什么叫"合适"的方法呢？当然，方法签名完全一样的方法自然是合适的。但是如果方法中的参数类型在声明的类型中并不能找到呢？比如上面的代码中调用father.f1(char)，Father类型并没有f1(char)的方法签名。实际上，JVM会找到一种“凑合”的办法，就是通过 参数的自动转型 来找 到“合适”的 方法。比如char可以通过自动转型成int，那么Father类中就可以匹配到这个方法了

• 但是还有一个问题，如果通过自动转型发现可以“凑合”出两个方法的话怎么办？
  一个很重要的标准就是：如果一个方法可以接受传递给另一个方法的任何参数，那么第一个方法就相对不合适。比如任何传递给f1(double[])方法的参数都可以传递给f1(Object)方法，而反之却不行，那么f1(double[])方法就更合适。

总结

(1) 所有私有方法、静态方法、构造器及初始化方法<clinit>都是采用静态绑定机制。在编译器阶段就已经指明了调用方法在常量池中的符号引用，JVM运行的时候只需要进行一次常量池解析即可。

(2) 类对象方法的调用必须在运行过程中采用动态绑定机制。

首先，根据对象的声明类型(对象引用的类型)找到“合适”的方法。具体步骤如下：

① 如果能在声明类型中匹配到方法签名完全一样(参数类型一致)的方法，那么这个方法是最合适的。

② 在第①条不能满足的情况下，寻找可以“凑合”的方法。标准就是通过将参数类型进行自动转型之后再进行匹配。如果匹配到多个自动转型后的方法签名f(A)和f(B)，则用下面的标准来确定合适的方法：传递给f(A)方法的参数都可以传递给f(B)，则f(A)最合适。反之f(B)最合适 。

③ 如果仍然在声明类型中找不到“合适”的方法，则编译阶段就无法通过。

然后，根据在堆中创建对象的实际类型找到对应的方法表，从中确定具体的方法在内存中的位置。

概念

下面介绍几个相关的概念，不用特意执着于各种名词，本质上了解字节码的引用原理，所有问题都可以解决。

★ 覆写（override）
一个实例方法可以覆写（override）在其超类中可访问到的具有相同签名的所有实例方法，从而使能了动态分派（dynamic dispatch）；换句话说，VM将基于实例的运行期类型来选择要调用的覆写方法。覆写是面向对象编程技术的基础，并且是唯一没有被普遍劝阻的名字重用形式：

注意的就是，返回值可以不同，子类的返回值必须是父类的子类或相同。

class Base{
      public void f(){}
}
class Derived extends Base{
      public void f(){}
}

★ 隐藏（hide）
一个域、静态方法或成员类型可以分别隐藏（hide）在其超类中可访问到的具有相同名字（对方法而言就是相同的方法签名)的所有域、静态方法或成员类型。隐藏一个成员将阻止其被继承。

静态方法，静态成员变量，子类会覆盖掉父类的，不存在继承关系

class Base{
      public static void f(){}
}
class Derived extends Base  {
      private static void f(){}   //hides Base. f()
}

★ 重载（overload）
在某个类中的方法可以重载（overload）另一个方法，只要它们具有相同的名字和不同的签名。由调用所指定的重载方法是在编译期选定的。

方法签名：方法名+参数
编译器确定，静态绑定

class CircuitBreaker{
      public void f (int i){}    //int overloading
      public void f(String s){}   //String overloading
}

★ 遮蔽（shadow）
一个变量、方法或类型可以分别遮蔽（shadow）在一个闭合的文本范围内的具有相同名字的所有变量、方法或类型。如果一个实体被遮蔽了，那么你用它的简单名是无法引用到它的;根据实体的不同，有时你根本就无法引用到它。

不同作用域，成员变量或者方法的覆盖操作

class WhoKnows{
    static String sentence=”I don't know.”;
    public static void main(String[] args〕{
           String sentence=”I don't know.”;  //shadows static field
           System.out. println (sentence);  // prints local variable
    }
}

尽管遮蔽通常是被劝阻的，但是有一种通用的惯用法确实涉及遮蔽。构造器经常将来自其所在类的某个域名重用为一个参数，以传递这个命名域的值。这种惯用法并不是没有风险，但是大多数Java程序员都认为这种风格带来的实惠要超过其风险:

这里，构造函数的参数size实际上遮蔽了成员变量size

class Belt{
      private find int size ;  //Parameter shadows Belt. size
      public Belt (int size){
           this. size=size;
      }
}

★ 遮掩（obscure）
一个变量可以遮掩具有相同名字的一个类型，只要它们都在同一个范围内:如果这个名字被用于变量与类型都被许可的范围，那么它将引用到变量上。相似地，一个变量或一个类型可以遮掩一个包。遮掩是唯一一种两个名字位于不同的名字空间的名字重用形式，这些名字空间包括:变量、包、方法或类型。如果一个类型或一个包被遮掩了，那么你不能通过其简单
名引用到它，除非是在这样一个上下文环境中，即语法只允许在其名字空间中出现一种名字。遵守命名习惯就可以极大地消除产生遮掩的可能性:

这是一种错误的用法了

public class Obscure{
      static String System;// Obscures type java.lang.System
      public static void main(String[] args)
            // Next line won't compile:System refers to static field
            System. out. println(“hello, obscure world!”);
      }
}