内部类

Java允许把类声明放进另一个类、接口或代码块，也允许在对象创建表达式中直接声明一个没有名称的类。嵌套把只服务于一个宿主的实现放在使用位置附近，同时仍保留类的字段、方法、继承与接口实现能力。

规范中的“嵌套类”与“内部类”不是同义词。嵌套类包含成员类、局部类和匿名类；内部类只包含其中没有显式或隐式static的类。因此，“静态内部类”这个常见说法并不准确，应该叫“静态嵌套类”。

成员内部类适合表示离不开某个外部对象的行为，例如迭代器需要直接读取所属集合的当前位置。静态嵌套类适合只在命名与可见性上属于宿主的类型，例如构建器、结果类型或私有实现。局部类和匿名类则把很小的实现限制在一个方法或表达式附近。

嵌套不等于继承，也不会自动产生封装边界。外部类与其嵌套类可以按Java访问规则互相访问private成员，但公开嵌套类型仍可能成为外部API。选择形式时要先确定类型的所有者、可见性和实例生命周期。

当实现只需要一个函数式接口的方法时，lambda往往比匿名类短。不过lambda不是匿名类：两者的this、可声明成员和适用目标不同。若这些差异会影响行为，就不能把两种写法机械互换。

编译器根据声明出现的位置和static状态决定类别，再根据词法作用域解析名称。关键不是大括号嵌套了几层，而是对象是否需要外围实例，以及局部名称是否被捕获。

下面的分类采用Java 25规范术语。成员类是外部类型的成员；局部类和匿名类不是任何包、类或接口的成员，即使它们写在方法或类体的词法范围内。

四种常见形式

成员枚举类、成员记录类以及接口的成员类都隐式为static，所以它们是嵌套类而不是内部类。局部枚举类与局部记录类也隐式为static。普通局部类和匿名类仍属于内部类，即使声明出现在静态上下文中。

匿名类通过类实例创建表达式或带类体的枚举常量隐式声明。它只能在该表达式中选择一个直接父类或直接父接口，不能显式声明构造器；需要初始化自身字段时可以使用字段初始化器或实例初始化块。

外围实例与名称解析

非静态成员内部类的对象带有一个 外围实例（enclosing instance） 。在外部类之外创建它时，语法中的outer.new Member()明确指定这个对象。静态嵌套类没有这条隐式对象关系，可以直接通过外部类型名创建。

内部类方法中的this指向内部类对象。需要指明词法外围对象时使用Outer.this；字段同名时，这个限定也能消除歧义。静态上下文没有外围this，所以在那里声明的局部类或匿名类虽然仍按规范归入内部类，却可能没有直接外围实例。

“静态嵌套类只能访问外部类的静态成员”是一种容易误导的简写。准确说法是：它没有隐式外部对象，因此不能直接使用外部实例成员；如果手中有外部对象引用，仍可通过该引用访问其成员，包括按语言规则可访问的private成员。

成员内部类也可以声明static字段、方法、成员类型和静态初始化块。这项限制已在Java 16放宽；static成员没有内部类对象的this，也没有可供使用的外围实例。

局部变量捕获

局部类和匿名类可以引用词法作用域中的局部变量、形参和异常参数，但这些变量必须是final或 实际final（effectively final） 。后者没有写出final，却满足加上final也不会引入编译错误的赋值约束。

这个规则限制的是变量重新赋值，不是对象状态。捕获的List变量不能再指向另一份列表，但内部类仍可调用add()修改原列表。用单元素数组绕过重新赋值限制虽然能编译，却常把状态所有权藏得更深。

捕获按需要发生。局部类没有引用某个局部名称时，不会因为处于同一方法就自动保留它。反过来，一个被捕获的名称可能指向很大的对象图，所以名称数量不能说明实际保留的数据大小。

编译器必须让内部类对象在原方法返回后仍能观察到规范要求的值。具体如何生成字段、构造器参数和类文件属于实现细节；应用代码不应依赖这些合成名称。

访问与类型所有权

成员类可以声明为public、protected、包级可见或private。局部类不能使用这些访问修饰符，它的名称只在对应代码块的作用域内可见；匿名类甚至没有可供其他声明引用的简单名称。

嵌套类能够访问宿主的私有成员，宿主也能访问嵌套类的私有成员。这种访问便利不应演变成随意共享状态。若一个辅助类型只需要构造时传入的两个值，显式参数通常比隐式读取整个外部对象更清楚。

泛型外部类的非静态成员内部类处于外部类型参数的作用域内。静态嵌套类不能直接使用外部类的类型参数；需要泛型时，它应声明自己的类型参数。这条差异常能暴露某个类型是否真的依赖外部实例。

下面三个示例依次展示成员形式、局部捕获，以及匿名类与lambda的this差异。所有输出均由本地OpenJDK 21.0.12使用javac --release 21 -Xlint:all编译后实际运行得到；所用语义在Java 25中保持有效。

成员内部类与静态嵌套类

Picker的标签天然属于某个仓库对象，所以它读取NestedKinds.this.warehouse。Snapshot自己接收所需数据，不依赖NestedKinds实例。

picker的创建表达式必须提供north，因此两者的生命周期存在对象级联系。snapshot的构造只包含显式参数；把它放在NestedKinds中表达的是命名和可见性，而不是实例所有权。

