Java 基础体系 · 第 44/100 篇。示例统一以 Java 25 LTS 为语言和 JVM 基线；框架示例使用与其兼容的现代稳定版本。

Java 25 嵌套类、内部类、局部类与匿名类：捕获和生命周期

在 Java 中，类声明的位置会改变它的名称、可见性、创建方式，以及对象与外部作用域之间的关系。尤其是“捕获”和“生命周期”这两个问题，不能只用“内部类可以访问外部类成员”来概括：

• 一个类是否是嵌套类，描述的是它声明在另一个类或接口内部。
• 一个嵌套类是否是内部类，取决于它是否具有隐式或显式的静态属性。
• 一个类是否是局部类，取决于它是否声明在方法、构造器、局部初始化器或静态初始化器内部。
• 一个对象是否捕获了局部变量、外部实例或其他对象，决定了它可能延长哪些对象的可达生命周期。
• 类的加载与初始化生命周期，与类实例的构造、可达性和垃圾回收生命周期，是不同层次的概念。

本文以 Java 25 为范围，先建立分类，再分别推导成员嵌套类、内部类、局部类和匿名类的捕获规则与生命周期。

---

一、先区分四个层次：声明、类型、实例和作用域

1. 嵌套类：声明位置的总称

如果一个类声明出现在另一个类或接口的主体内部，它就是嵌套类（nested class）。

class Outer {
    static class StaticNested {
    }

    class Inner {
    }

    void method() {
        class Local {
        }

        Object anonymous = new Object() {
        };
    }
}

这里有四个类声明：

• Outer.StaticNested：静态嵌套成员类；
• Outer.Inner：非静态嵌套成员类，也就是内部类；
• Local：局部类；
• new Object() {} 创建的匿名类：匿名类。

“嵌套类”是总称，不等于“内部类”。判断关系可以写成：

嵌套类
├── 静态嵌套类
└── 非静态嵌套类，即内部类
    ├── 非静态成员类
    ├── 局部类
    └── 匿名类

但这里还要注意一个容易混淆的点：局部类和匿名类是否属于“内部类”，不能只看它们是否写在方法里，而要看它们是否是静态的。Java 语言规范把没有显式或隐式静态属性的嵌套类称为内部类。通常，方法中的局部类和匿名类都是内部类；如果它们位于静态上下文中，则没有外部实例可供捕获。

2. 成员类、局部类和匿名类：按声明方式分类

嵌套类还可以按“声明出现在哪里”分类：

类型	声明位置	是否有类名	是否可以直接声明构造器
成员类	外部类或接口的成员区域	有	可以
局部类	方法、构造器或局部初始化器内部	有，但作用域局部	可以
匿名类	类实例创建表达式中	没有源代码级名称	不能声明显式构造器

静态嵌套类是成员类的一种。内部类则可能是成员类、局部类或匿名类。

3. 四种生命周期不能混为一谈

分析下面代码时，至少要区分四个问题：

class Outer {
    class Inner {
    }
}

1. Outer 这个类型何时被加载、链接和初始化？
2. Inner 这个类型何时被加载、链接和初始化？
3. new Outer() 创建的外部对象何时可回收？
4. new Outer().new Inner() 创建的内部类对象何时可回收？

类型生命周期由类加载器、类初始化和类卸载决定；对象生命周期主要由可达性决定。一个类声明存在，并不意味着已经创建了对应对象；创建内部类对象，也不代表其类型一定在每次创建时重新初始化。

---

二、静态嵌套类与内部类的根本区别

1. 静态嵌套类不需要外部实例

class Counter {
    private int value;

    static class Factory {
        static Counter create() {
            return new Counter();
        }
    }
}

创建 Factory 对象时不需要先创建 Counter 对象：

Counter.Factory factory = new Counter.Factory();
Counter counter = Counter.Factory.create();

静态嵌套类可以访问外部类的静态成员，但不能直接访问某个外部类实例的实例成员：

class Outer {
    private static int staticValue = 10;
    private int instanceValue = 20;

    static class Nested {
        int read() {
            return staticValue;   // 合法

            // return instanceValue; // 编译错误：没有外部 Outer 实例
        }
    }
}

如果静态嵌套类确实需要外部对象，必须显式持有它：

class Outer {
    private int value;

    static class Nested {
        private final Outer owner;

        Nested(Outer owner) {
            this.owner = owner;
        }

        int read() {
            return owner.value;
        }
    }
}

这里的 owner 是普通的显式字段，不是 Java 语言为内部类自动建立的外部实例关系。

2. 非静态成员类具有外部实例

class Outer {
    private int value = 42;

