Java 内部类有哪几种？为什么匿名内部类只能访问 final 变量？

简化版

Java 内部类分四种：成员内部类（普通非静态，持有外部类实例引用，能访问外部所有成员）、静态内部类（static，不持有外部实例，只能访问外部静态成员）、局部内部类（定义在方法里）、匿名内部类（没有名字、定义即用，常用于接口回调）。匿名/局部内部类访问方法里的局部变量时，那个变量必须是 final 或「事实上 final」（effectively final），因为内部类实例的生命周期可能比方法长，编译器是把局部变量复制一份给内部类的，若变量可变会造成「两份副本不一致」，所以强制它不可变。

详细版

四种内部类对比：

类型	是否持有外部类实例	能访问外部什么	典型用途
成员内部类	是（隐含 `Outer.this`）	外部所有成员（含私有）	与外部类紧密关联的辅助类
静态内部类	否	只能访问外部静态成员	不依赖外部实例的辅助类（如 Builder、Node）
局部内部类	是（在实例方法中）	外部成员 + 方法内 final 局部变量	方法内临时用的类
匿名内部类	是	外部成员 + 方法内 final 局部变量	接口/抽象类的一次性实现（回调、监听器）

public class Outer {
    private int a = 1;
    private static int b = 2;

    class Member { void f() { System.out.println(a + b); } }        // 成员：a、b 都能访问
    static class StaticInner { void f() { System.out.println(b); } } // 静态：只能访问 b

    void method() {
        int local = 3;   // 事实上 final
        // 匿名内部类：实现 Runnable
        Runnable r = new Runnable() {
            public void run() { System.out.println(a + local); }  // 能访问 a 和 final 的 local
        };
    }
}

为什么静态内部类常被推荐：成员内部类隐含持有外部类实例的引用（Outer.this），如果内部类实例被长期持有（如放进静态集合、作为回调），会导致外部类实例无法被 GC —— 内存泄漏。静态内部类不持有外部引用，没这个问题。所以「不需要访问外部实例成员时，优先用静态内部类」。

⚠️ Java 8 起局部变量只要「事实上 final」（赋值后不再改）就行，不用显式写 final 关键字。但本质没变——被内部类捕获的局部变量仍然不能在之后被修改，否则编译报错。

完整版教学

一、四种内部类的全景

内部类就是「定义在另一个类内部的类」，按位置和修饰符分四种，核心区别在是否持有外部类实例：

class Outer {
    class Member {}          // 成员内部类：非静态，绑定 Outer 的实例
    static class Nested {}    // 静态内部类：不绑定实例
    void m() {
        class Local {}        // 局部内部类：定义在方法内
        new Runnable(){...};  // 匿名内部类：无名，定义即实例化
    }
}

理解内部类的钥匙是一个问题：它需不需要「外部类的那个实例」？ 成员内部类、局部内部类、匿名内部类都是「非静态」的，它们隐含持有一个 Outer.this 引用，所以能访问外部实例的字段和方法；静态内部类不持有，所以只能碰外部的静态成员。这个「持不持有外部实例」的差异，决定了它们的能力边界和内存行为。

二、成员内部类：隐含的外部引用

成员内部类能直接访问外部类的所有成员（包括私有），秘密在于它编译后持有一个指向外部实例的引用：

class Outer {
    private int a = 1;
    class Member { void f() { print(a); } }
}
// 编译后 Member 近似：
class Outer$Member {
    final Outer this$0;                        // 隐含持有外部实例！
    Outer$Member(Outer outer) { this$0 = outer; }
    void f() { print(this$0.a); }              // 通过外部引用访问 a
}

所以创建成员内部类必须先有外部实例：outer.new Member()。而这个隐含引用正是双刃剑——它让内部类能访问外部成员，但也让内部类”拴住”了外部实例：只要内部类实例还活着，外部实例就不能被回收。这引出了静态内部类的价值。

三、静态内部类：为什么它更安全

静态内部类（static class）不持有外部实例引用，它和外部类只是「命名空间上的归属」，逻辑上独立：

static class StaticInner {
    void f() {
        // print(a);   // ✗ 编译错误，访问不了外部实例成员 a
        print(b);      // ✓ 只能访问外部静态成员 b
    }
}

《Effective Java》建议：如果内部类不需要访问外部类的实例成员，就把它声明为 static。原因是防内存泄漏——

非静态内部类持有 Outer.this：
  若把内部类实例放进一个长生命周期的地方（静态 Map、事件监听器、异步回调）
  → Outer 实例被内部类拴住，永远无法 GC → 内存泄漏

静态内部类不持有外部引用：
  内部类实例的生死和外部实例无关，不会拖累外部类回收

典型应用：HashMap.Node、各种 Builder 都是静态内部类——它们只是「归属于外部类的工具」，不需要外部实例。这是「优先用静态内部类」这条建议的根本原因。

四、匿名内部类：一次性的实现

匿名内部类没有名字，「定义即实例化」，专门用于「只用一次」的接口/抽象类实现：

// 传统匿名内部类（Java 8 前的回调标配）
button.addListener(new ClickListener() {
    public void onClick() { System.out.println("clicked"); }
});

// Lambda 是函数式接口匿名内部类的简写（Java 8+）
button.addListener(() -> System.out.println("clicked"));

