一、前言

Java 從 7 版本到 17 版本，在語言和虛擬機層面不斷演進，其中一個重要的改進是針對巢狀類別 (nested classes) 的存取控制。在 Java 11 之前，巢狀類別的存取控制在某些情況下略顯不足，導致編譯器需要產生「橋接方法」（bridge methods）來允許內部類別存取外部類別的私有成員。Java 11 引入了「巢狀式存取控制」 (Nest-Based Access Control)，通過在類別檔案中引入 NestHost 和 NestMembers 屬性，提升了巢狀類別的存取效率和可維護性。這種改進簡化了虛擬機的行為，避免了編譯器合成橋接方法，使得程式碼更加清晰且執行效率更高。本文將深入探討 Java 7 至 17 關於巢狀存取控制的變化，分析其架構，工具與範例，並做出總結。

二、舊有巢狀類別存取機制的挑戰 (Java 11 之前)

返回目錄

在 Java 11 之前，巢狀類別（包括內部類別和靜態巢狀類別）存取外部類別的私有成員時，會遇到一些挑戰：

編譯器合成橋接方法: 當內部類別需要存取外部類別的私有成員時，編譯器會自動生成橋接方法 (bridge method) ，這些橋接方法實際上是包裝器，用於存取外部類別的私有成員。這些方法在類別檔案中是可見的，但它們並不是程式設計師直接寫的，因此會造成混亂和額外的運行時開銷。
存取效能較差: 由於需要經過橋接方法的中轉，巢狀類別存取外部類別私有成員的效率會相對較低。
類別檔案膨脹: 編譯器合成的橋接方法會增加類別檔案的大小，影響載入速度和記憶體使用。

以下範例說明了橋接方法的存在：

public class OuterClass {
    private int privateField = 10;