    class Inner {
        int read() {
            return value;
        }
    }
}

创建 Inner 对象时必须提供一个 Outer 实例：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

表达式：

outer.new Inner()

分为两个语义步骤：

1. 计算 outer，得到一个 Outer 实例；
2. 在该外部实例的上下文中创建 Inner 实例。

也可以在 Outer 的实例方法中直接写：

class Outer {
    class Inner {
    }

    Inner createInner() {
        return new Inner();
    }
}

此时 new Inner() 中的外部实例就是当前的 this。

如果外部实例表达式为 null，创建内部类对象会失败：

Outer outer = null;
Outer.Inner inner = outer.new Inner(); // NullPointerException

这不是因为 Inner 的构造器主动解引用了某个字段，而是因为内部类实例必须绑定到一个真实的外部实例。

3. 内部类中的 this 与外部类中的 this

在内部类中：

class Outer {
    int id = 1;

    class Inner {
        int id = 2;

        void print() {
            System.out.println(id);
            System.out.println(this.id);
            System.out.println(Outer.this.id);
        }
    }
}

输出为：

2
2
1

含义分别是：

• id：默认解析到当前 Inner 对象的字段；
• this.id：明确表示当前 Inner 对象的字段；
• Outer.this.id：明确表示与当前 Inner 对象关联的 Outer 对象的字段。

Outer.this 是内部类访问其直接词法外部实例的语法。对于多层嵌套，可以写：

class A {
    class B {
        class C {
            int readA() {
                return A.this.hashCode();
            }
        }
    }
}

---

三、成员类、局部类和匿名类如何访问外部状态

需要把“访问外部成员”和“捕获局部变量”分开。

1. 外部字段访问依赖实例或静态成员

成员类可以访问外部类的私有成员：

class Account {
    private long balance = 100;

    class View {
        long balance() {
            return balance;
        }
    }
}

这不是因为 Java 把 private 当成了 public，而是 Java 语言允许嵌套类型访问其外部类的成员。编译器和 JVM 会共同保证这种访问能够实现。

如果字段是实例字段，非静态内部类还需要一个外部实例：

Account account = new Account();
Account.View view = account.new View();

如果字段是静态字段，静态嵌套类也可以访问：

class Config {
    private static String environment = "prod";

    static class Reader {
        String read() {
            return environment;
        }
    }
}

2. 局部变量捕获有明确限制

局部类和匿名类可以使用外层方法的参数和局部变量，但被使用的局部变量必须是：

• final 变量；或者
• 有效 final（effectively final）变量。

有效 final 的含义是：变量没有声明为 final，但初始化后没有再次赋值，也没有对它使用 ++、-- 等改变变量值的操作。

class Example {
    Runnable create(int input) {
        int base = 10; // 有效 final

        return new Runnable() {
            @Override
            public void run() {
                System.out.println(base + input);
            }
        };
    }
}

base 和 input 都没有重新赋值，因此可以被匿名类使用。

下面代码不能编译：

Runnable create() {
    int count = 0;

    count++; // count 不再是有效 final

    return () -> System.out.println(count);
}

典型编译错误会表达为变量必须是 final 或有效 final。原因不是匿名类不能访问局部变量，而是 Java 不允许它捕获一个可能继续被重新赋值的局部变量。

3. “变量捕获”不是“共享局部变量槽位”

看下面代码：

class Example {
    Runnable create() {
        int value = 10;

        Runnable result = new Runnable() {
            @Override
            public void run() {
                System.out.println(value);
            }
        };

        return result;
    }
}

create() 返回后，栈上的局部变量 value 已经不存在。为了让返回的对象仍然能打印 10，Java 的语义要求匿名类对象保存捕获值。

可以用近似模型理解编译器生成的结果：

final class SyntheticAnonymous implements Runnable {
    private final int capturedValue;

    SyntheticAnonymous(int capturedValue) {
        this.capturedValue = capturedValue;
    }

    @Override
    public void run() {
        System.out.println(capturedValue);
    }
}

实际生成的类名、字段名和字节码细节属于实现细节，不能依赖 this$0、val$value 等合成名称；但“对象需要保留捕获值”是理解语言行为的正确模型。

因此，下面的直觉是错误的：

匿名类以后运行时，会回到 create() 的栈帧中读取 value。

正确理解是：

匿名类实例在创建时获得了 value 的值，并在自己的对象状态中保存这个值。

4. 捕获的是值，还是可变对象的引用

如果捕获的是引用类型变量，保存的是引用值；引用指向的对象仍然可能被修改。

class Example {
    Runnable create() {
        var state = new StringBuilder("A");

        return () -> {
            state.append("B");
            System.out.println(state);
        };
    }
}

