成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

從Java靜態綁定和動態綁定中得到優化啟示

作者：Androidyue
開發 后端
一個Java程序的執行要經過編譯和執行（解釋）這兩個步驟，同時Java又是面向對象的編程語言。當子類和父類存在同一個方法，子類重寫了父類的方法，程序在運行時調用方法是調用父類的方法還是子類的重寫方法呢，這應該是我們在初學Java時遇到的問題。這里首先我們將確定這種調用何種方法實現或者變量的操作叫做綁定。

一個Java程序的執行要經過編譯和執行（解釋）這兩個步驟，同時Java又是面向對象的編程語言。當子類和父類存在同一個方法，子類重寫了父類的方法，程序在運行時調用方法是調用父類的方法還是子類的重寫方法呢，這應該是我們在初學Java時遇到的問題。這里首先我們將確定這種調用何種方法實現或者變量的操作叫做綁定。

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

區別對比

  • 靜態綁定發生在編譯時期，動態綁定發生在運行時
  • 使用private或static或final修飾的變量或者方法，使用靜態綁定。而虛方法（可以被子類重寫的方法）則會根據運行時的對象進行動態綁定。
  • 靜態綁定使用類信息來完成，而動態綁定則需要使用對象信息來完成。
  • 重載(Overload)的方法使用靜態綁定完成，而重寫(Override)的方法則使用動態綁定完成。

重載方法的示例

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

  1. public class TestMain { 
  2.   public static void main(String[] args) { 
  3.       String str = new String(); 
  4.       Caller caller = new Caller(); 
  5.       caller.call(str); 
  6.   } 
  7.  
  8.   static class Caller { 
  9.       public void call(Object obj) { 
  10.           System.out.println("an Object instance in Caller"); 
  11.       } 
  12.        
  13.       public void call(String str) { 
  14.           System.out.println("a String instance in in Caller"); 
  15.       } 
  16.   } 
  17. } 

執行的結果為

  1. 22:19 $ java TestMain 
  2. a String instance in in Caller 

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

驗證

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

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

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

重寫方法的示例

  1. public class TestMain { 
  2.   public static void main(String[] args) { 
  3.       String str = new String(); 
  4.       Caller caller = new SubCaller(); 
  5.       caller.call(str); 
  6.   } 
  7.    
  8.   static class Caller { 
  9.       public void call(String str) { 
  10.           System.out.println("a String instance in Caller"); 
  11.       } 
  12.   } 
  13.    
  14.   static class SubCaller extends Caller { 
  15.       @Override 
  16.       public void call(String str) { 
  17.           System.out.println("a String instance in SubCaller"); 
  18.       } 
  19.   } 
  20. } 

執行的結果為

  1. 22:27 $ java TestMain 
  2. a String instance in SubCaller 

上面的代碼，Caller中有一個call方法的實現，SubCaller繼承Caller，并且重寫了call方法的實現。我們聲明了一個Caller類型的變量callerSub，但是這個變量指向的時一個SubCaller的對象。根據結果可以看出，其調用了SubCaller的call方法實現，而非Caller的call方法。這一結果的產生的原因是因為在運行時發生了動態綁定，在綁定過程中需要確定調用哪個版本的call方法實現。

驗證

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

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

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

當重載遇上重寫

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

下面的代碼首先會發生靜態綁定，確定調用參數為String對象的call方法，然后在運行時進行動態綁定確定執行子類還是父類的call實現。

  1. public class TestMain { 
  2.   public static void main(String[] args) { 
  3.       String str = new String(); 
  4.       Caller callerSub = new SubCaller(); 
  5.       callerSub.call(str); 
  6.   } 
  7.    
  8.   static class Caller { 
  9.       public void call(Object obj) { 
  10.           System.out.println("an Object instance in Caller"); 
  11.       } 
  12.        
  13.       public void call(String str) { 
  14.           System.out.println("a String instance in in Caller"); 
  15.       } 
  16.   } 
  17.    
  18.   static class SubCaller extends Caller { 
  19.       @Override 
  20.       public void call(Object obj) { 
  21.           System.out.println("an Object instance in SubCaller"); 
  22.       } 
  23.        
  24.       @Override 
  25.       public void call(String str) { 
  26.           System.out.println("a String instance in in SubCaller"); 
  27.       } 
  28.   } 
  29. } 

執行結果為

  1. 22:30 $ java TestMain 
  2. a String instance in in SubCaller 

