久久国产成人av_抖音国产毛片_a片网站免费观看_A片无码播放手机在线观看,色五月在线观看,亚洲精品m在线观看,女人自慰的免费网址,悠悠在线观看精品视频,一级日本片免费的,亚洲精品久,国产精品成人久久久久久久

搜索
分享

Java中的靜態(tài)綁定和動態(tài)綁定

 臭小子的共享 2015-04-05

一個Java程序的執(zhí)行要經(jīng)過編譯和執(zhí)行（解釋）這兩個步驟,，同時Java又是面向?qū)ο蟮木幊陶Z言,。當(dāng)子類和父類存在同一個方法,，子類重寫了父類的方法,，程序在運行時調(diào)用方法是調(diào)用父類的方法還是子類的重寫方法呢，這應(yīng)該是我們在初學(xué)Java時遇到的問題,。這里首先我們將確定這種調(diào)用何種方法實現(xiàn)或者變量的操作叫做綁定,。

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

區(qū)別對比

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

重載方法的示例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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í)行的結(jié)果為

1
2

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ā)編譯一下即可驗證,。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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方法。

重寫方法的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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í)行的結(jié)果為

1
2

22:27 $ java TestMain
a String instance in SubCaller

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

驗證

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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
}

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

當(dāng)重載遇上重寫

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

下面的代碼首先會發(fā)生靜態(tài)綁定,，確定調(diào)用參數(shù)為String對象的call方法,，然后在運行時進行動態(tài)綁定確定執(zhí)行子類還是父類的call實現(xiàn)。

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

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í)行結(jié)果為

1
2

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

驗證

由于上面已經(jīng)介紹,，這里只貼一下反編譯結(jié)果啦

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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),。比如

1
2
3
4
5

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

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

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

假設(shè)某框架1.0中的BaseCaller和SuperCaller

1
2
3
4
5
6
7
8
9
10
11

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方法,。

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

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文件,，假設(shè)靜態(tài)綁定可以確定上面Caller的super.call為BaseCaller.call實現(xiàn),。

然后我們再次假設(shè)這個框架1.1版本中BaseCaller不重寫SuperCaller的call方法，那么上面的假設(shè)可以靜態(tài)綁定的call實現(xiàn)在1.1版本就會出現(xiàn)問題,，因為在1.1版本上super.call應(yīng)該是使用SuperCall的call方法實現(xiàn),，而非假設(shè)使用靜態(tài)綁定確定的BaseCaller的call方法實現(xiàn)。

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

得到的優(yōu)化啟示,？

由于動態(tài)綁定需要在運行時確定執(zhí)行哪個版本的方法實現(xiàn)或者變量，比起靜態(tài)綁定起來要耗時,。

所以在不影響整體設(shè)計，我們可以考慮將方法或者變量使用private,，static或者final進行修飾,。

參考文章

一本書

  • Java核心技術(shù)，Java領(lǐng)域最有影響力和價值的著作之一,，擁有20多年教學(xué)與研究經(jīng)驗的資深Java技術(shù)專家撰寫（獲Jolt大獎）,，與《Java編程思想》齊名，10余年全球暢銷不衰,，廣受好評,。

    本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布,，不代表本站觀點,。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息,，謹(jǐn)防詐騙,。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點擊一鍵舉報,。
    轉(zhuǎn)藏 分享 獻花（0）

    0條評論

    發(fā)表

    請遵守用戶 評論公約

    類似文章 更多