匿名内部类 · Lumjiel

在 Java 开发中，我们经常会见到这样的代码：

List<TreeNode> queue = new LinkedList<>() {{ add(root); }};

初看之下，这行代码是创建了一个 LinkedList 集合并添加了 root 元素，但其中的 {{ ... }} 语法却让不少初学者感到困惑。其实这背后隐藏着 Java 中一个非常实用的特性 ——匿名内部类。本文就从这行代码出发，带你彻底搞懂匿名内部类的本质、用法、原理和注意事项。

一、先拆解：那行代码到底在做什么？

要理解匿名内部类，我们先把开头的代码拆解开，看看它的执行逻辑：

1. 表面现象

这行代码看似是 “创建 LinkedList 实例 + 直接添加元素”，但实际上做了两件核心事情：

定义了一个没有名字的内部类（匿名内部类），这个类继承自 LinkedList<TreeNode>；
在匿名内部类中，通过实例初始化块（{ ... }）调用 add(root) 方法，完成元素添加；
创建这个匿名内部类的实例，并赋值给 List<TreeNode> 类型的变量 queue。

2. 等价于显式代码

为了更直观，我们可以把匿名内部类 “显式化”。上面的代码等价于：注:Anonymous 匿名的

// 1. 定义一个继承自 LinkedList 的命名内部类
class AnonymousLinkedList extends LinkedList<TreeNode> {
    // 2. 实例初始化块：创建对象时自动执行
    {
        add(root);
    }
}
// 3. 创建该类的实例并赋值
List<TreeNode> queue = new AnonymousLinkedList();

通过对比可以发现：匿名内部类本质就是 “没有类名的继承 / 实现类”，它省略了类的命名步骤，直接在创建对象时定义类的结构，用完即弃。

二、匿名内部类的核心概念

1. 定义

匿名内部类是 Java 中的一种特殊内部类，它没有显式的类名，通常用于创建一个 “只使用一次” 的类实例，并且在创建实例的同时完成类的定义。

2. 语法结构

匿名内部类的语法固定格式如下：

父类/接口 变量名 = new 父类/接口(构造参数) {
    // 匿名内部类的类体：可以重写方法、定义属性、实例初始化块等
};

拆解语法要素：

父类 / 接口：匿名内部类必须继承一个父类（如开头代码中继承 LinkedList）或实现一个接口（如 Runnable、Comparator）；
new 父类/接口(构造参数)：表面是调用父类 / 接口的构造方法，实际是创建匿名内部类的实例（接口本身不能实例化，这里是编译器的语法糖）；
{ ... }：这是匿名内部类的类体，包含类的核心逻辑（重写方法、初始化代码等）。

3. 关键特征

没有类名：无法通过 “类名.new” 的方式创建多个实例（除非重复定义，但失去意义）；
必须继承 / 实现：不能独立存在，必须依附于一个父类或接口；
生命周期短暂：通常只创建一个实例，用完后被垃圾回收；
可以访问外部环境：能访问外部类的成员（非静态内部类可访问外部类所有成员，局部匿名内部类可访问局部 final 变量）。

三、匿名内部类的常见用法

匿名内部类的核心价值是 “简化代码”，尤其是在需要临时创建一个类的实例（且只使用一次）时。常见场景有 3 类：

1. 继承父类，重写方法

开头的代码就是典型场景：继承 LinkedList 父类，通过实例初始化块完成初始化操作（添加元素）。再举一个简单例子：

// 父类：Animal
class Animal {
    public void cry() {
        System.out.println("动物叫");
    }
}

// 匿名内部类继承 Animal，重写 cry 方法
Animal cat = new Animal() {
    @Override
    public void cry() {
        System.out.println("喵喵喵");
    }
};
cat.cry(); // 输出：喵喵喵

2. 实现接口，重写抽象方法

这是最常用的场景！Java 中接口不能实例化，但可以通过匿名内部类实现接口的抽象方法，避免创建单独的实现类。例如：

（1）线程创建（实现 Runnable 接口）

// 传统方式：创建 Runnable 实现类（繁琐）
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行");
    }
}
new Thread(new MyRunnable()).start();

// 匿名内部类方式（简化）
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程执行（匿名内部类）");
    }
}).start();

（2）集合排序（实现 Comparator 接口）

List<Integer> list = Arrays.asList(3, 1, 2);
// 匿名内部类实现 Comparator 接口，定义排序规则
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2; // 升序排序
    }
});
System.out.println(list); // 输出：[1, 2, 3]

3. 作为方法参数（简化回调逻辑）

当方法参数是 “接口 / 抽象类类型” 时，直接传入匿名内部类，避免单独定义类。例如：

// 定义一个需要回调的方法
public static void doSomething(Callback callback) {
    System.out.println("执行核心逻辑");
    callback.onFinish(); // 回调方法
}

// 回调接口
interface Callback {
    void onFinish();
}