这里 state 变量本身没有重新赋值，所以可以捕获；但 StringBuilder 对象的内容可以改变。

返回的 Runnable 被调用时会输出：

AB

若后续还有其他代码持有同一个 StringBuilder 并修改它，匿名类也会观察到修改后的对象状态。这不是“捕获了变量槽位”，而是捕获了同一个对象引用。

这种方式不会自动产生线程安全性。多个线程同时调用 run() 时，StringBuilder 的并发修改仍然可能产生竞态。

5. 用可变容器绕过限制，并没有绕过并发问题

下面代码可以编译：

Runnable create() {
    int[] box = {0};

    Runnable r = () -> System.out.println(box[0]);

    box[0] = 42;
    return r;
}

输出通常为：

42

因为匿名类捕获的是数组引用，而不是数组元素的快照。box 变量本身没有重新指向其他数组，但数组内容可以改变。

这只是改变了数据模型，并没有让局部变量重新变成共享变量。实际共享的是堆上的数组对象，因此仍然需要考虑：

• 是否需要同步；
• 是否需要 volatile 或原子类型；
• 是否存在对象发布不安全；
• 回调执行时是否仍应看到最新状态。

如果需要跨线程更新，通常应明确使用 AtomicInteger、锁或其他并发工具，而不是依赖数组技巧。

---

四、局部类：有名字的局部类型

1. 局部类的作用域从声明点开始

class Parser {
    Object parse(String text) {
        class Result {
            private final String value;

            Result(String value) {
                this.value = value;
            }

            String value() {
                return value;
            }
        }

        return new Result(text.trim());
    }
}

Result 只在 parse 方法中从声明点之后可见：

class Parser {
    Object parse(String text) {
        // Result x = ...; // 编译错误：声明前不可用

        class Result {
        }

        Result result = new Result();
        return result;
    }

    // Result field; // 编译错误：Result 不在这里的作用域内
}

局部类有类名，因此可以：

• 声明字段和方法；
• 实现接口；
• 继承类；
• 声明构造器；
• 在方法内部多次创建该局部类的对象。

2. 局部类同时捕获外部实例和局部变量

class Report {
    private final String prefix;

    Report(String prefix) {
        this.prefix = prefix;
    }

    Runnable createTask(String name) {
        class Task implements Runnable {
            @Override
            public void run() {
                System.out.println(prefix + ": " + name);
            }
        }

        return new Task();
    }
}

这里有两种不同的外部状态：

• prefix 是 Report 的实例字段，访问它需要关联的 Report 实例；
• name 是方法参数，局部类需要捕获它的值。

可用近似对象关系表示：

Task 对象
├── 外部 Report 实例引用
└── 捕获的 name 引用

因此：

Report report = new Report("INFO");
Runnable task = report.createTask("import");

即使 createTask 已经返回，task 仍然能够访问 prefix 和 name。

3. 局部类的创建是运行时动作

局部类的声明在编译期确定，但对象的创建由执行路径决定：

Runnable create(boolean enabled) {
    class Task implements Runnable {
        @Override
        public void run() {
            System.out.println("run");
        }
    }

    if (!enabled) {
        return null;
    }

    return new Task();
}

当 enabled 为 false 时，局部类定义存在，但没有创建 Task 实例。执行 new Task() 一次创建一个新对象：

Runnable a = create(true);
Runnable b = create(true);

System.out.println(a == b); // false

除非代码显式复用某个对象，否则每次执行对象创建表达式都会得到不同实例。

4. 局部类可以使用泛型和继承关系

import java.util.Comparator;

class Sorter {
    Comparator<String> descending() {
        class Descending implements Comparator<String> {
            @Override
            public int compare(String left, String right) {
                return right.compareTo(left);
            }
        }

        return new Descending();
    }
}

局部类适合需要多个方法、字段或较清晰的状态结构，但类型只服务于一个方法的场景。它与匿名类的主要差别不是“能不能捕获”，而是是否需要一个可在局部作用域中引用的类声明。

---

五、匿名类：没有源代码级名称的类实例

1. 匿名类是类实例创建表达式的一部分

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("running");
    }
};

new Runnable() { ... } 同时完成两件事：

1. 声明一个没有源代码级名称的类；
2. 创建该类的一个实例。

匿名类必须：

• 继承一个类，或实现一个接口；
• 提供所需的抽象方法实现；
• 通过实例初始化器或捕获值完成初始化。

它不能像普通命名类那样声明显式构造器，因为没有可用于构造器名称的类名：

Runnable task = new Runnable() {
    // Runnable() { } // 编译错误：不能声明匿名类构造器
};

