java方法調用之動態調用多態（重寫override）的實現原理——方法表（三）

package org.fan.learn.methodTable;

/**
 * Created by fan on 2016/3/30.
 */
public class ClassReference {
    static class Person {
        @Override
        public String toString(){
            return "I'm a person.";
        }
        public void eat(){
            System.out.println("Person eat");
        }
        public void speak(){
            System.out.println("Person speak");
        }

    }

    static class Boy extends Person{
        @Override
        public String toString(){
            return "I'm a boy";
        }
        @Override
        public void speak(){
            System.out.println("Boy speak");
        }
        public void fight(){
            System.out.println("Boy fight");
        }
    }

    static class Girl extends Person{
        @Override
        public String toString(){
            return "I'm a girl";
        }
        @Override
        public void speak(){
            System.out.println("Girl speak");
        }
        public void sing(){
            System.out.println("Girl sing");
        }
    }

    public static void main(String[] args) {
        Person boy = new Boy();
        Person girl = new Girl();
        System.out.println(boy);
        boy.eat();
        boy.speak();
        //boy.fight();
        System.out.println(girl);
        girl.eat();
        girl.speak();
        //girl.sing();
    }
}

注意，boy.fight(); 和 girl.sing(); 這兩個是有問題的，在IDEA中會提示“Cannot resolve method ‘fight()’”。因為，方法的調用是有靜態類型檢查的，而boy和girl的靜態類型都是Person類型的，在Person中沒有fight方法和sing方法。因此，會報錯。
執行結果如下：

從上圖可以看到，boy.eat() 和 girl.eat() 調用產生的輸出都是”Person eat”，因為Boy和Girl中沒有override 父類的eat方法。
字節碼指令：

public static void main(java.lang.String[]);
  Code:
   Stack=2, Locals=3, Args_size=1
   0:   new     #2; //class ClassReference$Boy
   3:   dup
   4:   invokespecial   #3; //Method ClassReference$Boy."":()V
   7:   astore_1
   8:   new     #4; //class ClassReference$Girl
   11:  dup
   12:  invokespecial   #5; //Method ClassReference$Girl."":()V
   15:  astore_2
   16:  getstatic       #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   19:  aload_1
   20:  invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/Object;)V
   23:  aload_1
   24:  invokevirtual   #8; //Method ClassReference$Person.eat:()V
   27:  aload_1
   28:  invokevirtual   #9; //Method ClassReference$Person.speak:()V
   31:  getstatic       #6; //Field java/lang/System.out:Ljava/io/PrintStream;
   34:  aload_2
   35:  invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/Object;)V
   38:  aload_2
   39:  invokevirtual   #8; //Method ClassReference$Person.eat:()V
   42:  aload_2
   43:  invokevirtual   #9; //Method ClassReference$Person.speak:()V
   46:  return

其中所有的invokevirtual調用的都是Person類中的方法。

下面看看java對象的內存模型：

從上圖可以清楚地看到調用方法的指針指向。而且可以看出相同簽名的方法在方法表中的偏移量是一樣的。這個偏移量只是說Boy方法表中的繼承自Object類的方法、繼承自Person類的方法的偏移量與Person類中的相同方法的偏移量是一樣的，與Girl是沒有任何關系的。

下面再看看調用過程，以girl.speak() 方法的調用為例。在我的字節碼中，這條指令對應43: invokevirtual #9; //Method ClassReference$Person.speak:()V ，為了便於使用IBM的圖，這裡采用跟IBM一致的符號引用：invokevirtual #12; 。調用過程圖如下所示：

(1)在常量池中找到方法調用的符號引用
(2)查看Person的方法表，得到speak方法在該方法表的偏移量（假設為15），這樣就得到該方法的直接引用。
(3)根據this指針確定方法接收者(girl)的實際類型
(4)根據對象的實際類型得到該實際類型對應的方法表，根據偏移量15查看有無重寫（override）該方法，如果重寫，則可以直接調用；如果沒有重寫，則需要拿到按照繼承關系從下往上的基類（這裡是Person類）的方法表，同樣按照這個偏移量15查看有無該方法。

接口引用調用invokeinterface

代碼如下：

package org.fan.learn.methodTable;

/**
 * Created by fan on 2016/3/29.
 */
public class InterfaceReference {
    interface IDance {
        void dance();
    }

