Java 內部類全景解析：成員/靜態/局部/匿名四大類型、訪問規則、字節碼實現與工程應用

前言

內部類是 Java 語法糖的集中體現，編譯器通過生成隱式構造器、外部類引用字段、訪問權限橋接方法，實現內部類對外部成員的無縫訪問。掌握四大類型的語義邊界、捕獲語義、序列化陷阱、Lambda 替代關係，能幫你寫出更簡潔、封裝性更強的代碼。本文從語法、字節碼、最佳實踐三個維度徹底講透。

一、四大類型語法與語義對比

二、字節碼級實現機制

1. 成員內部類

// 源碼
class Outer {
    private int outerField = 1;
    class Inner {
        void access() { System.out.println(outerField); }
    }
}

// 編譯器生成 (反編譯)
class Outer$Inner {
    final Outer this$0; // 隱式引用
    Outer$Inner(Outer this$0) { this.this$0 = this$0; }
    void access() { System.out.println(this$0.outerField); }
    // 若訪問 private，編譯器在 Outer 生成靜態橋接方法：
    // static int access$000(Outer o) { return o.outerField; }
}

2. 局部/匿名類捕獲 final 變量

void method(final int param, int local) {
    local = 2; // 非 final，不可捕獲
    Runnable r = () -> System.out.println(param); // param 隱式 final
    // 等價匿名類生成：
    // class Outer$1 implements Runnable {
    //     final int val$param; // 複製值
    //     Outer$1(int param) { this.val$param = param; }
    //     public void run() { System.out.println(val$param); }
    // }
}

本質：值複製。Java 8+ 允許「實際最終」變量（不重新賦值），編譯器自動視為 final。

三、代碼示例全集

1. 成員內部類 + 外部類引用語法

public class MemberInnerDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.callInner(); // 通過外部實例創建內部實例

        // 外部類靜態方法中創建：需先有外部實例
        Outer.Inner inner = new Outer().new Inner();
        inner.innerMethod();
    }
}

class Outer {
    private String name = "Outer";
    class Inner {
        private String name = "Inner";
        void innerMethod() {
            System.out.println(this.name);        // Inner
            System.out.println(Outer.this.name);  // Outer
        }
    }
    void callInner() { new Inner().innerMethod(); }
}

2. 靜態嵌套類：不依賴外部實例

public class StaticNestedDemo {
    public static void main(String[] args) {
        // 無需 Outer 實例
        Outer.Nested nested = new Outer.Nested();
        nested.print(); // 只能訪問 Outer 靜態成員
    }
}

class Outer {
    private static String staticField = "Static";
    private String instanceField = "Instance"; // 編譯錯誤若訪問

    static class Nested {
        void print() { System.out.println(staticField); }
    }
}

3. 局部內部類：方法作用域封裝

public class LocalInnerDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.process(42);
    }
}

class Outer {
    private int base = 10;
    void process(final int param) { // param 必須 final 或 effectively final
        int local = 100; // effectively final
        class Local {
            void compute() {
                System.out.println(base + param + local); // 152
            }
        }
        new Local().compute();
    }
}

4. 匿名內部類：就地實現接口/繼承類

public class AnonymousDemo {
    public static void main(String[] args) {
        // 實現接口
        Runnable r = new Runnable() {
            @Override public void run() { System.out.println("匿名 Runnable"); }
        };
        r.run();

        // 繼承抽象類
        AbstractWorker worker = new AbstractWorker() {
            @Override void execute() { System.out.println("匿名 Worker"); }
        };
        worker.execute();

        // 帶構造器參數（僅繼承類可用）
        Thread t = new Thread("Anonymous-Thread") {
            @Override public void run() { System.out.println(getName() + " running"); }
        };
        t.start();
    }
}

abstract class AbstractWorker { abstract void execute(); }

四、工程陷阱與最佳實踐

五、Lambda 與內部類的關係

• Lambda 表達式是函數式接口（單抽象方法）的匿名實例，編譯為 invokedynamic 指令，運行時生成類，無 this$0 引用，不捕獲外部實例，內存更輕量。
• Runnable r = () -> {}; vs new Runnable() {}：前者無外部引用，後者隱式持有 Outer.this。
• 方法引用 obj::method 同理。

六、總結

• 成員內部類：需外部實例，共享外部狀態，慎用於長生命週期對象。
• 靜態嵌套類：獨立於外部實例，首選用於輔助類、Builder、DTO。
• 局部內部類：方法級封裝，捕獲 final 變量，罕見但強大。
• 匿名內部類：就地實現，配合 Lambda 使用，注意內存洩漏與序列化。
• 原則：能靜態就靜態、能 Lambda 就 Lambda、能提取具名類就提取，保持代碼清晰、無隱式持有風險。