2. 匿名类可以有实例初始化器

class Service {
    Runnable create() {
        return new Runnable() {
            private final String message;

            {
                message = "initialized";
            }

            @Override
            public void run() {
                System.out.println(message);
            }
        };
    }
}

实例初始化器会在匿名类对象构造过程中执行。更常见的方式是直接初始化字段：

return new Runnable() {
    private final String message = "initialized";

    @Override
    public void run() {
        System.out.println(message);
    }
};

3. 匿名类对象的静态类型通常是父类型或接口类型

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("run");
    }

    public void extraMethod() {
        System.out.println("extra");
    }
};

task.run();
// task.extraMethod(); // 编译错误

变量 task 的静态类型是 Runnable，因此只能直接调用 Runnable 声明的方法。匿名类中额外声明的方法并不会自动出现在父类型接口中。

使用 var 可以让局部变量保留匿名类的推断类型：

var task = new Runnable() {
    @Override
    public void run() {
        System.out.println("run");
    }

    public void extraMethod() {
        System.out.println("extra");
    }
};

task.run();
task.extraMethod();

这并不意味着匿名类获得了稳定的源代码名称，也不适合把匿名类的私有实现细节暴露到较大范围。var 只影响局部变量的静态类型推断。

4. 匿名类与 Lambda 不是同一种机制

如果目标类型是函数式接口，下面两种写法都可能可用：

Runnable a = () -> System.out.println("lambda");

Runnable b = new Runnable() {
    @Override
    public void run() {
        System.out.println("anonymous");
    }
};

但它们的语义不同：

• Lambda 表达式不是匿名类声明；
• 匿名类有自己的 this；
• Lambda 中的 this 指向外围对象；
• 匿名类可以声明额外字段、方法和实例初始化器；
• Lambda 的实现形式可以由 JVM 使用 invokedynamic 等机制处理，不能按匿名类的对象结构推断。

比较 this：

class Demo {
    void test() {
        Runnable lambda = () ->
            System.out.println(this.getClass().getName());

        Runnable anonymous = new Runnable() {
            @Override
            public void run() {
                System.out.println(this.getClass().getName());
            }
        };

        lambda.run();
        anonymous.run();
    }
}

Lambda 中的 this 是 Demo.this；匿名类中的 this 是匿名类实例本身。

---

六、捕获的形式化条件与执行时机

1. 局部变量捕获条件

设一个局部变量为 v，一个局部类或匿名类中的表达式引用了 v。要使该引用合法，v 必须满足：

v 是 final
或
v 是有效 final

若 v 为引用类型，还要区分：

变量引用不可重新赋值
≠
引用指向的对象不可变

例如：

final StringBuilder builder = new StringBuilder("A");
Runnable r = () -> builder.append("B");

这里变量 builder 是 final，但对象内容仍可变化。

2. 捕获发生在实例创建时

Runnable create() {
    String message = "first";

    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println(message);
        }
    };

    return r;
}

执行过程可拆成：

1. 进入 create，创建局部变量 message；
2. 执行匿名类实例创建表达式；
3. 将当前 message 的引用值交给新对象；
4. 将新对象赋给 r；
5. 方法返回；
6. 栈上的局部变量生命周期结束，但匿名对象仍保留所需状态；
7. 以后调用 r.run()，从匿名对象保存的状态读取消息。

由于 message 不能被重新赋值，Java 不需要定义“匿名对象究竟读取哪个时间点的局部变量值”的共享变量语义。

3. 捕获值不是延迟求值

class Example {
    Runnable create() {
        String value = new String("A");

        Runnable r = () -> System.out.println(value);

        return r;
    }
}

匿名类或 Lambda 捕获的是 value 当前保存的引用。它不会在未来重新执行 new String("A")，也不会重新查找 create() 的局部变量。

若想让回调每次获取最新结果，应捕获一个提供结果的对象或方法，而不是捕获一次性结果：

import java.util.function.Supplier;

class Example {
    Supplier<String> createSupplier() {
        return () -> loadCurrentValue();

        // 假设 loadCurrentValue() 是当前类中的实例方法
    }

    private String loadCurrentValue() {
        return "current";
    }
}

这里每次调用 get() 都会执行 loadCurrentValue()；这属于延迟执行，而不是普通变量捕获。

---

七、外部实例引用是内部类生命周期的关键

1. 内部类对象通常保持外部实例可达

考虑：

class Session {
    private final byte[] cache = new byte[1024 * 1024];

    class Listener {
        void onEvent() {
            System.out.println(cache.length);
        }
    }

    Listener listener() {
        return new Listener();
    }
}

调用：

Session session = new Session();
Session.Listener listener = session.listener();

