Java的动态绑定机制

Java的动态绑定又称为运行时绑定。意思就是说，程序会在运行的时候自动选择调用哪儿个方法。

一、动态绑定的过程：

　　例子：

1 public class Son extends Father
2 Son son = new Son();
3 son.method();

　　1. 首先，编译器根据对象的声明类型和方法名，搜索相应类(Son)及其父类(Father)的“方法表”，找出所有访问属性为public的method方法。

　　　 可能存在多个方法名为method的方法，只是参数类型或数量不同。

　　2. 然后，根据方法的“签名”找出完全匹配的方法。

　　　 方法的名称和参数列表称为方法的签名。

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

1 public Father getFather(){...}  //父类中的方法
2 public Son getFather(){...}     //子类覆盖父类中的getFather()方法

　　3. 如果是private、static、final 方法或者是构造器，则编译器明确地知道要调用哪儿个方法，这种调用方式成为“静态调用”。

　　4. 调用方法。

　　　 如果子类Son中定义了 method() 的方法，则直接调用子类中的相应方法；如果子类Son中没有定义相应的方法，则到其父类中寻找method()方法。

二、Demo

　　1. 子类重写父类中的方法，调用子类中的方法

1 public class Father{
 2     public void method(){
 3         System.out.println("父类方法："+this.getClass());
 4     }
 5 }
 6 public class Son extends Father{
 7     public void method(){
 8        System.out.println("子类方法"+this.getClass());
 9     }
10     public static void main(String[] args){
11         Father instance = new Son();
12         instance.method();
13     }
14 }
15 //结果：子类方法：class Son

　　2. 子类没有重写父类中的方法，所以到父类中寻找相应的方法

public class Father{
    public void method(){
        System.out.println("父类方法："+this.getClass());
    }
}
public class Son extends Father{
    public static void main(String[] args){
        Father instance = new Son();
        instance.method();
    }
}
//结果：父类方法：class Son

三、动态绑定只是针对对象的方法，对于属性无效。因为属性不能被重写。

1 public class Father{
 2     public String name = "父亲属性";
 3 }
 4 public class Son extends Father{
 5     public String name = "孩子属性";
 6 
 7     public static void main(String[] args){
 8         Father instance = new Son();
 9         System.out.println(instance.name);
10     }
11 }
12 //结果：父亲属性\

 

                             JAVA动态绑定的内部实现机制

  JAVA虚拟机调用一个类方法时，它会基于对象引用的类型(通常在编译时可知)来选择所调用的方法。相反，当虚拟机调用一个实例方法时，它会基于对象实际的类型(只能在运行时得知)来选择所调用的方法，这就是动态绑定，是多态的一种。动态绑定为解决实际的业务问题提供了很大的灵活性，是一种非常优美的机制。

1 JAVA对象模型

  JAVA虚拟机规范并没有规定JAVA对象在堆里是如何表示的。对象的内部表示也影响着整个堆以及垃圾收集器的设计，它由虚拟机的实现者决定。

  JAVA对象中包含的基本数据由它所属的类及其所有超类声明的实例变量组成。只要有一个对象引用，虚拟机就必须能够快速地定位对象实例的数据。另外，它也必须能通过该对象引用访问相应的类数据(存储于方法区的类型信息)，因此在对象中通常会有一个指向方法区的指针。当程序在运行时需要转换某个对象引用为另外一种类型时，虚拟机必须要检查这种转换是否被允许，被转换的对象是否的确是被引用的对象或者它的超类型。当程序在执行instanceof操作时，虚拟机也进行了同样的检查。所以虚拟机都需要查看被引用的对象的类数据。

  不管虚拟机的实现使用什么样的对象表示法，很可能每个对象都有一个方法表因为方法表加快了调用实例方法时的效率。但是JAVA虚拟机规范并未要求必须使用方法表，所以并不是所有实现中都会使用它。

  下面是一种JAVA对象的内存表示：

 

JAVA对象内存模型

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

2 动态绑定内部机制

  方法表是一个指向方法区中的方法指针的数组。方法表中不包含static、private等静态绑定的方法，仅仅包含那些需要动态绑定的实例方法。

  在方法表中，来自超类的方法出现在来自子类的方法之前，并且排列方法指针的顺序和方法在class文件中出现的顺序相同，这种排列顺序的例外情况是，被子类的方法覆盖的方法出现在超类中该方法第一次出现的地方。

  例如有超类Base和子类Derive：

1. public class Base   
2. {  
3.   public Base()  
4.   {  
5.   }  
6.      
7.   public void test()  
8.   {  
9.     System.out.println( "int Base" );  
10.   }  
11.     
12.   public void print()  
13.   {  
14.   }  
15. }  
16.   
17. public class Derive extends Base  
18. {  
19.   public Derive()  
20.   {  
21.   }  
22.   
23.   public void test()  
24.   {  
25.     System.out.println( "int Derive" );  
26.   }  
27.     
28.   public void sayHello()  
29.   {  
30.   }  
31.     
32.   public static void main( String[] args )  
33.   {  
34.       Base base = new Derive();  
35.       base.test();  
36.   }  
37. }  

 

 上例中的Base和Derive的方法表如下：

 

  在这个例子里，test()方法在Base和Derive的方法表中都是同一个位置-位置1。在Base方法表中，test()指针是Base的test()方法内存地址；而在Derive方法表中，方法表的位置1放置的是Derive的test()方法内存地址。

  当JAVA虚拟机执行base.test()时，通过base引用可以找到base所指向的实际对象的内存位置，现在虚拟机不知道base引用的实际对象是Base还是Derive。但是根据上面的对象内存模型，虚拟机从对象内存中的第一个指针“特殊结构指针”开始，可以找到实际对象的类型数据和Class实例，这样虚拟机就可以知道base引用的实际对象是Derive对。为了执行test()，虚拟机需要找到test()的字节码，方法的字节码存放在方法区中。虚拟机从对象内存中的第一个指针“特殊结构指针”开始，搜寻方法表的位置1，位置1指向的test()方法是Derive类的test()方法，这就是JAVA虚拟机将要执行的test()的字节码。现在，虚拟机知道了调用的实际对象是Derive对象，调用的实际test()方法是Derive类的test()方法，所以JAVA虚拟机能够正确执行-调用base引用的实际对象的方法而不是base引用本身的方法。

  这是动态绑定的一种实现方式，根据不同的JAVA虚拟机平台和不同的实际约束，动态绑定可以有不同的内部实现机制。

转载于:https://my.oschina.net/u/3704129/blog/1550634