http://www.jb51.net/article/59929.htm
一個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小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)