Java 匿名內部類完整指南：語法、原理、捕獲變量規則與現代替代方案

前言：什麼是匿名內部類？

匿名內部類 是「沒有名字的內部類」。它同時完成定義類與創建實例兩個動作，且只能使用一次。主要用於：

• 實現介面/抽象類的單次實現（如事件監聽器、比較器、Runnable）。
• 就地覆寫部分方法（模板方法模式的具體實現）。
• 簡化代碼結構，避免為一次性使用創建獨立類文件。

前提條件：必須繼承一個父類或實現一個介面（不能獨立存在）。

一、從「顯式類」到「匿名類」的演進

1. 傳統方式：獨立子類

abstract class Person {
    public abstract void eat();
}

class Child extends Person {
    @Override public void eat() {
        System.out.println("eat something");
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Child(); // 向上轉型
        p.eat();
    }
}

缺點：Child 類污染命名空間、文件分散、僅用一次卻佔用一個 .class 文件。

2. 匿名內部類改寫

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() { // ① new 父類/介面
            @Override             // ② 大括號內是類體
            public void eat() {
                System.out.println("eat something");
            }
        }; // ③ 分號結束語句
        p.eat();
    }
}

語法結構：new 父類型/介面類型() { 類體 }。編譯器自動生成 Demo$1.class。

3. 實現介面的匿名類

interface Person { void eat(); }

Person p = new Person() {
    @Override public void eat() { System.out.println("eat something"); }
};

介面無構造器，new Person() 實為「實現介面的匿名類實例化」。

二、經典應用場景：多線程創建

1. 繼承 Thread

Thread t = new Thread() {
    @Override public void run() {
        for (int i = 1; i <= 5; i++) System.out.print(i + " ");
    }
};
t.start(); // 輸出: 1 2 3 4 5

2. 實現 Runnable（推薦，支援線程池）

Runnable r = new Runnable() {
    @Override public void run() {
        for (int i = 1; i <= 5; i++) System.out.print(i + " ");
    }
};
new Thread(r).start();

三、核心難點：外部局部變量捕獲規則

1. Java 7 規則：必須是 final

public void startTask(final String config) { // 參數加 final
    new Thread() {
        public void run() {
            System.out.println("Config: " + config); // 捕獲 config
        }
    }.start();
}

局部變量同理：

void demo() {
    final int count = 10; // 必須 final
    Runnable r = new Runnable() {
        public void run() {
            System.out.println(count); // 捕獲
        }
    };
}

2. Java 8+ 規則：Effectively Final（實際上 final）

void demo() {
    int count = 10; // 無需寫 final，但不能再賦值
    // count = 20; // 取消註釋 → 編譯錯誤：Variable used in lambda expression should be final or effectively final
    
    Runnable r = () -> System.out.println(count); // Lambda 同樣受限
}

本質： 匿名類/Lambda 捕獲的是變量的值副本（基本類型）或引用副本（引用類型）。若外部變量後續修改，內部副本不同步，會導致語義混亂。編譯器強制「不再賦值」保證副本與原始值一致。

3. 繞過限制的技巧（不推薦常規使用）

// 使用單元素陣列/容器包裝
void demo() {
    final int[] counter = {0}; // 陣列引用 final，內容可變
    Runnable r = new Runnable() {
        public void run() {
            System.out.println(++counter[0]); // 修改陣列元素
        }
    };
}

// 使用 AtomicInteger 等線程安全容器
AtomicInteger counter = new AtomicInteger(0);
Runnable r = () -> System.out.println(counter.incrementAndGet());

四、匿名類 vs Lambda 表達式（Java 8+）

遷移示例：

// 匿名類
Comparator cmp = new Comparator() {
    @Override public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

// Lambda (Java 8+)
Comparator cmp = (a, b) -> a.length() - b.length();
// 或方法引用
Comparator cmp = Comparator.comparingInt(String::length);

五、編譯器生成的字節碼結構

// Demo.java
public class Demo {
    public void test() {
        Runnable r = new Runnable() {
            public void run() { System.out.println("hello"); }
        };
    }
}

// 編譯產物
Demo.class
Demo$1.class  // 匿名類：final class Demo$1 implements Runnable
// 字段：final Demo this$0; // 持有外部類引用
// 構造器：Demo$1(Demo outer) { this$0 = outer; }
// 方法：run() { System.out.println("hello"); }

若匿名類訪問外部 final 變量，構造器會新增對應字段並複製值：

// 捕獲 final String config
Demo$1(Demo outer, String config) { 
    this$0 = outer; 
    this.config = config; // 額外字段
}

六、常見坑與最佳實踐

七、現代化替代方案總結

1. Lambda 表達式： 函數式介面首選（Runnable, Callable, Comparator, Consumer, Function 等）。
2. 方法引用： ClassName::method、instance::method、Constructor::new。
3. 靜態內部類 / 獨立類： 邏輯復雜、需復用、需測試、需序列化時。
4. 函數式編程組合： Stream、CompletableFuture 替代手動線程管理。

結語

匿名內部類是 Java 1.1 時代為「函數式編程」做出的妥協產物，解決了「一次性實現介面」的語法痛點。Java 8 引入 Lambda 與 invokedynamic 後，匿名類完成了歷史使命，退居為「非函數式介面、需捕獲可變狀態、需遞歸、需序列化」等邊界場景的備選方案。理解其捕獲語義、this 指向、字節碼結構，有助於排查遺留系統疑難雜症；新代碼請擁抱 Lambda 與流式 API，寫出更簡潔、更安全、更高效的現代 Java 代碼。