动态绑定

调用类方法，基于对象引用的类型(通常在编译时可知)来选择所调用的方法。 

调用实例方法，它会基于对象实际的类型(只能在运行时得知)来选择所调用的方法。

 

【JAVA对象模型】

　　JAVA对象中包含的基本数据由它所属的类及其所有超类声明的实例变量组成。只要有一个对象引用，虚拟机就必须能够快速地定位对象实例的数据。

　　另外，它也必须能通过该对象引用访问相应的  类数据(存储于方法区的类型信息)，因此在对象中通常会有一个指向方法区的指针。

　　当程序在执行instanceof操作时，查看被引用的对象的类数据。

　　很可能每个对象都有一个方法表。因为方法表加快了调用实例方法时的效率。

　　方法数据存放在类的方法区中，包含一个方法的具体实现的字节码二进制。方法指针   直接指向这个方法在内存中的起始位置，通过方法指针就可以找到这个方法。

 

 

【动态绑定内部机制】

　　方法表是一个指向方法区中的方法指针的数组。

　　方法表中不包含static、private等静态绑定的方法，仅仅包含那些需要动态绑定的实例方法。

　　虚拟机从对象内存中的第一个指针“特殊结构指针”开始，可以找到实际对象的类型数据和Class实例，这样虚拟机就可以知道base引用的实际对象是Derive。

 

【符号引用】

　　在java中，一个java类将会编译成一个class文件。在编译时，java类并不知道引用类的实际内存地址，因此只能使用符号引用来代替。比如 org.simple.People类引用org.simple.Tool类，在编译时People类并不知道Tool类的实际内存地址，因此只能使用符号org.simple.Tool(假设)来表示Tool类的地址。 

　　而在类装载器 装载People类时 ，此时可以 通过虚拟机获取Tool类的实际内存地址 ，因此便可以既将符号org.simple.Tool替换为Tool类的实际内存地址，及直接引用地址。

 

---

【Java动态绑定机制的内幕】http://hxraid.iteye.com/blog/428891

 

JVM是如何知道调用的是哪个类的方法源代码？

 

揭露JVM方法调用的静态(static binding) 和动态绑定机制(auto binding) 。

——

public class StaticCall{  

       public static void main(){  

            Father.f1(); //调用静态方法  

       } 

}

执行方法调用的语句(Father.f1())被编译器编译成了一条指令：invokestatic #13。

 (1) 指令中的#13指的是StaticCall类的常量池中第13个常量表的索引项(关于常量池详见《Class文件内容及常量池 》)。

这个常量表(CONSTATN_Methodref_info ) 记录的是方法f1信息的符号引用(包括f1所在的类名，方法名和返回类型)。JVM会首先根据这个符号引用找到方法f1所在的类的全限定名: hr.test.Father。

     (2) 紧接着JVM会加载、链接和初始化Father类。

     (3) 然后在Father类所在的方法区中找到f1()方法的直接地址，并将这个直接地址记录到StaticCall类的常量池索引为13的常量表中。这个过程叫【常量池解析】，以后再次调用Father.f1()时，将直接找到f1方法的字节码。

     (4) 完成了StaticCall类常量池索引项13的常量表的解析之后，JVM就可以调用f1()方法，并开始解释执行f1()方法中的指令了。

通过上面的过程，我们发现经过常量池解析之后，JVM就能够确定要调用的f1()方法具体在内存的什么位置上了。

实际上，这个信息在编译阶段就已经在StaticCall类的常量池中记录了下来。这种在编译阶段就能够确定调用哪个方法的方式，我们叫做 静态绑定机制 。

除了被 static 修饰的静态方法，所有被 private 修饰的私有方法、被 final 修饰的禁止子类覆盖的方法都会被编译成invokestatic指令。

另外所有类的初始化方法<init>和<clinit>会被编译成invokespecial指令。 

应该是private修饰的私有方法会被编译为invokespecial指令。

JVM会采用静态绑定机制来顺利的调用这些方法。 

 

——

package hr.test;  

//被调用的父类  

class Father{  