若Snapshot收到一个NestedKinds参数，它仍能读取该对象的私有字段。static取消的是隐式外围实例，不是同一嵌套范围中的私有访问权限。

让局部类与匿名类共享捕获状态

Recorder捕获tenant和events，返回的匿名Runnable又捕获recorder。两次audit()调用产生两组状态，而重复调用同一个结果会继续修改原列表。

import java.util.ArrayList;
import java.util.List;

public class LocalAndAnonymous {
    static Runnable audit(String tenant) {
        List<String> events = new ArrayList<>();

        class Recorder {
            void add(String action) {
                events.add(tenant + ":" + action);
            }

            String summary() {
                return String.join(" | ", events);
            }
        }

        Recorder recorder = new Recorder();
        recorder.add("created");

        return new Runnable() {
            @Override
            public void run() {
                recorder.add("sent");
                System.out.println(recorder.summary());
            }
        };
    }

    public static void main(String[] args) {
        Runnable north = audit("north");
        Runnable south = audit("south");
        north.run();
        south.run();
        north.run();
    }
}

north:created | north:sent
south:created | south:sent
north:created | north:sent | north:sent

events和recorder都没有被重新赋值，所以符合实际final规则；events.add()修改的是对象内容。若取消注释一条events = new ArrayList<>()，即使赋值写在创建内部类之后，名称也不再是实际final，编译器会拒绝捕获。

示例没有任何LocalAndAnonymous实例，因为audit()是静态方法。这也说明捕获局部变量与持有外部类对象是两条不同关系。代码审查时应分别追踪它们。

比较匿名类与lambda中的this

匿名类建立新的对象作用域，所以它的this.owner是自身字段；lambda不引入新的this，其中的this.owner仍指向ThisBinding对象。

public class ThisBinding {
    private final String owner = "enclosing";

    void compare() {
        Runnable anonymous = new Runnable() {
            private final String owner = "anonymous";

            @Override
            public void run() {
                System.out.println("anonymous this: " + this.owner);
                System.out.println("outer this: " + ThisBinding.this.owner);
            }
        };

        Runnable lambda =
                () -> System.out.println("lambda this: " + this.owner);

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

    public static void main(String[] args) {
        new ThisBinding().compare();
    }
}

anonymous this: anonymous
outer this: enclosing
lambda this: enclosing

匿名类（anonymous class） 还可以声明字段、额外方法和实例初始化块，并且可以继承普通类。lambda只能以函数式接口为目标；若匿名类依赖自身this或额外状态，改成lambda前必须重新设计这些语义。

在内部类中声明静态成员

Formatter是非静态成员内部类，却合法声明了静态字段和静态方法。两个内部对象共享created，而实例方法label()仍通过外围实例读取prefix。

public class InnerStatics {
    private final String prefix;

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

    class Formatter {
        private static int created;

        Formatter() {
            created++;
        }

        static int created() {
            return created;
        }

        String label(int id) {
            return prefix + id;
        }
    }

    public static void main(String[] args) {
        var owner = new InnerStatics("A-");
        var first = owner.new Formatter();
        owner.new Formatter();

        System.out.println(InnerStatics.Formatter.created());
        System.out.println(first.label(7));
    }
}

2
A-7

静态方法通过InnerStatics.Formatter.created()调用，不需要Formatter对象或InnerStatics对象。它也不能直接读取prefix；实例方法拥有内部对象及其外围实例，才可以进行未限定访问。

这个示例在本地使用--release 21编译通过，没有依赖Java 25新增语法。若项目仍以Java 15或更早版本为源码目标，同一声明会因旧规则而失败。

把所有嵌套形式都叫内部类

修复方法： 先用“嵌套类”概括全部形式，再区分是否为内部类。明确写出成员、局部或匿名，以及显式或隐式static，不要只凭文件名中的$推断源码类别。

为不相关的辅助类保留外围实例

修复方法： 辅助类不需要隐式实例成员时，把它声明为static嵌套类，并通过构造器传入真正需要的数据。确实需要外围状态的回调要有明确的注销或取消路径，并用生命周期测试确认释放边界。

用可变容器绕过实际final

修复方法： 先确定状态属于哪个对象和哪个并发边界。需要多个操作或不变量时，把状态放进命名良好的类；只有契约确实要求跨线程原子计数时才使用原子类，并测试完整的复合操作。

把匿名类机械改成lambda

修复方法： 检查目标类型、重载选择、this和Outer.this、对象身份，以及额外成员是否参与行为。确认只需要一个函数式接口操作后再转换，并运行覆盖回调注册与调用时机的测试。

依赖编译器生成的二进制名称

修复方法： 需要稳定标识的类型应拥有正式名称和公开契约。诊断时可以用javap查看当前构建，生产逻辑则通过接口、显式注册和受控序列化格式定位行为。

沿用Java 16之前的静态成员规则

修复方法： 按项目的--release目标核对语言规则。静态成员现在合法，但其代码处于静态上下文，不能借此访问内部类对象或外围实例的this。

• Java语言规范25：内部类与外围实例
• Java语言规范25：局部类与局部接口声明
• Java语言规范25：匿名类声明
• Java语言规范25：简单表达式名称与捕获限制
• Java虚拟机规范25：NestHost属性