轉自：http://blog.csdn.net/zhengzhb/article/details/7496949
java的動態綁定
所謂的動態綁定就是指程執行期間（而不是在編譯期間）判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。java繼承體系中的覆蓋就是動態綁定的，看一下如下的代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
classFather
{ publicvoid
method(){ System.out.println("This
is Father's method"); }}classSon1
extendsFather{ publicvoid
method(){ System.out.println("This
is Son1's method"); }}classSon2
extendsFather{ publicvoid
method(){ System.out.println("This
is Son2's method"); }}publicclass
Test { publicstatic
void
main(String[] args){ Father
s1 = newSon1(); s1.method(); Father
s2 = newSon2(); s2.method(); }} |
運行結果如下：
This is Son1′s method
This is Son2′s method
通過運行結果可以看到，儘管我們引用的類型是Father類型的，但是運行時卻是調用的它實際類型（也就是Son1和Son2）的方法，這就是動態綁定。在java語言中，繼承中的覆蓋就是是動態綁定的，當我們用父類引用實例化子類時，會根據引用的實際類型調用相應的方法。
java的靜態綁定
相對於動態綁定，靜態綁定就是指在編譯期就已經確定執行哪一個方法。在java中，方法的重載（方法名相同而參數不同）就是靜態綁定的，重載時，執行哪一個方法在編譯期就已經確定下來了。看一下代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
classFather
{}classSon1
extendsFather{}classSon2
extendsFather{}classExecute
{ publicvoid
method(Father father){ System.out.println("This
is Father's method"); } publicvoid
method(Son1 son){ System.out.println("This
is Son1's method"); } publicvoid
method(Son2 son){ System.out.println("This
is Son2's method"); }}publicclass
Test { publicstatic
void
main(String[] args){ Father
father = newFather(); Father
s1 = newSon1(); Father
s2 = newSon2(); Execute
exe = newExecute(); exe.method(father); exe.method(s1); exe.method(s2); }} |
運行結果如下：
This is Father’s method
This is Father’s method
This is Father’s method
在這裏，程序在編譯的時候就已經確定使用method(Father father)方法了，不管我們在運行的時候傳入的實際類型是什麼，它永遠都只會執行method(Father father)這個方法。也就是說，java的重載是靜態綁定的。
instanceof操作符與轉型
有時候，我們希望在使用重載的時候，程序能夠根據傳入參數的實際類型動態地調用相應的方法，也就是說，我們希望java的重載是動態的，而不是靜態的。但是由於java的重載不是動態綁定，我們只能通過程序來人爲的判斷，我們一般會使用instanceof操作符來進行類型的判斷。我們要對method(Father father)進行修改，在方法體中判斷運行期間的實際類型，修改後的method(Father father)方法如下：
|
1
2
3
4
5
6
7
8
9
|
publicvoid
method(Father father){ if(fatherinstanceofSon1){ method((Son1)father); }elseif(fatherinstanceofSon2){ method((Son2)father); }elseif(fatherinstanceofFather){ System.out.println("This
is Father's method"); }} |
請注意，我們必須把判斷是否是父類的條件（也就是判斷是否爲Father類的條件）放到最後，否則將一律會被判斷爲Father類，達不到我們動態判斷的目的。修改代碼後，程序就可以動態地根據參數的實際類型來調用相應的方法了。運行結果如下：
This is Father’s method
This is Son1′s method
This is Son2′s method
但是這種實現方式有一個明顯的缺點，它是僞動態的，仍然需要我們來通過程序來判斷類型。假如Father有100個子類的話，還是這樣來實現顯然是不合適的。必須通過其他更好的方式實現才行，我們可以使用雙分派方式來實現動態綁定。
用雙分派實現動態綁定
首先，什麼是雙分派？還記得23種設計模式（9）：訪問者模式中一開始舉的例子嗎？
類A中的方法method1和method2的區別就是，method2是雙分派。我們可以看一下java雙分派的特點：首先要有一個訪問類B，類B提供一個showA(A a) 方法，在方法中，調用類A的method1方法，然後類A的method2方法中調用類B的showA方法並將自己作爲參數傳給showA。雙分派的核心就是這個this對象。說到這裏，我們已經明白雙分派是怎麼回事了，但是它有什麼效果呢？就是可以實現方法的動態綁定，我們可以對上面的程序進行修改，代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
classFather
{ publicvoid
accept(Execute exe){ exe.method(this); }}classSon1
extendsFather{ publicvoid
accept(Execute exe){ exe.method(this); }}classSon2
extendsFather{ publicvoid
accept(Execute exe){ exe.method(this); }}classExecute
{ publicvoid
method(Father father){ System.out.println("This
is Father's method"); } publicvoid
method(Son1 son){ System.out.println("This
is Son1's method"); } publicvoid
method(Son2 son){ System.out.println("This
is Son2's method"); }}publicclass
Test { publicstatic
void
main(String[] args){ Father
father = newFather(); Father
s1 = newSon1(); Father
s2 = newSon2(); Execute
exe = newExecute(); father.accept(exe); s1.accept(exe); s2.accept(exe); }} |
可以看到我們修改的地方，在Father，Son1，Son2中分別加入一個雙分派的方法。調用的時候，原本是調用Execute的method方法，現在改爲調用Father的accept方法。運行結果如下：
This is Father’s method
This is Son1′s method
This is Son2′s method
運行結果符合我們的預期，實現了動態綁定。雙分派實現動態綁定的本質，就是在重載方法委派的前面加上了繼承體系中覆蓋的環節，由於覆蓋是動態的，所以重載就是動態的了，與使用instanceof操作符的效果是一樣的（用instanceof操作符可以實現重載方法動態綁定的原因也是因爲instanceof操作符是動態的）。但是與使用instanceof操作符實現動態綁定相比，雙分派方式的可擴展性要好的多。