1. 概述

在 Java 中，嵌套类（Nested Class）是指定义在另一个类内部的类。根据定义方式和访问权限的不同，嵌套类可以分为静态嵌套类（Static Nested Class）和内部类（Inner Class）。内部类又进一步细分为成员内部类、局部内部类和匿名内部类。理解这些概念对于编写结构清晰、封装良好的 Java 代码至关重要。

2. 静态嵌套类

静态嵌套类使用 static 关键字修饰，它与外部类（Outer Class）相关联，但可以独立于外部类的实例而存在。

public class OuterClass {
    private static String outerStaticField = "Outer Static";

    // 静态嵌套类
    static class StaticNestedClass {
        void display() {
            // 可以访问外部类的静态成员
            System.out.println(outerStaticField);
        }
    }

    public static void main(String[] args) {
        // 创建静态嵌套类实例，无需外部类实例
        OuterClass.StaticNestedClass nestedObj = new OuterClass.StaticNestedClass();
        nestedObj.display(); // 输出: Outer Static
    }
}

特点：

• 可以访问外部类的所有静态成员（包括私有静态成员）。
• 不能直接访问外部类的非静态成员（需要先创建外部类实例）。
• 创建实例时不需要外部类实例。
• 常用于与外部类逻辑相关，但不需要外部类实例上下文的场景。

3. 成员内部类

成员内部类（非静态嵌套类）是最常见的内部类形式，它定义在外部类的成员位置，没有 static 修饰符。

public class OuterClass {
    private String outerField = "Outer Field";

    // 成员内部类
    class MemberInnerClass {
        void display() {
            // 可以直接访问外部类的实例成员
            System.out.println(outerField);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        // 创建内部类实例需要先有外部类实例
        OuterClass.MemberInnerClass innerObj = outer.new MemberInnerClass();
        innerObj.display(); // 输出: Outer Field
    }
}

特点：

• 可以访问外部类的所有成员（包括私有成员）。
• 每个内部类实例都隐式持有一个指向外部类实例的引用（OuterClass.this）。
• 创建实例必须先有外部类实例。
• 不能定义静态成员（除非是编译时常量）。

4. 局部内部类

局部内部类定义在方法、构造器或代码块内部，作用域仅限于所在的代码块。

public class OuterClass {
    public void outerMethod() {
        final String localVar = "Local Variable";

        // 局部内部类
        class LocalInnerClass {
            void display() {
                System.out.println(localVar); // 只能访问 final 或 effectively final 的局部变量
            }
        }

        LocalInnerClass localObj = new LocalInnerClass();
        localObj.display(); // 输出: Local Variable
    }
}

特点：

• 作用域仅限于定义它的代码块。
• 可以访问外部类的所有成员。
• 只能访问所在方法中声明为 final 或 effectively final 的局部变量。
• 不能使用访问修饰符（public、private、protected）。

5. 匿名内部类

匿名内部类是没有显式类名的局部内部类，通常用于实现接口或继承类，并立即创建实例。

public class OuterClass {
    public static void main(String[] args) {
        // 匿名内部类实现 Runnable 接口
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous inner class running");
            }
        };

        new Thread(runnable).start();

        // 匿名内部类继承 Thread 类
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread from anonymous class");
            }
        };
        thread.start();
    }
}

特点：

• 没有类名，只能使用一次。
• 必须继承一个类或实现一个接口。
• 不能定义构造器，但可以有实例初始化块。
• 常用于事件监听器、线程创建等一次性使用的场景。

6. 总结与对比

类型	定义位置	static 修饰	访问外部类成员	创建方式	典型用途
静态嵌套类	类成员位置	有	仅静态成员	new Outer.StaticNested()	工具类、与外部类逻辑相关但不依赖实例
成员内部类	类成员位置	无	所有成员	outer.new Inner()	紧密关联外部类状态，如迭代器
局部内部类	方法/代码块内	无	所有成员 + final 局部变量	在定义块内 new LocalInner()	方法内部专用辅助类
匿名内部类	方法/代码块内	无	所有成员 + final 局部变量	new Interface/Class(){...}	一次性回调、事件监听

7. 实际应用建议

• 优先考虑静态嵌套类：如果内部类不需要访问外部类实例成员，应声明为静态嵌套类，减少内存开销。
• 谨慎使用成员内部类：每个内部类实例都持有外部类引用，可能导致内存泄漏（如将内部类实例传递给长生命周期对象）。
• Lambda 替代匿名内部类：对于只有一个抽象方法的接口（函数式接口），优先使用 Lambda 表达式，代码更简洁。
• 注意序列化：内部类（非静态）包含隐式的外部类引用，序列化时可能带来意外问题。