Java中的靜態綁定與動態綁定詳細介紹

一個Java程式的執行要經過編譯和執行（解釋）這兩個步驟，同時Java又是物件導向的程式語言。當子類別和父類別存在同一個方法，子類別重寫了父類別的方法，程式在執行時呼叫方法是呼叫父類別的方法還是子類別的重寫方法呢，這應該是我們在初學Java時遇到的問題。這裡首先我們將確定這種呼叫何種方法實作或變數的操作叫做綁定。

在Java中存在兩種綁定方式，一種為靜態綁定，又稱作早期綁定。另一種是動態綁定，也稱為後期綁定。

區別對比

1.靜態綁定發生在編譯時期，動態綁定發生在運行時
2.使用private或static或final修飾的變數或方法，使用靜態綁定。而虛方法（可以被子類別重寫的方法）則會根據運行時的物件進行動態綁定。
3.靜態綁定使用類別資訊來完成，而動態綁定則需要使用物件資訊來完成。
4.重載(Overload)的方法使用靜態綁定完成，而重寫(Override)的方法則使用動態綁定完成。

重載方法的範例

這裡展示一個重載方法的範例。

public class TestMain {
  public static void main(String[] args) {
      String str = new String();
      Caller caller = new Caller();
      caller.call(str);
  }
  static class Caller {
      public void call(Object obj) {
          System.out.println("an Object instance in Caller");
      }
      
      public void call(String str) {
          System.out.println("a String instance in in Caller");
      }
  }
}

執行的結果為

22:19 $ java TestMain
a String instance in in Caller

在上面的程式碼中，call方法存在兩個重載的實現，一個是接收Object類型的物件作為參數，另一個則是接收String類型的物件作為參數。 str是一個String對象，所有接收String類型參數的call方法都會被呼叫。而這裡的綁定就是在編譯時期根據參數型別進行的靜態綁定。

驗證

光看表象無法證明是進行了靜態綁定，使用javap發編譯一下即可驗證。

22:19 $ javap -c TestMain
Compiled from "TestMain.java"
public class TestMain {
  public TestMain();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/String
       3: dup
       4: invokespecial #3                  // Method java/lang/String."<init>":()V
       7: astore_1
       8: new           #4                  // class TestMain$Caller
      11: dup
      12: invokespecial #5                  // Method TestMain$Caller."<init>":()V
      15: astore_2
      16: aload_2
      17: aload_1
      18: invokevirtual #6                  // Method TestMain$Caller.call:(Ljava/lang/String;)V
      21: return
}

看到了這一行18: invokevirtual #6 // Method TestMain$Caller.call:(Ljava/lang/String;)V確實是發生了靜態綁定，確定了呼叫了接收String物件作為參數的caller方法。

重寫方法的範例

public class TestMain {
  public static void main(String[] args) {
      String str = new String();
      Caller caller = new SubCaller();
      caller.call(str);
  }
  
  static class Caller {
      public void call(String str) {
          System.out.println("a String instance in Caller");
      }
  }
  
  static class SubCaller extends Caller {
      @Override
      public void call(String str) {
          System.out.println("a String instance in SubCaller");
      }
  }
}

執行的結果為

22:27 $ java TestMain
a String instance in SubCaller

上面的程式碼，Caller中有一個call方法的實現，SubCaller繼承Caller，並且重寫了call方法的實作。我們宣告了一個Caller類型的變數callerSub，但是這個變數指向的時一個SubCaller的物件。根據結果可以看出，其呼叫了SubCaller的call方法實現，而非Caller的call方法。這結果的產生的原因是因為在運行時發生了動態綁定，在綁定過程中需要確定呼叫哪個版本的call方法實作。

驗證

使用javap不能直接驗證動態綁定，然後如果證明沒有進行靜態綁定，那麼就說明進行了動態綁定。

22:27 $ javap -c TestMain
Compiled from "TestMain.java"
public class TestMain {
  public TestMain();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/String
       3: dup
       4: invokespecial #3                  // Method java/lang/String."<init>":()V
       7: astore_1
       8: new           #4                  // class TestMain$SubCaller
      11: dup
      12: invokespecial #5                  // Method TestMain$SubCaller."<init>":()V
      15: astore_2
      16: aload_2
      17: aload_1
      18: invokevirtual #6                  // Method TestMain$Caller.call:(Ljava/lang/String;)V
      21: return
}

如同上面的結果，18: invokevirtual #6 // Method TestMain$Caller.call:(Ljava/lang/String;)V這裡是TestMain$Caller.call而非TestMain$SubCaller.call，因為編譯期無法確定呼叫子類別還是父類別的實現，所以只能丟給運行時的動態綁定來處理。