    public class InnerClass {
        public void accessOuterPrivateField() {
            System.out.println(privateField);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.accessOuterPrivateField();
    }
}

編譯 OuterClass.java 檔案，使用 Java 11 以前版本進行編譯：

$ /d/jdk/zulu8.46.0.19-ca-jdk8.0.252-win_x64/bin/javac.exe -encoding utf-8 OuterClass.java

在 Java 11 之前，上述程式碼會生成一個包含橋接方法的類別檔案 OuterClass$InnerClass.class 。可以使用 javap -p 工具查看編譯後的 bytecode。

$ /d/jdk/zulu8.46.0.19-ca-jdk8.0.252-win_x64/bin/javap.exe -v OuterClass\$InnerClass.class
Classfile /D:/Ethan/workspace/lab/example/text/java-newfeatures/src/OuterClass$InnerClass.class
  Last modified 2025/1/20; size 567 bytes
  MD5 checksum dc6b564ec623dfd8d92b68d922eb298e
  Compiled from "OuterClass.java"
public class OuterClass$InnerClass
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Fieldref           #6.#18         // OuterClass$InnerClass.this$0:LOuterClass;
   #2 = Methodref          #7.#19         // java/lang/Object."<init>":()V
   #3 = Fieldref           #20.#21        // java/lang/System.out:Ljava/io/PrintStream;
   #4 = Methodref          #22.#23        // OuterClass.access$000:(LOuterClass;)I
   #5 = Methodref          #24.#25        // java/io/PrintStream.println:(I)V
   #6 = Class              #26            // OuterClass$InnerClass
   #7 = Class              #29            // java/lang/Object
   #8 = Utf8               this$0
   #9 = Utf8               LOuterClass;
  #10 = Utf8               <init>
  #11 = Utf8               (LOuterClass;)V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               accessOuterPrivateField
  #15 = Utf8               ()V
  #16 = Utf8               SourceFile
  #17 = Utf8               OuterClass.java
  #18 = NameAndType        #8:#9          // this$0:LOuterClass;
  #19 = NameAndType        #10:#15        // "<init>":()V
  #20 = Class              #30            // java/lang/System
  #21 = NameAndType        #31:#32        // out:Ljava/io/PrintStream;
  #22 = Class              #33            // OuterClass
  #23 = NameAndType        #34:#35        // access$000:(LOuterClass;)I
  #24 = Class              #36            // java/io/PrintStream
  #25 = NameAndType        #37:#38        // println:(I)V
  #26 = Utf8               OuterClass$InnerClass
  #27 = Utf8               InnerClass
  #28 = Utf8               InnerClasses
  #29 = Utf8               java/lang/Object
  #30 = Utf8               java/lang/System
  #31 = Utf8               out
  #32 = Utf8               Ljava/io/PrintStream;
  #33 = Utf8               OuterClass
  #34 = Utf8               access$000
  #35 = Utf8               (LOuterClass;)I
  #36 = Utf8               java/io/PrintStream
  #37 = Utf8               println
  #38 = Utf8               (I)V
{
  final OuterClass this$0;
    descriptor: LOuterClass;
    flags: ACC_FINAL, ACC_SYNTHETIC

  public OuterClass$InnerClass(OuterClass);
    descriptor: (LOuterClass;)V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: aload_1
         2: putfield      #1                  // Field this$0:LOuterClass;
         5: aload_0
         6: invokespecial #2                  // Method java/lang/Object."<init>":()V
         9: return
      LineNumberTable:
        line 4: 0

  public void accessOuterPrivateField();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: aload_0
         4: getfield      #1                  // Field this$0:LOuterClass;
         7: invokestatic  #4                  // Method OuterClass.access$000:(LOuterClass;)I
        10: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        13: return
      LineNumberTable:
        line 6: 0
        line 7: 13
}
SourceFile: "OuterClass.java"
InnerClasses:
     public #27= #6 of #22; //InnerClass=class OuterClass$InnerClass of class OuterClass

橋接方法分析:

Constant pool 中的 #4 = Methodref #22.#23: 這個常數池項目表示 OuterClass$InnerClass 類別引用了 OuterClass.access$000:(LOuterClass;)I 這個方法。
accessOuterPrivateField() 方法中的 7: invokestatic #4: 在 accessOuterPrivateField() 方法的 bytecode 中，可以看到它使用 invokestatic 指令來呼叫 OuterClass.access$000 方法。
access$000 方法: 這個 access$000 方法是一個由編譯器自動生成的橋接方法，它存在於 OuterClass 中，目的是讓 InnerClass 可以存取 OuterClass 的私有成員 privateField。

小結

在 Java 11 之前，當內部類別 InnerClass 需要存取外部類別 OuterClass 的私有成員 privateField 時，編譯器會做以下事情：

自動在 OuterClass 中生成一個 access$000 的靜態方法。這個方法的簽名通常是 static int access$000(OuterClass outer)，它會存取 outer.privateField 並返回。
InnerClass 的 accessOuterPrivateField 方法會呼叫 OuterClass.access$000 來間接存取 privateField。

這個 access$000 方法就是橋接方法。它在程式碼中是不可見的，由編譯器自動生成，增加了類別檔案的大小和執行時的開銷。

三、巢狀存取控制 (Nest-Based Access Control) 的引入 (Java 11)

返回目錄

Java 11 引入了巢狀式存取控制，旨在解決舊有巢狀類別存取機制的問題。巢狀存取控制的核心概念是 巢 (nest) 。一個巢由一個外部類別 (nest host) 和所有在語法上屬於這個巢的類別 (nest members) 所組成。巢內的類別可以自然存取巢內其他類別的私有成員，無需橋接方法。

架構分析

返回目錄

NestHost 屬性: 在類別檔案中，每個巢成員都會有一個 NestHost 屬性，指向它的巢的主體。這個屬性明確標示了該類別屬於哪個巢。
NestMembers 屬性: 巢主體類別會有一個 NestMembers 屬性，列出屬於這個巢的所有成員類別。
存取規則: 屬於同一個巢的類別，彼此可以自由存取對方所有層次的成員，包括私有成員，無需產生橋接方法。

工具與實例

返回目錄

Java 11 及之後的版本，可以使用 javap -v 工具查看類別檔案的詳細資訊，包括 NestHost 和 NestMembers 屬性。

修改先前範例，使其符合巢狀存取控制的設計：

public class OuterClassAfter11 {
  private int privateField = 10;

  public class InnerClass {
    public void accessOuterPrivateField() {
      System.out.println(privateField);
    }
  }

  public static class StaticNested {
    public void accessOuterPrivateField(OuterClassAfter11 outer) {
      System.out.println(outer.privateField);
    }
  }