session = null;

此时 session 这个局部变量不再指向 Session，但 listener 仍然指向内部类对象，而内部类对象必须关联其外部 Session 实例。于是对象图近似为：

listener
  │
  ▼
Listener ─────► Session ─────► cache

只要 listener 仍然可达，Session 和 cache 通常也会继续可达。

这不是“内部类复制了外部对象所有字段”，而是内部类对象保存了外部实例关系；访问 cache 时，实际仍然通过那个 Session 实例读取字段。

2. 静态嵌套类没有这个隐式关系

class Session {
    private final byte[] cache = new byte[1024 * 1024];

    static class Listener {
        void onEvent() {
            // 不能直接访问某个 Session 的 cache
        }
    }
}

静态嵌套类实例不会因为“声明在 Session 内部”就自动持有 Session 实例：

listener
  │
  ▼
StaticListener

如果静态嵌套类中出现了对外部实例的引用，只能是代码显式保存的引用：

static class Listener {
    private final Session session;

    Listener(Session session) {
        this.session = session;
    }
}

此时延长 Session 生命周期的是显式字段，而不是静态嵌套类这一分类本身。

3. 返回回调时容易形成长期引用链

class Controller {
    private final byte[] largeState = new byte[10 * 1024 * 1024];

    Runnable callback() {
        return new Runnable() {
            @Override
            public void run() {
                System.out.println(largeState.length);
            }
        };
    }
}

如果把返回的 Runnable 注册到一个长期存活的调度器、事件总线或线程池中：

Runnable callback = new Controller().callback();
registry.register(callback);

那么可能形成：

registry
  │
  ▼
anonymous Runnable
  │
  ▼
Controller
  │
  ▼
largeState

这会使 Controller 及其关联状态保持可达。是否构成内存泄漏，取决于注册表是否会移除回调以及回调是否应当长期存在；但引用链本身是确定的。

4. WeakReference 不能自动解除内部类关系

把外部对象放入 WeakReference，可以避免某个显式引用保持对象强可达：

import java.lang.ref.WeakReference;

class Listener {
    private final WeakReference<Controller> controller;

    Listener(Controller controller) {
        this.controller = new WeakReference<>(controller);
    }
}

但如果 Listener 本身是 Controller 的非静态内部类，它通常已经有一个强的外部实例引用。此时再增加 WeakReference<Controller> 并不能消除内部类自带的强引用。

如果确实需要弱引用语义，通常应使用静态嵌套类或顶层类，并显式管理 WeakReference。

---

八、生命周期：从类型初始化到对象回收

1. 类型生命周期与实例生命周期独立

class Outer {
    static int x = initialize();

    static int initialize() {
        System.out.println("Outer initialized");
        return 1;
    }

    static class Nested {
        static int y = initializeNested();

        static int initializeNested() {
            System.out.println("Nested initialized");
            return 2;
        }
    }
}

仅加载或引用 Outer、Outer.Nested 的符号，不应简单等价为两个类的静态初始化代码都已经执行。类初始化由 Java 语言规范规定的主动使用条件触发；具体的加载和链接时间还由 JVM 实现决定。

例如：

int value = Outer.Nested.y;

会主动使用 Nested 的静态字段，从而触发 Nested 的初始化。是否同时初始化 Outer，要根据 Nested 的初始化代码和实际主动使用路径判断，不能用“嵌套类一定先初始化外部类”概括。

工程上应区分：

• 规范保证：静态初始化按类初始化规则执行，并且同一个类初始化至多成功完成一次；
• 实现行为：类文件、内部类元数据和合成字段的具体布局；
• 对象生命周期：由强引用、软引用、弱引用、虚引用和垃圾回收器共同影响。

2. 对象何时可回收由可达性决定

Java 没有规定对象创建后经过固定时间就回收。对象在某次垃圾回收判断中不可从 GC Roots 到达时，才具备被回收的条件。

下列对象通常属于重要的可达性来源：

• 当前线程栈中的局部变量；
• 静态字段；
• 活跃线程；
• JNI 引用；
• 类加载器及其关联对象；
• 其他仍然可达对象中的实例字段。

因此：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

outer = null;

不能推出 Outer 一定可以回收，因为 inner 可能仍然持有它。

3. 内部类对象不一定比外部类对象“活得短”

class Outer {
    class Inner {
    }
}

常见误解是：

Outer 创建后，Inner 只是一个临时附属对象，所以 Inner 一定随 Outer 一起消失。

实际关系是双向推理中的单向强引用：

Inner ─────► Outer

但 Outer 不一定反向持有 Inner。因此可能出现：