// 调用方法时，传入匿名内部类作为参数
doSomething(new Callback() {
    @Override
    public void onFinish() {
        System.out.println("核心逻辑执行完毕（回调）");
    }
});

四、深入原理：匿名内部类的底层实现

匿名内部类并不是 “无中生有”，编译器会在编译时为它生成一个命名的 class 文件，格式为 外部类名$数字.class（例如外部类是 Test，匿名内部类会生成 Test$1.class、Test$2.class 等，按定义顺序编号）。

以开头的代码为例，编译器会生成一个类似这样的类：

// 编译器生成的命名类（我们看不到，但真实存在）
class Test$1 extends LinkedList<TreeNode> {
    // 外部类的引用（如果访问了外部类成员，会自动生成）
    final Test this$0;
    // 外部变量 root 的引用（如果 root 是局部变量，会自动传入）
    final TreeNode val$root;

    // 构造方法（编译器自动生成）
    Test$1(Test this$0, TreeNode val$root) {
        this.this$0 = this$0;
        this.val$root = val$root;
        super(); // 调用父类 LinkedList 的构造方法
        this.add(val$root); // 实例初始化块的代码被移到构造方法中
    }
}

从底层实现可以看出：

匿名内部类的实例初始化块 { ... } 会被编译器合并到构造方法中；
如果匿名内部类访问了外部类的成员或局部变量，编译器会自动在匿名内部类中添加对应的引用，并通过构造方法传入（这也是局部变量需要是 final 的原因：避免外部变量修改后，匿名内部类中引用不一致）。

五、注意事项与避坑指南

1. 局部变量必须是 final（或 effectively final）

如果匿名内部类访问了所在方法的局部变量，该变量必须是 final（Java 8 后允许省略 final，但变量必须是 “effectively final”—— 即声明后不再修改）。例如：

public static void test() {
    int num = 10; // effectively final（未修改）
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(num); // 合法
        }
    };
    // num = 20; // 错误：修改后不再是 effectively final
}

原因：局部变量存储在栈中，方法执行完毕后栈帧销毁；而匿名内部类的实例可能还存在（如线程未执行完）。为了避免 “变量已销毁但匿名内部类还在访问” 的矛盾，编译器会将局部变量复制到匿名内部类中，并要求变量不可修改（保证复制前后一致）。

2. 不能有构造方法，但可以有实例初始化块

匿名内部类没有类名，因此不能定义显式的构造方法（构造方法名必须与类名一致）。但可以通过实例初始化块（{ ... }）完成初始化操作（如开头代码中的 add(root)），初始化块会在父类构造方法执行后、匿名内部类实例创建前执行。

3. 与 Lambda 表达式的区别（Java 8+）

Java 8 引入的 Lambda 表达式看似和匿名内部类功能类似（都能简化接口实现），但二者有本质区别：

特性	匿名内部类	Lambda 表达式
适用场景	继承类、实现多方法接口	仅适用于 “函数式接口”（单抽象方法）
生成 class 文件	会生成独立的 $ 数字.class	不会生成独立 class（通过 invokedynamic 指令实现）
访问外部变量	支持 final/effectively final	同左
代码简洁度	较繁琐	极简洁

例如，之前的 Runnable 示例用 Lambda 表达式可简化为：

new Thread(() -> System.out.println("线程执行（Lambda）")).start();

结论：如果是实现 “函数式接口”（仅一个抽象方法），优先用 Lambda 表达式；如果是继承类、实现多方法接口，必须用匿名内部类。

4. 避免过度使用：可读性优先

匿名内部类虽然简化代码，但如果类体逻辑复杂（如超过 10 行代码），会导致代码可读性下降（匿名类没有名字，他人难以理解其职责）。此时建议创建单独的命名类，而非匿名内部类。

5. 开头代码的潜在问题

回到文章开头的代码 new LinkedList<>() {{ add(root); }}，虽然简洁，但有一个潜在问题：

每次执行都会创建一个新的匿名内部类实例（而非 LinkedList 原生实例）；
如果频繁执行（如循环中），会产生大量匿名内部类实例，可能影响性能（虽然影响微小，但需注意）。

六、总结

匿名内部类是 Java 中 “简化代码、临时使用” 的重要特性，核心要点如下：

本质：没有类名的继承类 / 实现类，编译后会生成命名的 class 文件；
语法：new 父类/接口() { 类体 }，必须继承父类或实现接口；
场景：临时创建实例（仅用一次）、实现接口（如回调、排序）、简化方法参数；
坑点：局部变量需为 final、无显式构造方法、避免逻辑复杂的匿名类；
对比：Java 8+ 中，函数式接口优先用 Lambda，多方法 / 继承类用匿名内部类。

理解匿名内部类后，再看 new LinkedList<>() {{ add(root); }} 这样的代码就一目了然了 —— 它不是什么 “黑魔法”，只是用匿名内部类简化了集合初始化。在实际开发中，合理使用匿名内部类能让代码更简洁，但需平衡简洁性和可读性，避免过度使用。