  public static void main(String[] args) {
    OuterClassAfter11 outer = new OuterClassAfter11();
    OuterClassAfter11.InnerClass inner = outer.new InnerClass();
    inner.accessOuterPrivateField();
    OuterClassAfter11.StaticNested staticNested = new StaticNested();
    staticNested.accessOuterPrivateField(outer);
  }
}

編譯 OuterClassAfter11.java 檔案：

$ javac -encoding utf-8 OuterClassAfter11.java

執行結果：

$ java OuterClassAfter11.java
10
10

觀察 OuterClassAfter11.class 檔案：

返回目錄

NestMembers 屬性:
- 從 javap -v OuterClassAfter11.class 的輸出中，我們看到 NestMembers: 屬性包含 OuterClassAfter11$StaticNested 和 OuterClassAfter11$InnerClass。這明確指出 OuterClassAfter11 是 Nest Host，而 StaticNested 和 InnerClass 都是這個 Nest 的成員。
InnerClasses 屬性:
- InnerClasses: 屬性列出所有內部類別，public #41= #14 of #8; // InnerClass=class OuterClassAfter11$InnerClass of class OuterClassAfter11 和 public static #42= #28 of #8; // StaticNested=class OuterClassAfter11$StaticNested of class OuterClassAfter11 確認了它們是 OuterClassAfter11 的內部類別。

$ javap -v OuterClassAfter11.class
Classfile /D:/Ethan/workspace/lab/example/text/java-newfeatures/src/OuterClassAfter11.class
  Last modified 2025年1月20日; size 730 bytes
  SHA-256 checksum fda0dbffcb4d714172e20c1dce54e80a9ebd13ff08e01b48ee3be130f100dbdd
  Compiled from "OuterClassAfter11.java"
public class OuterClassAfter11
  minor version: 0
  major version: 61
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #8                          // OuterClassAfter11
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 1, methods: 2, attributes: 3
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // OuterClassAfter11.privateField:I
   #8 = Class              #10            // OuterClassAfter11
   #9 = NameAndType        #11:#12        // privateField:I
  #10 = Utf8               OuterClassAfter11
  #11 = Utf8               privateField
  #12 = Utf8               I
  #13 = Methodref          #8.#3          // OuterClassAfter11."<init>":()V
  #14 = Class              #15            // OuterClassAfter11$InnerClass
  #15 = Utf8               OuterClassAfter11$InnerClass
  #16 = Methodref          #17.#18        // java/util/Objects.requireNonNull:(Ljava/lang/Object;)Ljava/lang/Object;
  #17 = Class              #19            // java/util/Objects
  #18 = NameAndType        #20:#21        // requireNonNull:(Ljava/lang/Object;)Ljava/lang/Object;
  #19 = Utf8               java/util/Objects
  #20 = Utf8               requireNonNull
  #21 = Utf8               (Ljava/lang/Object;)Ljava/lang/Object;
  #22 = Methodref          #14.#23        // OuterClassAfter11$InnerClass."<init>":(LOuterClassAfter11;)V
  #23 = NameAndType        #5:#24         // "<init>":(LOuterClassAfter11;)V
  #24 = Utf8               (LOuterClassAfter11;)V
  #25 = Methodref          #14.#26        // OuterClassAfter11$InnerClass.accessOuterPrivateField:()V
  #26 = NameAndType        #27:#6         // accessOuterPrivateField:()V
  #27 = Utf8               accessOuterPrivateField
  #28 = Class              #29            // OuterClassAfter11$StaticNested
  #29 = Utf8               OuterClassAfter11$StaticNested
  #30 = Methodref          #28.#3         // OuterClassAfter11$StaticNested."<init>":()V
  #31 = Methodref          #28.#32        // OuterClassAfter11$StaticNested.accessOuterPrivateField:(LOuterClassAfter11;)V
  #32 = NameAndType        #27:#24        // accessOuterPrivateField:(LOuterClassAfter11;)V
  #33 = Utf8               Code
  #34 = Utf8               LineNumberTable
  #35 = Utf8               main
  #36 = Utf8               ([Ljava/lang/String;)V
  #37 = Utf8               SourceFile
  #38 = Utf8               OuterClassAfter11.java
  #39 = Utf8               NestMembers
  #40 = Utf8               InnerClasses
  #41 = Utf8               InnerClass
  #42 = Utf8               StaticNested
{
  public OuterClassAfter11();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: bipush        10
         7: putfield      #7                  // Field privateField:I
        10: return
      LineNumberTable:
        line 1: 0
        line 2: 4

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=4, args_size=1
         0: new           #8                  // class OuterClassAfter11
         3: dup
         4: invokespecial #13                 // Method "<init>":()V
         7: astore_1
         8: new           #14                 // class OuterClassAfter11$InnerClass
        11: dup
        12: aload_1
        13: dup
        14: invokestatic  #16                 // Method java/util/Objects.requireNonNull:(Ljava/lang/Object;)Ljava/lang/Object;
        17: pop
        18: invokespecial #22                 // Method OuterClassAfter11$InnerClass."<init>":(LOuterClassAfter11;)V
        21: astore_2
        22: aload_2
        23: invokevirtual #25                 // Method OuterClassAfter11$InnerClass.accessOuterPrivateField:()V
        26: new           #28                 // class OuterClassAfter11$StaticNested
        29: dup
        30: invokespecial #30                 // Method OuterClassAfter11$StaticNested."<init>":()V
        33: astore_3
        34: aload_3
        35: aload_1
        36: invokevirtual #31                 // Method OuterClassAfter11$StaticNested.accessOuterPrivateField:(LOuterClassAfter11;)V
        39: return
      LineNumberTable:
        line 17: 0
        line 18: 8
        line 19: 22
        line 20: 26
        line 21: 34
        line 22: 39
}
SourceFile: "OuterClassAfter11.java"
NestMembers:
  OuterClassAfter11$StaticNested
  OuterClassAfter11$InnerClass
InnerClasses:
  public #41= #14 of #8;                  // InnerClass=class OuterClassAfter11$InnerClass of class OuterClassAfter11
  public static #42= #28 of #8;           // StaticNested=class OuterClassAfter11$StaticNested of class OuterClassAfter11

觀察 OuterClassAfter11$InnerClass.class 檔案：

返回目錄

NestHost 屬性:
- 在 javap -v OuterClassAfter11$InnerClass.class 的輸出中，我們看到 NestHost: class OuterClassAfter11。這表示 InnerClass 的 Nest Host 是 OuterClassAfter11，也驗證了它是 OuterClassAfter11 Nest 的成員。

$ javap -v OuterClassAfter11\$InnerClass.class
Classfile /D:/Ethan/workspace/lab/example/text/java-newfeatures/src/OuterClassAfter11$InnerClass.class
  Last modified 2025年1月20日; size 609 bytes
  SHA-256 checksum 0157ba0bc92487c059993cd4c308a362d69423c47cf6c888c1411d307ff3229f
  Compiled from "OuterClassAfter11.java"
public class OuterClassAfter11$InnerClass
  minor version: 0
  major version: 61
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #2                          // OuterClassAfter11$InnerClass
  super_class: #8                         // java/lang/Object
  interfaces: 0, fields: 1, methods: 2, attributes: 3
Constant pool:
   #1 = Fieldref           #2.#3          // OuterClassAfter11$InnerClass.this$0:LOuterClassAfter11;
   #2 = Class              #4             // OuterClassAfter11$InnerClass
   #3 = NameAndType        #5:#6          // this$0:LOuterClassAfter11;
   #4 = Utf8               OuterClassAfter11$InnerClass
   #5 = Utf8               this$0
   #6 = Utf8               LOuterClassAfter11;
   #7 = Methodref          #8.#9          // java/lang/Object."<init>":()V
   #8 = Class              #10            // java/lang/Object
   #9 = NameAndType        #11:#12        // "<init>":()V
  #10 = Utf8               java/lang/Object
  #11 = Utf8               <init>
  #12 = Utf8               ()V
  #13 = Fieldref           #14.#15        // java/lang/System.out:Ljava/io/PrintStream;
  #14 = Class              #16            // java/lang/System
  #15 = NameAndType        #17:#18        // out:Ljava/io/PrintStream;
  #16 = Utf8               java/lang/System
  #17 = Utf8               out
  #18 = Utf8               Ljava/io/PrintStream;
  #19 = Fieldref           #20.#21        // OuterClassAfter11.privateField:I
  #20 = Class              #22            // OuterClassAfter11
  #21 = NameAndType        #23:#24        // privateField:I
  #22 = Utf8               OuterClassAfter11
  #23 = Utf8               privateField
  #24 = Utf8               I
  #25 = Methodref          #26.#27        // java/io/PrintStream.println:(I)V
  #26 = Class              #28            // java/io/PrintStream
  #27 = NameAndType        #29:#30        // println:(I)V
  #28 = Utf8               java/io/PrintStream
  #29 = Utf8               println
  #30 = Utf8               (I)V
  #31 = Utf8               (LOuterClassAfter11;)V
  #32 = Utf8               Code
  #33 = Utf8               LineNumberTable
  #34 = Utf8               accessOuterPrivateField
  #35 = Utf8               SourceFile
  #36 = Utf8               OuterClassAfter11.java
  #37 = Utf8               NestHost
  #38 = Utf8               InnerClasses
  #39 = Utf8               InnerClass
{
  final OuterClassAfter11 this$0;
    descriptor: LOuterClassAfter11;
    flags: (0x1010) ACC_FINAL, ACC_SYNTHETIC

  public OuterClassAfter11$InnerClass(OuterClassAfter11);
    descriptor: (LOuterClassAfter11;)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: aload_1
         2: putfield      #1                  // Field this$0:LOuterClassAfter11;
         5: aload_0
         6: invokespecial #7                  // Method java/lang/Object."<init>":()V
         9: return
      LineNumberTable:
        line 4: 0

  public void accessOuterPrivateField();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: aload_0
         4: getfield      #1                  // Field this$0:LOuterClassAfter11;
         7: getfield      #19                 // Field OuterClassAfter11.privateField:I
        10: invokevirtual #25                 // Method java/io/PrintStream.println:(I)V
        13: return
      LineNumberTable:
        line 6: 0
        line 7: 13
}
SourceFile: "OuterClassAfter11.java"
NestHost: class OuterClassAfter11
InnerClasses:
  public #39= #2 of #20;                  // InnerClass=class OuterClassAfter11$InnerClass of class OuterClassAfter11

無橋接方法分析:

Constant pool 中直接引用 #19 = Fieldref #20.#21 : InnerClass 的常數池直接包含了對 OuterClassAfter11.privateField 的引用。
accessOuterPrivateField() 方法中的 7: getfield #19 : 在 accessOuterPrivateField() 方法中，InnerClass 直接使用 getfield 指令來存取外部類別 OuterClassAfter11 的 privateField，而沒有呼叫任何橋接方法。

觀察 OuterClassAfter11$StaticNested.class 檔案：

返回目錄

NestHost 屬性:
- 在 javap -v OuterClassAfter11$StaticNested.class 的輸出中，我們看到 NestHost: class OuterClassAfter11。這表示 StaticNested 的 Nest Host 是 OuterClassAfter11，也驗證了它是 OuterClassAfter11 Nest 的成員。

$ javap -v OuterClassAfter11\$StaticNested.class
Classfile /D:/Ethan/workspace/lab/example/text/java-newfeatures/src/OuterClassAfter11$StaticNested.class
  Last modified 2025年1月20日; size 556 bytes
  SHA-256 checksum f1a06b849b734cef7ba2c2196188fc2ee820022fc1ecf0161b1bdad74e4ff39a
  Compiled from "OuterClassAfter11.java"
public class OuterClassAfter11$StaticNested
  minor version: 0
  major version: 61
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #25                         // OuterClassAfter11$StaticNested
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 3
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // java/lang/System.out:Ljava/io/PrintStream;
   #8 = Class              #10            // java/lang/System
   #9 = NameAndType        #11:#12        // out:Ljava/io/PrintStream;
  #10 = Utf8               java/lang/System
  #11 = Utf8               out
  #12 = Utf8               Ljava/io/PrintStream;
  #13 = Fieldref           #14.#15        // OuterClassAfter11.privateField:I
  #14 = Class              #16            // OuterClassAfter11
  #15 = NameAndType        #17:#18        // privateField:I
  #16 = Utf8               OuterClassAfter11
  #17 = Utf8               privateField
  #18 = Utf8               I
  #19 = Methodref          #20.#21        // java/io/PrintStream.println:(I)V
  #20 = Class              #22            // java/io/PrintStream
  #21 = NameAndType        #23:#24        // println:(I)V
  #22 = Utf8               java/io/PrintStream
  #23 = Utf8               println
  #24 = Utf8               (I)V
  #25 = Class              #26            // OuterClassAfter11$StaticNested
  #26 = Utf8               OuterClassAfter11$StaticNested
  #27 = Utf8               Code
  #28 = Utf8               LineNumberTable
  #29 = Utf8               accessOuterPrivateField
  #30 = Utf8               (LOuterClassAfter11;)V
  #31 = Utf8               SourceFile
  #32 = Utf8               OuterClassAfter11.java
  #33 = Utf8               NestHost
  #34 = Utf8               InnerClasses
  #35 = Utf8               StaticNested
{
  public OuterClassAfter11$StaticNested();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 10: 0

  public void accessOuterPrivateField(OuterClassAfter11);
    descriptor: (LOuterClassAfter11;)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: aload_1
         4: getfield      #13                 // Field OuterClassAfter11.privateField:I
         7: invokevirtual #19                 // Method java/io/PrintStream.println:(I)V
        10: return
      LineNumberTable:
        line 12: 0
        line 13: 10
}
SourceFile: "OuterClassAfter11.java"
NestHost: class OuterClassAfter11
InnerClasses:
  public static #35= #25 of #14;          // StaticNested=class OuterClassAfter11$StaticNested of class OuterClassAfter11

無橋接方法分析:

Constant pool 中直接引用 #13 = Fieldref #14.#15 : StaticNested 的常數池直接包含了對 OuterClassAfter11.privateField:I 的引用。
accessOuterPrivateField() 方法中的 4: getfield #13 : 在 accessOuterPrivateField() 方法中， StaticNested 直接使用 getfield 指令來存取外部類別 OuterClassAfter11 的 privateField，而沒有呼叫任何橋接方法。

Nest:

返回目錄

靜態巢狀類別 (StaticNested) 的 Nest 成員身份：即使 StaticNested 是靜態的，它依然屬於 OuterClassAfter11 的 Nest。這與傳統的 Java 內部類別概念稍有不同，因為過去靜態巢狀類別通常不被視為外部類別的「一部分」。
存取控制： Nest 關係讓內部類別可以更自然地存取外部類別的私有成員，而無需編譯器生成額外的橋接方法，提升了程式碼的效率和可讀性。
this$0 欄位： InnerClass 有一個 final OuterClassAfter11 this$0 欄位，這是一個隱式的外部類別實例的引用，用於存取外部類別的成員。在巢狀存取控制中，這個引用仍然存在，但存取私有成員不再需要橋接方法。
requireNonNull 方法：在 main 方法中， java/util/Objects.requireNonNull 方法被用來檢測 OuterClassAfter11 的實例是否為空，確保在使用前是有效的物件。

小結

在 Java 11 及以後，由於 Nest 的概念，編譯器不再需要生成橋接方法：

OuterClassAfter11 和 OuterClassAfter11$InnerClass、OuterClassAfter11$StaticClass 被視為同一個 Nest 的成員。
InnerClass 和 StaticClass 可以直接存取 OuterClassAfter11 的私有成員 privateField。
因此，編譯器不再需要自動生成 access$000 這種橋接方法，程式碼更加精簡，執行效率也更高。

四、Java 12 至 17 的相關演進

返回目錄

Java 11 引入巢狀存取控制之後，後續版本並沒有對此特性進行重大修改，這體現了該機制的成熟和穩定性。Java 12 至 17 延續了這一機制，確保了程式碼的穩定性和高效性。這些版本主要關注在其他方面的語言特性和效能優化，而巢狀存取控制已經相對完善。具體來說：

持續穩定性: 雖然 Java 12 至 17 沒有針對巢狀存取控制引入重大變更，但這些版本在 JVM 層面持續優化，確保了 Nest-Based Access Control 的穩定性和效能。
與其他特性的互動: Nest-Based Access Control 是一個底層機制，它與 Java 後續版本中引入的其他語言特性 (如 Record、Sealed Class) 相容良好。開發者可以安全地在這些新特性中使用巢狀類別，享受 Nest 帶來的好處。
工具改進: javap 工具在 Java 12 以後的版本中，對 Nest 相關資訊的輸出更加完整和易讀，方便開發者分析類別檔案。
效能提升: 後續版本對 JVM 的不斷優化，間接提升了使用巢狀存取控制的程式碼的執行效能。例如，JIT 編譯器可以更好地優化使用 Nest 的程式碼。
版本兼容性: 确保 Java 11 及之后編譯的代碼，在不同版本的 JVM 上運行都具有良好的兼容性，無需額外處理。
沒有新屬性: Java 12 至 17 没有引入新的類別文件屬性來擴展巢狀存取控制，說明 Java 11 引入的機制已经足够完整且满足需求。

總結來說，Java 12 至 17 的演進，主要是對 Java 11 引入的巢狀存取控制機制的穩定性和效能做進一步的保證，並將其融入到後續版本的新特性中。

五、總結

返回目錄

Java 11 引入的巢狀存取控制 (Nest-Based Access Control) 是一項重要的改進，解決了舊有巢狀類別存取機制中的問題，帶來了以下優點：

消除橋接方法: 編譯器不再需要生成橋接方法，程式碼更加清晰易懂，類別檔案也更加簡潔。這不僅減少了類別檔案的大小，也減少了開發者在除錯時的困擾。
提升存取效能: 巢狀類別可以直接存取外部類別的私有成員，無需經過中轉，提高了運行效率。在效能敏感的程式碼中，這種優化尤為重要。
簡化虛擬機行為: 虛擬機的載入和執行流程得到簡化，提高了效率和可維護性。
更自然的存取模型: 讓內部類別和外部類別的關係更加緊密，符合程式開發者的直覺。
促進設計模式: 巢狀類別常常用於實現特定設計模式，Nest-Based Access Control 使得這些模式的實現更加有效率。
對微服務架構的影響: 雖然 Nest 主要是語言層面的機制，但其在微服務架構中也有應用，例如，服務內的私有類別之間的存取更加高效。
鼓勵程式碼模組化: 鼓勵開發者合理使用巢狀類別，提高程式碼的模組化和可維護性。
現代Java開發的必要知識: 理解 Nest-Based Access Control 是現代 Java 開發者的基本要求，有助於編寫更高效、更可靠的程式碼。
除錯優化: javap 工具不僅是分析工具，更是除錯與效能調優的利器，透過觀察 bytecode 可以更深入理解程式碼的行為。

從 Java 11 開始，巢狀存取控制機制在 Java 語言中成為標準，並且在 Java 12 至 17 中持續得到應用，這證明了這項改進的價值和重要性。開發者應當理解巢狀存取控制的原理，以撰寫更高效、更易於維護的 Java 程式碼。

此外，使用 javap 工具檢視 bytecode 文件，能夠幫助我們更深入地理解底層實現，對於除錯或優化程式碼都有很大的幫助。

返回目錄

網頁

2025年1月22日星期三

Java 7 to 17 Nest-Based Access Control

一、前言

目錄

二、舊有巢狀類別存取機制的挑戰 (Java 11 之前)

三、巢狀存取控制 (Nest-Based Access Control) 的引入 (Java 11)

架構分析

工具與實例

觀察 OuterClassAfter11.class 檔案：

觀察 OuterClassAfter11$InnerClass.class 檔案：

觀察 OuterClassAfter11$StaticNested.class 檔案：

Nest:

四、Java 12 至 17 的相關演進

五、總結

沒有留言:

張貼留言

網頁

2025年1月22日 星期三

Java 7 to 17 Nest-Based Access Control

一、前言

目錄

二、舊有巢狀類別存取機制的挑戰 (Java 11 之前)

三、巢狀存取控制 (Nest-Based Access Control) 的引入 (Java 11)

架構分析

工具與實例

觀察 OuterClassAfter11.class 檔案：

觀察 OuterClassAfter11$InnerClass.class 檔案：

觀察 OuterClassAfter11$StaticNested.class 檔案：

Nest:

四、Java 12 至 17 的相關演進

五、總結

沒有留言:

張貼留言

2025年1月22日星期三