• Outer 仍可达，而 Inner 不可达：只回收 Inner；
• Inner 仍可达，因此 Outer 也可达：两者都不能回收；
• Outer 通过字段持有 Inner，两者形成互相引用：只要没有外部根指向它们，循环引用仍然可以被垃圾回收。

垃圾回收器处理的是整体可达性，不是简单的引用计数。

---

九、构造、初始化和捕获的执行顺序

下面例子展示外部对象、捕获参数和匿名类字段初始化的关系：

class Outer {
    private final String outerName;

    Outer(String outerName) {
        System.out.println("Outer constructor: " + outerName);
        this.outerName = outerName;
    }

    Runnable create(String taskName) {
        System.out.println("before anonymous creation");

        return new Runnable() {
            private final String label = outerName + "/" + taskName;

            {
                System.out.println("anonymous initializer: " + label);
            }

            @Override
            public void run() {
                System.out.println("run: " + label);
            }
        };
    }
}

class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("service");
        Runnable task = outer.create("load");
        task.run();
    }
}

输出顺序为：

Outer constructor: service
before anonymous creation
anonymous initializer: service/load
run: service/load

因果关系如下：

1. new Outer("service") 先执行 Outer 构造器；
2. outer.create("load") 进入方法；
3. 执行匿名类实例创建表达式；
4. 新匿名对象关联当前 Outer 实例，并保存捕获的 taskName；
5. 初始化匿名类字段 label；
6. 执行匿名类实例初始化器；
7. 方法返回匿名对象；
8. 调用 run()，读取匿名对象已经初始化的 label。

如果匿名类初始化期间抛出异常，实例创建表达式不会返回一个可用对象，外层方法也会异常退出。捕获并不改变构造器和实例初始化器的异常规则。

---

十、局部类和匿名类位于静态上下文时

1. 静态方法没有外部实例

class Util {
    private static String prefix = "util";

    static Runnable create(String name) {
        class Task implements Runnable {
            @Override
            public void run() {
                System.out.println(prefix + ": " + name);
            }
        }

        return new Task();
    }
}

Task 可以访问：

• Util.prefix 这样的静态成员；
• create 的参数 name。

但它不能使用 Util.this，因为 create 是静态方法，没有当前 Util 实例：

class Util {
    static Runnable create() {
        return new Runnable() {
            @Override
            public void run() {
                // System.out.println(Util.this); // 编译错误
            }
        };
    }
}

2. 实例字段、静态字段和局部变量的区别

在实例方法中：

class Example {
    private int instanceValue = 1;
    private static int staticValue = 2;

    Runnable create(int parameter) {
        int localValue = 3;

        return () -> System.out.println(
            instanceValue + staticValue + parameter + localValue
        );
    }
}

四个值的来源不同：

名称	来源	是否需要外部实例
instanceValue	Example 实例字段	是
staticValue	Example 静态字段	否
parameter	方法参数	通过捕获保存
localValue	局部变量	通过捕获保存

把它们都称为“捕获变量”会掩盖重要差异。严格说，局部变量和参数需要被捕获；实例字段则通过外部实例关系访问。

---

十一、Java 25 中的静态成员限制不要套用旧规则

历史上，Java 对内部类声明静态成员有较严格的限制。Java 16 放宽了内部类静态成员的相关限制，Java 25 应按当前 Java 语言规范判断，而不能继续使用早期版本“内部类不能有任何静态成员”的旧结论。

需要区分两件事：

class Outer {
    class Inner {
        static int counter = 0;
    }
}

这里 Inner 仍然是非静态内部类。允许声明静态成员，并不代表 Inner 变成了静态嵌套类，也不代表它不再需要 Outer 实例：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

“类中有静态成员”和“类声明为 static”是两个不同问题：

• static class Nested：改变嵌套类是否需要外部实例；
• static int counter：声明一个属于类型而不是对象的静态成员。

判断 Java 25 某种具体声明是否合法时，应以 Java SE 25 的 JLS 8.1.3、8.5 和相关局部类规则为准，而不要依赖旧版编译器的记忆。

---

十二、完整示例：比较四种类型的创建与引用链

下面代码可以使用 JDK 25 编译运行：

import java.util.concurrent.atomic.AtomicInteger;

public class NestedLifecycleDemo {
    private final String ownerName;
    private final AtomicInteger value = new AtomicInteger();

    public NestedLifecycleDemo(String ownerName) {
        this.ownerName = ownerName;
    }

    // 静态嵌套成员类：没有隐式外部实例
    public static class StaticNested {
        private final String name;

        public StaticNested(String name) {
            this.name = name;
        }

        public String describe() {
            return "static nested: " + name;
        }
    }