當重載遇上重寫

下面的例子有點變態哈，Caller類中存在call方法的兩種重載，更複雜的是SubCaller集成Caller並且重寫了這兩個方法。其實這種情況是上面兩種情況的複合情況。

下面的程式碼首先會發生靜態綁定，確定呼叫參數為String物件的call方法，然後在執行時間進行動態綁定確定執行子類別還是父類別的call實作。

public class TestMain {
  public static void main(String[] args) {
      String str = new String();
      Caller callerSub = new SubCaller();
      callerSub.call(str);
  }
  
  static class Caller {
      public void call(Object obj) {
          System.out.println("an Object instance in Caller");
      }
      
      public void call(String str) {
          System.out.println("a String instance in in Caller");
      }
  }
  
  static class SubCaller extends Caller {
      @Override
      public void call(Object obj) {
          System.out.println("an Object instance in SubCaller");
      }
      
      @Override
      public void call(String str) {
          System.out.println("a String instance in in SubCaller");
      }
  }
}

執行結果為

22:30 $ java TestMain
a String instance in in SubCaller

驗證

由於上面已經介紹，這裡只貼一下反編譯結果啦

22:30 $ javap -c TestMain
Compiled from "TestMain.java"
public class TestMain {
  public TestMain();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/String
       3: dup
       4: invokespecial #3                  // Method java/lang/String."<init>":()V
       7: astore_1
       8: new           #4                  // class TestMain$SubCaller
      11: dup
      12: invokespecial #5                  // Method TestMain$SubCaller."<init>":()V
      15: astore_2
      16: aload_2
      17: aload_1
      18: invokevirtual #6                  // Method TestMain$Caller.call:(Ljava/lang/String;)V
      21: return
}

好奇問題

非動態綁定不可麼？

其實理論上，某些方法的綁定也可以由靜態綁定實現。例如：

public static void main(String[] args) {
      String str = new String();
      final Caller callerSub = new SubCaller();
      callerSub.call(str);
}

例如這裡callerSub持有subCaller的物件並且callerSub變數為final，立即執行了call方法，編譯器理論上透過足夠的分析程式碼，是可以知道應該呼叫SubCaller的call方法。

但是為什麼沒有進行靜態綁定呢？
假設我們的Caller繼承自某一個框架的BaseCaller類，其實作了call方法，而BaseCaller繼承自SuperCaller。 SuperCaller中對call方法也進行了實作。

假設某個框架1.0中的BaseCaller和SuperCaller

static class SuperCaller {
  public void call(Object obj) {
      System.out.println("an Object instance in SuperCaller");
  }
}
  
static class BaseCaller extends SuperCaller {
  public void call(Object obj) {
      System.out.println("an Object instance in BaseCaller");
  }
}

而我們使用框架1.0進行了這樣的實作。 Caller繼承自BaseCaller，並且呼叫了super.call方法。

public class TestMain {
  public static void main(String[] args) {
      Object obj = new Object();
      SuperCaller callerSub = new SubCaller();
      callerSub.call(obj);
  }
  
  static class Caller extends BaseCaller{
      public void call(Object obj) {
          System.out.println("an Object instance in Caller");
          super.call(obj);
      }
      
      public void call(String str) {
          System.out.println("a String instance in in Caller");
      }
  }
  
  static class SubCaller extends Caller {
      @Override
      public void call(Object obj) {
          System.out.println("an Object instance in SubCaller");
      }
      
      @Override
      public void call(String str) {
          System.out.println("a String instance in in SubCaller");
      }
  }
}

然後我們基於這個框架的1.0版編譯出來了class文件，假設靜態綁定可以確定上面Caller的super.call為BaseCaller.call實作。

然後我們再次假設這個框架1.1版本中BaseCaller不重寫SuperCaller的call方法，那麼上面的假設可以靜態綁定的call實現在1.1版本就會出現問題，因為在1.1版本上super.call應該是使用SuperCall的call方法實現，而非假設使用靜態綁定確定的BaseCaller的call方法實現。

所以，有些實際上可以靜態綁定的，考慮到安全和一致性，就索性都進行了動態綁定。

得到的最佳化啟示？

由於動態綁定需要在運行時確定執行哪個版本的方法實現或變量，比起靜態綁定起來要耗時。

所以在不影響整體設計，我們可以考慮將方法或變數使用private，static或final來修飾。

更多Java中的靜態綁定和動態綁定詳細介紹相關文章請關注PHP中文網！