    public void f1(){  

        System.out.println("father-f1()");  

    }  

        public void f1(int i){  

                System.out.println("father-f1()  para-int "+i);  

        }  

}  

//被调用的子类  

class Son extends Father{  

    public void f1(){ //覆盖父类的方法  

        System.out.println("Son-f1()");  

    }  

        public void f1(char c){  

                System.out.println("Son-s1() para-char "+c);  

        }  

}  

 

//调用方法  

import hr.test.*;  

public class AutoCall{  

    public static void main(String[] args){  

        Father father=new Son(); //多态  

        father.f1(); //打印结果： Son-f1()  

    }  

}

 

JVM是如何知道f.f1()调用的是子类Sun中方法而不是Father中的方法呢？在解释这个问题之前，我们首先简单的讲下JVM管理的一个非常重要的数据结构—— 方法表 。

 

在 JVM加载类的同时，会在 方法区中为这个类存放很多信息(详见《 Java 虚拟机体系结构 》)。其中就有一个数据结构叫 方法表。 它以数组的形式记录了当前类及其所有超类的可见方法字节码在内存中的直接地址 。

 

下图是上面源代码中Father和Sun类在方法区中的方法表：

 

对于上面的源代码，编译器首先会把main方法编译成下面的字节码指令：多态调用的字节码指令代码

0  new hr.test.Son [13] //在堆中开辟一个Son对象的内存空间，并将对象引用压入操作数栈  

3  dup    

4  invokespecial #7 [15] // 调用初始化方法来初始化堆中的Son对象  

7  astore_1 //弹出操作数栈的Son对象引用压入局部变量1中  

8  aload_1 //取出局部变量1中的对象引用压入操作数栈  

9  invokevirtual #15 //调用f1()方法  

12  return  

 

其中invokevirtual指令的详细调用过程是这样的：

       (1) invokevirtual指令中的#15指的是AutoCall类的常量池中第15个常量表的索引项。这个常量表(CONSTATN_Methodref_info ) 记录的是方法f1信息的符号引用(包括f1所在的类名，方法名和返回类型)。JVM会首先根据这个符号引用找到调用方法f1的类的全限定名: hr.test.Father。这是因为调用方法f1的类的对象father声明为Father类型。

       (2) 在Father类型的方法表中查找方法f1，如果找到，则将方法f1在方法表中的索引项11(如上图)记录到AutoCall类的常量池中第15个常量表中(常量池解析 )。这里有一点要注意：如果Father类型方法表中没有方法f1，那么即使Son类型中方法表有，编译的时候也通过不了。因为调用方法f1的类的对象father的声明为Father类型。

       (3) 在调用invokevirtual指令前有一个aload_1指令，它会将开始创建在堆中的Son对象的引用压入操作数栈。

　　然后invokevirtual指令会根据这个Son对象的引用首先找到堆中的Son对象

　　然后进一步找到Son对象所属类型的方法表。过程如下图所示：

　　(4) 这是通过第(2)步中解析完成的#15常量表中的方法表的索引项【子类采用相同的索引号】11，可以定位到Son类型方法表中的方法f1()，然后通过直接地址找到该方法字节码所在的内存空间。

      很明显，根据对象(father)的声明类型(Father)还不能够确定调用方法f1的位置，必须根据father在堆中实际创建的对象类型Son来确定f1方法所在的位置。这种在程序运行过程中，通过动态创建的对象的方法表来定位方法的方式，我们叫做 动态绑定机制 。

上面的过程很清楚的反映出在方法覆盖的多态调用的情况下，JVM是如何定位到准确的方法的。

——

但是下面的调用方法JVM是如何定位的呢？(仍然使用上面代码中的Father和Son类型)

 

1. public class AutoCall{  
2.        public static void main(String[] args){  
3.              Father father=new Son();  
4.              char c='a';  
5.              father.f1(c); //打印结果：father-f1()  para-int 97  
6.        }  
7. }  

       问题是Fahter类型中并没有方法签名为f1(char)的方法呀。但打印结果显示JVM调用了Father类型中的f1(int)方法，并没有调用到Son类型中的f1(char)方法。

 

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

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

 