驗證

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

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

好奇問題

非動態綁定不可么？

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

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

比如這里callerSub持有subCaller的對象并且callerSub變量為final，立即執行了call方法，編譯器理論上通過足夠的分析代碼，是可以知道應該調用SubCaller的call方法。

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

假設某框架1.0中的BaseCaller和SuperCaller

  1. static class SuperCaller { 
  2.   public void call(Object obj) { 
  3.       System.out.println("an Object instance in SuperCaller"); 
  4.   } 
  5. } 
  6.    
  7. static class BaseCaller extends SuperCaller { 
  8.   public void call(Object obj) { 
  9.       System.out.println("an Object instance in BaseCaller"); 
  10.   } 
  11. } 

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

  1. public class TestMain { 
  2.   public static void main(String[] args) { 
  3.       Object obj = new Object(); 
  4.       SuperCaller callerSub = new SubCaller(); 
  5.       callerSub.call(obj); 
  6.   } 
  7.    
  8.   static class Caller extends BaseCaller{ 
  9.       public void call(Object obj) { 
  10.           System.out.println("an Object instance in Caller"); 
  11.           super.call(obj); 
  12.       } 
  13.        
  14.       public void call(String str) { 
  15.           System.out.println("a String instance in in Caller"); 
  16.       } 
  17.   } 
  18.    
  19.   static class SubCaller extends Caller { 
  20.       @Override 
  21.       public void call(Object obj) { 
  22.           System.out.println("an Object instance in SubCaller"); 
  23.       } 
  24.        
  25.       @Override 
  26.       public void call(String str) { 
  27.           System.out.println("a String instance in in SubCaller"); 
  28.       } 
  29.   } 
  30. } 

然后我們基于這個框架的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核心技術，Java領域最有影響力和價值的著作之一，擁有20多年教學與研究經驗的資深Java技術專家撰寫（獲Jolt大獎），與《Java編程思想》齊名，10余年全球暢銷不衰，廣受好評。

責任編輯：張偉 來源： 技術小黑屋
Java
相關推薦

2012-01-09 11:26:15

Java

2009-07-22 08:52:05

Scala動態綁定

2011-08-22 09:34:50

Objective-C多態動態類型

2016-12-14 14:29:30

Java動態綁定機制

2014-04-02 09:21:52

2013-08-19 14:27:49

2011-12-30 09:40:28

2016-09-27 16:26:58

2022-02-18 08:28:49

域名公網IP

2017-08-07 16:39:03

JSX動態數據

2016-10-11 20:33:17

JavaScriptThisWeb

2010-07-30 10:45:08

Flex數據綁定

2022-01-18 10:39:29

自動駕駛數據人工智能

2021-12-12 20:10:49

域名動態IP

2011-03-30 09:13:13

靜態類Windows Pho

2023-10-07 11:04:58

WPF數據UI

2011-07-27 08:56:32

Oracle數據庫綁定變量軟解析

2023-10-20 09:51:00

編程開發

2021-07-06 06:39:22

Java靜態代理動態代理

2009-06-18 14:40:44

TreeView動態綁
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 狠狠亚洲 | 日韩欧美在线一区 | 亚洲不卡在线观看 | 久久精品久久精品 | 99在线精品视频 | 国内精品免费久久久久软件老师 | 亚洲狠狠爱 | 国产免费xxx | 91久久久www播放日本观看 | 一区二区在线不卡 | 国产欧美一级二级三级在线视频 | 国产日韩欧美 | 视频三区| 91久久爽久久爽爽久久片 | 亚洲美女网站 | 国产成人精品一区二区三区 | 在线看日韩av | 成人水多啪啪片 | 日韩久久久久久 | 日韩无 | 天天影视亚洲综合网 | 亚洲一区二区三区桃乃木香奈 | 久久久久久久久淑女av国产精品 | 一区二区久久精品 | 天天干天天爱天天 | 午夜影视| 亚洲一区二区三区久久 | 一级毛片在线视频 | www国产成人免费观看视频,深夜成人网 | 超碰在线影院 | 宅男伊人| 产真a观专区 | 日韩免费1区二区电影 | 国产真实乱对白精彩久久小说 | 久久国产精品72免费观看 | 精久久久 | 精品亚洲一区二区三区四区五区 | 欧美日一区二区 | 久草.com | 中文字幕加勒比 | 天堂网av在线 |