    // 非静态成员类：具有外部实例关系
    public class Inner {
        public String describe() {
            return "inner of " + ownerName;
        }
    }

    public Runnable createTask(int increment) {
        // increment 没有再次赋值，因此是有效 final
        class LocalTask implements Runnable {
            @Override
            public void run() {
                int result = value.addAndGet(increment);
                System.out.println(ownerName + ": " + result);
            }
        }

        // 匿名类也捕获 ownerName、value 和 increment
        Runnable anonymousTask = new Runnable() {
            @Override
            public void run() {
                int result = value.addAndGet(increment);
                System.out.println("anonymous " + ownerName + ": " + result);
            }
        };

        new LocalTask().run();
        return anonymousTask;
    }

    public static void main(String[] args) {
        StaticNested nested = new StaticNested("N");
        System.out.println(nested.describe());

        NestedLifecycleDemo owner = new NestedLifecycleDemo("O");

        Inner inner = owner.new Inner();
        System.out.println(inner.describe());

        Runnable task = owner.createTask(5);
        task.run();
    }
}

一种预期输出是：

static nested: N
inner of O
O: 5
anonymous O: 10

逐步解释：

1. new StaticNested("N") 不需要 NestedLifecycleDemo 实例；
2. owner.new Inner() 把 inner 绑定到 owner；
3. createTask(5) 创建一个局部类 LocalTask，并立即运行它；
4. 局部类通过外部实例访问 ownerName 和 value，通过捕获访问 increment；
5. 匿名类对象被返回；
6. 调用返回的匿名对象时，方法已经结束，但它仍保存了 increment，并仍通过外部实例关系访问 ownerName 和 value；
7. 两次 addAndGet(5) 分别产生 5 和 10。

这里使用 AtomicInteger 是为了让跨调用的可变状态语义明确；若改成普通 int 字段，则单线程示例仍然成立，但并发调用时不具备原子更新保证。

---

十三、失败表现与诊断方法

1. 捕获非有效 final 局部变量

void invalid() {
    int count = 0;

    Runnable r = () -> System.out.println(count);

    count++;
}

这段代码不能编译。即使 count++ 出现在匿名类创建之后，整个方法中的变量仍然不是有效 final。有效 final 是对变量声明和使用方式的静态判断，不是“创建回调那一行之前暂时没修改”。

修复方式不是简单地把变量复制到另一个同样会变化的变量，而是明确选择数据模型：

void validWithAtomic() {
    var count = new AtomicInteger(0);

    Runnable r = () -> System.out.println(count.get());

    count.incrementAndGet();
    r.run();
}

这里捕获的是不可重新赋值的 AtomicInteger 引用，变化发生在对象内部，并由原子类型提供并发语义。

2. 在静态上下文直接创建非静态内部类

class Outer {
    class Inner {
    }

    static Inner create() {
        return new Inner(); // 编译错误
    }
}

错误原因是 new Inner() 需要一个 Outer 外部实例，而静态方法没有 Outer.this。

可以改为：

class Outer {
    class Inner {
    }

    static Inner create(Outer outer) {
        return outer.new Inner();
    }
}

或者，如果 Inner 不需要外部实例，就把它设计为静态嵌套类：

class Outer {
    static class Nested {
    }

    static Nested create() {
        return new Nested();
    }
}

3. 误把 $ 类文件名当成语言语法

常见编译结果可能包含：

Outer.class
Outer$Inner.class
Outer$1.class

这些名称通常反映嵌套类或匿名类的实现布局，但 $ 是二进制名称中的常见实现形式，不是 Java 源代码中判断类型关系的规范依据。代码不应依赖：

• 匿名类一定按 Outer$1、Outer$2 编号；
• 合成字段一定叫 this$0；
• 编译器一定采用某一种捕获字段布局；
• 不同编译器、字节码转换器和构建流程产生完全相同的类文件名称。

4. 用堆转储验证引用链

当怀疑匿名类或内部类保留了不应长期存在的对象时，重点不是查看源代码中“有没有显式字段”，而是查看运行时引用链：

GC Root
  └── 注册表静态字段
      └── 回调对象
          └── 外部实例引用
              └── 大型缓存

在生产环境中通常应：

1. 通过受控方式获取堆转储；
2. 在 MAT、JProfiler 或同类工具中查找目标对象的 GC Roots；
3. 检查回调对象的实际类型和引用路径；
4. 确认注册表、线程池、定时器或监听器是否应该释放该回调；
5. 修复注销逻辑，或改用静态嵌套类并显式传递必要数据。