但是还有一个问题，如果通过自动转型发现可以“凑合”出两个方法的话怎么办？比如下面的代码：

Java代码  

1. class Father{  
2.     public void f1(Object o){  
3.         System.out.println("Object");  
4.     }  
5.     public void f1(double[] d){  
6.         System.out.println("double[]");  
7.     }  
8.       
9. }  
10. public class Demo{  
11.     public static void main(String[] args) {  
12.         new Father().f1(null); //打印结果： double[]  
13.     }  
14. }  

        null可以引用于任何的引用类型，那么JVM如何确定“合适”的方法呢。一个很重要的标准就是：如果一个方法可以接受传递给另一个方法的任何参数，那么第一个方法就相对不合适。比如上面的代码: 任何传递给f1(double[])方法的参数都可以传递给f1(Object)方法，而反之却不行，那么f1(double[])方法就更合适【小范围】。因此JVM就会调用这个更合适的方法。

 

★ 总结

 

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

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

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

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

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

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

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

 

★ 覆写（override）

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

Java代码  

1. class Base{  
2.       public void f(){}  
3. }  
4. class Derived extends Base{  
5.       public void f(){}  
6. }  

 

 

★ 隐藏（hide）

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

Java代码  

1. class Base{  
2.       public static void f(){}  
3. }  
4. class Derived extends Base  {  
5.       private static void f(){}   //hides Base. f()  
6. }  

 

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

Java代码  

1. class CircuitBreaker{  
2.       public void f (int i){}    //int overloading  
3.       public void f(String s){}   //String overloading  
4. }  

 

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

Java代码  

1. class WhoKnows{  
2.     static String sentence=”I don't know.”;  
3.     public static void main(String[] args〕{  
4.            String sentence=”I don't know.”;  //shadows static field  
5.            System.out. println (sentence);  // prints local variable  打印局部变量
6.     }  
7. }  

      尽管遮蔽通常是被劝阻的，但是有一种通用的惯用法确实涉及遮蔽。

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

Java代码  

1. class Belt{  
2.       private find int size ;  //Parameter shadows Belt. size  
3.       public Belt (int size){  
4.            this. size=size;  
5.       }  
6. }  

 

★ 遮掩（obscure）

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

Java代码  

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

 

---

【常量池和符号解析】【  http://blog.chinaunix.net/uid-21880738-id-1813104.html 】

 

public class BaseTest 
2.{ 
3. public void sayHello2() 
4. { 
5. System.out.println("sayHello2"); 
6. } 
7.} 
8. 
9.public class Test extends BaseTest 
10.{ 
11. public void sayHello() 
12. { 
13. super.sayHello2();//使用invokespecial 

14. sayHello3();//使用invokestatic 

15. sayHello4();//使用invokevirtual 

16. } 
17. 
18. public static void sayHello3() 
19. { 
20. System.out.println("sayHello3"); 
21. } 
22. 
23. public void sayHello4() 
24. { 
25. System.out.println("sayHello4"); 
26. } 
27.}

看看sayHello的字节码

 

public void sayHello();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0 //将方法第一参数的地址推入栈顶，方法第一个参数就是this

1: invokespecial #15; //Method sayHello2:()V，这里字节码由操作码和常量池的

//偏移量组成，这里使用invokespecial是因为可以确定调用的就是BaseTest的sayHello2方法，另外调用的时候会根据方法需要的参数从栈顶弹出相应的参数

4: invokestatic #18; //Method sayHello3【不会被继承，所以没有aload_0(栈帧顶元素)】:()V，static方法不需要this参数

7: aload_0
8: invokevirtual #21; //Method sayHello4:()V，这里使用invokevirtual是因为Test有可能被继承，如果Test被继承而且继承类重载了sayHello4方法，调用的则会是继承类的sayHello方法

11: return

 

 

0xd6 invokevirtual_quick
0xd7 invokenonvirtual_quick
0xd8 invokesuper_quick
0xd9 invokestatic_quick
0xda invokeinteface_quick
0xdb invokevirtualobject_quick