#内部类分类与区别

class Outer {
    class Inner { }              // 1
    static class StaticInner { } // 2

    void method() {
        class LocalInner { }     // 3
        Runnable r = new Runnable() { // 4
            public void run() { }
        };
    }
}

class Outer {
    private int outerField = 10;

    // 成员内部类
    class Inner {
        private int innerField = 20;

        public void accessOuter() {
            // ✅ 内部类可以直接访问外部类的所有成员（包括 private）
            System.out.println(outerField);
            System.out.println(Outer.this.outerField); // 显式引用外部类 this
        }
    }
}

// 使用
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 通过外部类引用创建

class Outer {
    int outerData = 10;

    class Inner {
        int innerData = 20;

        // 编译器会生成：
        // final Outer this$0; // 隐式持有外部类引用

        void access() {
            // 编译器展开为：
            System.out.println(this$0.outerData);
        }
    }
}

class Outer {
    static int staticField = 10;

    // 静态内部类
    static class StaticInner {
        int innerData = 20;

        public void access() {
            // ✅ 可以访问外部类的静态成员
            System.out.println(staticField);
            // ❌ 不能访问外部类的实例成员
            // System.out.println(outerData); // 编译错误
        }
    }
}

// 使用
Outer.StaticInner inner = new Outer.StaticInner(); // 不需要外部类实例

class Outer {
    void method() {
        final int localVar = 10; // JDK 8 之前必须是 final

        class LocalInner {
            public void access() {
                // ✅ 可以访问方法的局部变量（JDK 8+ 不要求显式 final，但必须是 effectively final）
                System.out.println(localVar);
            }
        }

        LocalInner inner = new LocalInner();
        inner.access();
    }
}

// 常见用法：线程创建
Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
});
t.start();

// JDK 8+ Lambda 简化（Runnable 接口只有一个抽象方法）
Thread t2 = new Thread(() -> System.out.println("Running"));

// ❌ 匿名内部类不能有构造器
new MyClass() {
    // public MyClass() { } // 编译错误
    private int data = 0;
    @Override
    void method() { }
};

// ✅ 如果需要初始值，使用实例初始化块
new MyClass() {
    private int data;
    {
        // 实例初始化块，等价于构造器
        this.data = 10;
    }
};

// 匿名内部类实际上是在创建一个继承/实现某个类/接口的子类
// 以下两种写法等价：

// 匿名内部类
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// Lambda 表达式（JDK 8+，只适用于函数式接口）
Collections.sort(list, (a, b) -> a.compareTo(b));

class Outer {
    class Inner { }
    static class StaticInner { }
    void method() {
        class LocalInner { }
        Runnable r = new Runnable() { };
    }
}

// 编译后生成 5 个 class 文件：
// 1. Outer.class
// 2. Outer$Inner.class      （成员内部类）
// 3. Outer$StaticInner.class （静态内部类）
// 4. Outer$1LocalInner.class （局部内部类，编译器生成编号）
// 5. Outer$1.class          （匿名内部类）

// 局部内部类：有名字，可以重复使用
class LocalInner { }

// 匿名内部类：没有名字，一次性使用
new Runnable() { };