不要用强制 System.gc() 作为证明对象已经可以回收的依据。垃圾回收请求不是规范保证，而且即使发生回收，也不能替代对引用链的分析。

---

十四、生产代码中的取舍应从引用关系出发

1. 需要外部实例状态时使用内部类

内部类的优势是可以自然访问外部实例：

class Connection {
    private final Socket socket;

    class InputReader {
        byte[] read() {
            return socketRead(socket);
        }
    }

    private byte[] socketRead(Socket socket) {
        return new byte[0];
    }
}

代价是 InputReader 通常会保持 Connection 可达。若 InputReader 被放进长期存活的队列或缓存中，就必须确认这条引用链符合生命周期设计。

2. 只需要工具逻辑时优先考虑静态嵌套类

class Message {
    static class Validator {
        static boolean valid(String text) {
            return text != null && !text.isBlank();
        }
    }
}

Validator 不需要 Message 实例，因此静态嵌套类更准确地表达了依赖关系，也避免隐式外部实例引用。

3. 需要多个成员时使用局部类

局部类适合：

• 只在一个方法内使用；
• 需要多个字段或辅助方法；
• 需要实现接口或继承抽象类；
• 不希望把实现类型暴露为外部 API。

如果局部类实例被返回或注册到外部组件，它的“作用域局部”不等于“生命周期局部”。类型名称虽然只能在方法内使用，对象却可以通过接口或父类引用存活很久。

4. 一次性行为可使用匿名类，但要检查捕获对象

匿名类适合有状态的一次性实现：

Executor executor = command -> command.run();

executor.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("work");
    }
});

但在事件监听器、定时任务、异步执行器中，匿名类的简洁语法容易掩盖它捕获的外部实例和对象引用。诊断内存问题时，应把匿名类当成普通对象分析，而不是把它视为“轻量语法”。

---

十五、一个统一的判断方法

遇到嵌套类、内部类、局部类或匿名类问题时，可以按以下顺序推导：

第一步：判断声明分类

• 是否声明在另一个类或接口主体内？
• 是否是成员类、局部类，还是匿名类？
• 是否有 static，或处于接口等隐式静态上下文？

第二步：判断是否需要外部实例

• 静态嵌套类：语言上不需要外部实例；
• 非静态成员类：创建时必须绑定外部实例；
• 局部类或匿名类：如果位于实例上下文中，通常可以访问并保持外部实例；如果位于静态上下文中，则没有外部实例；
• 显式字段引用不应与隐式外部实例关系混淆。

第三步：列出所有外部状态

分别标记：

实例字段
静态字段
方法参数
局部变量
捕获的引用类型对象
显式保存的外部对象

只有参数和局部变量需要检查 final 或有效 final 规则；实例字段是否可变是另一个问题。

第四步：画出运行时引用图

例如：

长期存活组件
  └── 回调
      ├── 捕获的大型对象
      └── 非静态内部类的外部实例
          └── 其他字段

引用图比“这个类写在某个方法里”更能说明对象是否会继续存活。

第五步：分别检查类型和实例生命周期

不要把以下问题混为一个问题：

• 类何时加载？
• 静态初始化何时执行？
• 对象何时构造？
• 捕获值何时保存？
• 对象何时变得不可达？
• 类加载器何时可以卸载类？

---

结语

Java 25 中，嵌套类是声明位置的总称；静态嵌套类与内部类的分界在于是否需要外部实例；成员类、局部类和匿名类的分界在于声明位置和是否具有源代码级名称。

捕获机制的核心可以概括为两条不同的关系：

局部变量或参数：
    在对象创建时保存其值，要求 final 或有效 final

外部实例字段：
    通过内部类与外部实例之间的实例关系访问

生命周期问题则应沿着真实引用链分析：

回调或局部类对象
    → 捕获的引用
    → 外部实例引用
    → 外部实例持有的状态

静态嵌套类不会自动拥有外部实例，内部类通常会；匿名类和局部类虽然声明位置局部，但实例可以通过接口、父类、线程、监听器或缓存长期存活。理解这些差异后，创建方式、编译错误、内存保留和并发行为都可以从明确的语言规则与对象引用关系中推导出来。

---

系列导航与关联阅读

• 系列入口：Java 完整学习路线：从 Java 25 语言与 JVM 到 Spring、微服务和生产交付
• 上一篇：Java 25 Enum 深入：状态、策略、EnumSet、EnumMap 和持久化边界
• 下一篇：Java 25 不可变对象：防御复制、深浅不可变、线程安全和 Builder

官方资料

• Java SE 25 Documentation
• Java Language Specification

本文依据 Java、Spring 与相关项目官方文档重新梳理；正文、示例与生产清单由 WR BLOG 编写。