它本质是「局部内部类 + 没有名字」，编译后生成 Outer$1.class 这样的匿名类文件。它同样是非静态的（在实例方法里时持有外部引用），能访问外部成员和方法里的 final 局部变量。Lambda 表达式对函数式接口（单抽象方法接口）是它的语法糖简写——但注意 Lambda 和匿名内部类的 this 含义不同：匿名内部类的 this 指自己，Lambda 的 this 指外部类。

五、核心考点：为什么只能访问 final 局部变量

这是本题最经典的追问。局部变量存在栈上，方法执行完就销毁；而内部类实例可能存在堆上，生命周期比方法更长。矛盾就来了：

void method() {
    int local = 3;
    Runnable r = () -> print(local);   // 内部类捕获了 local
    return r;   // 方法结束，栈上的 local 销毁了，但 r 还活着还要用 local！
}

方法返回后，栈帧销毁，local 没了，但内部类实例 r 还引用着它。JVM 的解决办法是：内部类不直接引用局部变量，而是在创建时把它「复制」一份存进自己的字段：

编译器实际做的：
  内部类 Outer$1 有个字段 val$local
  创建内部类时：val$local = local（复制一份值）
  内部类用的是自己的副本 val$local，不是原来的 local

既然是「复制」，就产生一个一致性问题：如果原 local 之后被改了，内部类里的副本却不会跟着变，两份值不一致，行为诡异。为杜绝这种混乱，Java 干脆规定：被内部类捕获的局部变量必须 final（或事实上 final）——你根本不能改它，也就不存在「两份副本不一致」的问题。这就是「只能访问 final 变量」的根本原因：用不可变来回避「值拷贝」带来的一致性隐患。

六、为什么访问外部实例字段不要求 final

一个容易忽略的对比：内部类访问外部类的字段（如成员内部类访问 a）不要求 final，只有访问方法里的局部变量才要求。为什么？

外部类字段 a：存在堆上（对象里），内部类通过 Outer.this.a 实时访问
  → 引用的是同一个对象的同一个字段，永远一致，改了也同步 → 不需要 final

方法局部变量 local：存在栈上，方法结束就没了
  → 内部类只能复制一份，复制就有一致性问题 → 必须 final

关键差异是存储位置：字段在堆上、可共享、实时同步；局部变量在栈上、会销毁、只能拷贝。所以规则不是「内部类访问的一切都要 final」，而是「只有会被销毁、只能靠拷贝的局部变量才要 final」。理解了这层，就不会把规则记混。

记忆钩子：「四种内部类看是否持有外部实例：成员/局部/匿名持有（能访问外部实例成员，但可能内存泄漏）、静态不持有（更安全，优先用）；匿名/局部访问局部变量要 final，因为局部变量在栈上会销毁、内部类只能拷贝一份、拷贝要求不可变以防不一致」。

七、常见误区与追问

误区：所有内部类都持有外部类引用。 只有非静态内部类（成员/局部/匿名）持有 Outer.this；静态内部类不持有，所以更安全、能防内存泄漏。
误区：内部类访问外部字段也要求 final。 只有访问方法里的局部变量才要求 final；访问外部实例字段（堆上、可共享）不要求。
误区：Java 8 后可以修改被捕获的局部变量了。 不能，只是不用显式写 final 关键字，但仍必须「事实上 final」（赋值后不再改），改了照样编译报错。
误区：匿名内部类和 Lambda 完全等价。 对函数式接口 Lambda 是匿名内部类的简写，但 this 语义不同（匿名类 this 指自己，Lambda 指外部类），且 Lambda 不生成额外 class 文件。
追问：为什么捕获的局部变量必须 final？ 局部变量在栈上、方法结束销毁，内部类生命周期更长只能复制一份；若变量可变会导致「原变量和副本不一致」，强制 final 回避这个问题。
追问：什么时候该用静态内部类？ 内部类不需要访问外部实例成员时，用静态内部类，避免隐含的外部引用导致外部实例无法 GC（内存泄漏），如 Builder、HashMap.Node。
追问：成员内部类怎么创建？ 必须依附外部实例：Outer.Member m = outer.new Member();——因为它持有 Outer.this，没有外部实例就没法构造。

八、加强记忆

Java 内部类分四种，钥匙是「是否持有外部类实例」：成员内部类（非静态，隐含持有 Outer.this，能访问外部所有成员含私有）、静态内部类（不持有外部实例，只能访问外部静态成员）、局部内部类（方法内定义）、匿名内部类（无名、定义即实例化，用于一次性回调）。非静态内部类因为持有外部引用，若被长生命周期对象持有会拖住外部实例无法 GC 造成内存泄漏，所以「不需要访问外部实例成员时优先用静态内部类」（Builder、HashMap.Node 都是）。最经典的考点是「匿名/局部内部类访问局部变量为何要 final」——局部变量在栈上、方法结束就销毁，而内部类实例生命周期更长，编译器只能把变量复制一份进内部类字段；一旦原变量可变，就会和副本不一致，所以强制 final 来回避。而访问外部字段不要求 final，因为字段在堆上可共享、实时同步。一句话「四类看是否持有外部实例、静态最安全、捕获局部变量要 final 因栈变量只能拷贝」。

简化版

详细版