    static class Person {
        @Override
        public String toString() {
            return "I'm a person";
        }
        public void speak() {
            System.out.println("Person speak");
        }
        public void eat() {
            System.out.println("Person eat");
        }
    }

    static class Dancer extends Person implements IDance {
        @Override
        public String toString() {
            return "I'm a Dancer";
        }
        @Override
        public void speak() {
            System.out.println("Dancer speak");
        }
        public void dance() {
            System.out.println("Dancer dance");
        }
    }

    static class Snake implements IDance {
        @Override
        public String toString() {
            return "I'm a Snake";
        }
        public void dance() {
            System.out.println("Snake dance");
        }
    }

    public static void main(String[] args) {
        IDance dancer = new Dancer();
        System.out.println(dancer);
        dancer.dance();
        //dancer.speak();
        //dancer.eat();
        IDance snake = new Snake();
        System.out.println(snake);
        snake.dance();
    }
}

上面的代碼中dancer.speak(); dancer.eat(); 這兩句同樣不能調用。
執行結果如下所示：

其字節碼指令如下所示：

public static void main(java.lang.String[]);
  Code:
   Stack=2, Locals=3, Args_size=1
   0:   new     #2; //class InterfaceReference$Dancer
   3:   dup
   4:   invokespecial   #3; //Method InterfaceReference$Dancer."":()V
   7:   astore_1
   8:   getstatic       #4; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  aload_1
   12:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/Object;)V
   15:  aload_1
   16:  invokeinterface #6,  1; //InterfaceMethod InterfaceReference$IDance.dance:()V
   21:  new     #7; //class InterfaceReference$Snake
   24:  dup
   25:  invokespecial   #8; //Method InterfaceReference$Snake."":()V
   28:  astore_2
   29:  getstatic       #4; //Field java/lang/System.out:Ljava/io/PrintStream;
   32:  aload_2
   33:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/Object;)V
   36:  aload_2
   37:  invokeinterface #6,  1; //InterfaceMethod InterfaceReference$IDance.dance:()V
   42:  return

從上面的字節碼指令可以看到，dancer.dance(); 和snake.dance(); 的字節碼指令都是invokeinterface #6, 1; //InterfaceMethod InterfaceReference$IDance.dance:()V 。
為什麼invokeinterface指令會有兩個參數呢？

對象的內存模型如下所示：

從上圖可以看到IDance接口中的方法dance(）在Dancer類的方法表中的偏移量跟在Snake類的方法表中的偏移量是不一樣的，因此無法僅根據偏移量來進行方法的調用。（這句話在理解時，要注意，只是為了強調invokeinterface在查找方法時不再是基於偏移量來實現的，而是基於搜索的方式。）應該這麼說，dance方法在IDance方法表（如果有的話）中的偏移量與在Dancer方法表中的偏移量是不一樣的。
因此，要在Dancer的方法表中找到dance方法，必須搜索Dancer的整個方法表。

下面寫一個，如果Dancer中沒有重寫（override）toString方法，會發生什麼？
代碼如下：

package org.fan.learn.methodTable;

/**
 * Created by fan on 2016/3/29.
 */
public class InterfaceReference {
    interface IDance {
        void dance();
    }

    static class Person {
        @Override
        public String toString() {
            return "I'm a person";
        }
        public void speak() {
            System.out.println("Person speak");
        }
        public void eat() {
            System.out.println("Person eat");
        }
    }

    static class Dancer extends Person implements IDance {
//        @Override
//        public String toString() {
//            return "I'm a Dancer";
//        }
        @Override
        public void speak() {
            System.out.println("Dancer speak");
        }
        public void dance() {
            System.out.println("Dancer dance");
        }
    }

    static class Snake implements IDance {
        @Override
        public String toString() {
            return "I'm a Snake";
        }
        public void dance() {
            System.out.println("Snake dance");
        }
    }

    public static void main(String[] args) {
        IDance dancer = new Dancer();
        System.out.println(dancer);
        dancer.dance();
        //dancer.speak();
        //dancer.eat();
        IDance snake = new Snake();
        System.out.println(snake);
        snake.dance();
    }
}

執行結果如下：

可以看到System.out.println(dancer); 調用的是Person的toString方法。
內存模型如下所示：

結束語

這篇博文討論了invokevirtual和invokeinterface的內部實現的區別，以及override的實現原理。下一步，打算討論下invokevirtual的具體實現細節，如：如何實現符號引用到直接引用的轉換的？可能會看下OpenJDK底層的C++實現。