Java中的靜態(tài)綁定和動態(tài)綁定詳細介紹
一個Java程序的執(zhí)行要經(jīng)過編譯和執(zhí)行（解釋）這兩個步驟，同時Java又是面向?qū)ο蟮木幊陶Z言。當子類和父類存在同一個方法，子類重寫了父類的方法，程序在運行時調(diào)用方法是調(diào)用父類的方法還是子類的重寫方法呢，這應該是我們在初學Java時遇到的問題。這里首先我們將確定這種調(diào)用何種方法實現(xiàn)或者變量的操作叫做綁定。
在Java中存在兩種綁定方式，一種為靜態(tài)綁定，又稱作早期綁定。另一種就是動態(tài)綁定，亦稱為后期綁定。
區(qū)別對比
1.靜態(tài)綁定發(fā)生在編譯時期，動態(tài)綁定發(fā)生在運行時
2.使用private或static或final修飾的變量或者方法，使用靜態(tài)綁定。而虛方法（可以被子類重寫的方法）則會根據(jù)運行時的對象進行動態(tài)綁定。
3.靜態(tài)綁定使用類信息來完成，而動態(tài)綁定則需要使用對象信息來完成。
4.重載(Overload)的方法使用靜態(tài)綁定完成，而重寫(Override)的方法則使用動態(tài)綁定完成。
重載方法的示例
這里展示一個重載方法的示例。
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");
}
}
}
執(zhí)行的結果為
22:19 $ java TestMain
a String instance in in Caller
在上面的代碼中，call方法存在兩個重載的實現(xiàn)，一個是接收Object類型的對象作為參數(shù)，另一個則是接收String類型的對象作為參數(shù)。str是一個String對象，所有接收String類型參數(shù)的call方法會被調(diào)用。而這里的綁定就是在編譯時期根據(jù)參數(shù)類型進行的靜態(tài)綁定。
驗證
光看表象無法證明是進行了靜態(tài)綁定，使用javap發(fā)編譯一下即可驗證。
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確實是發(fā)生了靜態(tài)綁定，確定了調(diào)用了接收String對象作為參數(shù)的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");
}
}
}
執(zhí)行的結果為
22:27 $ java TestMain
a String instance in SubCaller
上面的代碼，Caller中有一個call方法的實現(xiàn)，SubCaller繼承Caller，并且重寫了call方法的實現(xiàn)。我們聲明了一個Caller類型的變量callerSub，但是這個變量指向的時一個SubCaller的對象。根據(jù)結果可以看出，其調(diào)用了SubCaller的call方法實現(xiàn)，而非Caller的call方法。這一結果的產(chǎn)生的原因是因為在運行時發(fā)生了動態(tài)綁定，在綁定過程中需要確定調(diào)用哪個版本的call方法實現(xiàn)。
驗證
使用javap不能直接驗證動態(tài)綁定，然后如果證明沒有進行靜態(tài)綁定，那么就說明進行了動態(tài)綁定。
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，因為編譯期無法確定調(diào)用子類還是父類的實現(xiàn)，所以只能丟給運行時的動態(tài)綁定來處理。
當重載遇上重寫
下面的例子有點變態(tài)哈，Caller類中存在call方法的兩種重載，更復雜的是SubCaller集成Caller并且重寫了這兩個方法。其實這種情況是上面兩種情況的復合情況。
下面的代碼首先會發(fā)生靜態(tài)綁定，確定調(diào)用參數(shù)為String對象的call方法，然后在運行時進行動態(tài)綁定確定執(zhí)行子類還是父類的call實現(xiàn)。
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");
}
}
}
執(zhí)行結果為
22:30 $ java TestMain
a String instance in in SubCaller
驗證
由于上面已經(jīng)介紹，這里只貼一下反編譯結果啦
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
}
好奇問題
非動態(tài)綁定不可么？
其實理論上，某些方法的綁定也可以由靜態(tài)綁定實現(xiàn)。比如：
public static void main(String[] args) {
String str = new String();
final Caller callerSub = new SubCaller();
callerSub.call(str);
}
比如這里callerSub持有subCaller的對象并且callerSub變量為final，立即執(zhí)行了call方法，編譯器理論上通過足夠的分析代碼，是可以知道應該調(diào)用SubCaller的call方法。
但是為什么沒有進行靜態(tài)綁定呢？
假設我們的Caller繼承自某一個框架的BaseCaller類，其實現(xiàn)了call方法，而BaseCaller繼承自SuperCaller。SuperCaller中對call方法也進行了實現(xiàn)。
假設某框架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進行了這樣的實現(xiàn)。Caller繼承自BaseCaller，并且調(diào)用了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文件，假設靜態(tài)綁定可以確定上面Caller的super.call為BaseCaller.call實現(xiàn)。
然后我們再次假設這個框架1.1版本中BaseCaller不重寫SuperCaller的call方法，那么上面的假設可以靜態(tài)綁定的call實現(xiàn)在1.1版本就會出現(xiàn)問題，因為在1.1版本上super.call應該是使用SuperCall的call方法實現(xiàn)，而非假設使用靜態(tài)綁定確定的BaseCaller的call方法實現(xiàn)。
所以，有些實際可以靜態(tài)綁定的，考慮到安全和一致性，就索性都進行了動態(tài)綁定。
得到的優(yōu)化啟示？
由于動態(tài)綁定需要在運行時確定執(zhí)行哪個版本的方法實現(xiàn)或者變量，比起靜態(tài)綁定起來要耗時。
所以在不影響整體設計，我們可以考慮將方法或者變量使用private，static或者final進行修飾。
相關文章
spring boot+ redis 接口訪問頻率限制的實現(xiàn)
這篇文章主要介紹了spring boot+ redis 接口訪問頻率限制的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-01-01
這篇文章主要為大家詳細介紹了java實現(xiàn)推箱子小游戲，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-05-05
MyBatis-Plus中使用EntityWrappe進行列表數(shù)據(jù)倒序設置方式
這篇文章主要介紹了MyBatis-Plus中使用EntityWrappe進行列表數(shù)據(jù)倒序設置方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-03-03
這篇文章主要給大家介紹了關于Java中Object類的幾個方法的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2018-05-05
java循環(huán)刪除List元素報錯的原因分析與解決
大家在工作中應該都會遇到從List集合中刪除某一個或多個元素的業(yè)務場景,相信大家都會避開在循環(huán)里面刪除元素,使用其他方式處理,這是為什么呢,下面小編就來和大家詳細聊聊2023-11-11
解決Java的InputMismatchException異常
這篇文章介紹了解決Java的InputMismatchException異常的方法，文中通過示例代碼介紹的非常詳細。對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-12-12
springboot掃描引入jar包的service等組件方式
這篇文章主要介紹了springboot掃描引入jar包的service等組件方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-07-07
棧和隊列，嚴格意義上來說，也屬于線性表，因為它們也都用于存儲邏輯關系為 "一對一" 的數(shù)據(jù)，但由于它們比較特殊，因此將其單獨作為一章，做重點講解2022-02-02
這篇文章主要介紹了java遞歸算法實例分析，具有一定借鑒價值，需要的朋友可以參考下。2017-12-12
這篇文章主要介紹了詳解SpringBoot 添加對JSP的支持（附常見坑點），非常具有實用價值，需要的朋友可以參考下2017-10-10