内部类

// 外部类
public class Outer {
 
    // 外部类的私有成员变量
    private String name = "Outer";
 
    // 外部类的私有方法
    private void outerMethod() {
        System.out.println("外部类的方法被调用");
    }
 
    // ========== 成员内部类 ==========
    // 没有 static 修饰，所以它是"成员内部类"而非"静态内部类"
    public class Inner {
 
        // 内部类自己的成员变量
        private String innerName = "Inner";
 
        public void display() {
            // 直接访问外部类的 private 成员变量 —— 这是内部类的核心特权
            System.out.println("外部类的 name = " + name);
            // 直接调用外部类的 private 方法
            outerMethod();
            // 访问自己的成员
            System.out.println("内部类的 innerName = " + innerName);
        }
    }
}

public class Main {
    public static void main(String[] args) {
 
        // 第一步：创建外部类实例
        Outer outer = new Outer();
 
        // 第二步：通过外部类实例来创建内部类实例
        // 语法：外部类实例.new 内部类构造器()
        Outer.Inner inner = outer.new Inner();
 
        // 调用内部类方法
        inner.display();
    }
}

public class Outer {
    private int x = 10;
 
    public class Inner {
        public void printX() {
            // 访问外部类的 x
            System.out.println(x);
        }
    }
}

// 编译器生成的等价代码（伪代码，帮助理解）
class Outer$Inner {
 
    // 编译器自动添加的字段：指向外部类实例的引用
    final Outer this$0;
 
    // 编译器修改后的构造器：多了一个 Outer 类型的参数
    Outer$Inner(Outer outer) {
        this.this$0 = outer; // 将外部类引用保存下来
    }
 
    public void printX() {
        // 通过 this$0 访问外部类的字段
        // 编译器还会生成一个合成的 access 方法来绕过 private 限制
        System.out.println(this$0.x);
    }
}

public class Outer {
 
    // 外部类的 name
    private String name = "Outer";
 
    public class Inner {
 
        // 内部类也有一个同名的 name
        private String name = "Inner";
 
        public void showNames() {
            // 局部变量 name
            String name = "Local";
 
            // 访问局部变量 —— 就近原则，直接用 name
            System.out.println("局部变量: " + name);           // Local
 
            // 访问内部类自己的成员变量 —— 用 this.name
            System.out.println("内部类成员: " + this.name);     // Inner
 
            // 访问外部类的成员变量 —— 用 Outer.this.name
            System.out.println("外部类成员: " + Outer.this.name); // Outer
        }
    }
}

public class Outer {
 
    // public 内部类：任何地方都能访问
    public class PublicInner { }
 
    // protected 内部类：同包 + 子类可访问
    protected class ProtectedInner { }
 
    // 默认（包级私有）内部类：仅同包可访问
    class DefaultInner { }
 
    // private 内部类：仅外部类自身可访问
    // 这是最常见的封装方式 —— 对外完全隐藏实现细节
    private class PrivateInner {
        void doWork() {
            System.out.println("只有 Outer 知道我的存在");
        }
    }
 
    // 外部类内部可以自由使用 private 内部类
    public void usePrivateInner() {
        PrivateInner pi = new PrivateInner();
        pi.doWork();
    }
}

public class Outer {
    public class Inner {
        // ❌ 编译错误（Java 16 之前）：成员内部类中不能有 static 字段
        // static int count = 0;
 
        // ✅ 但可以有 static final 的编译期常量（因为常量在编译期就确定了）
        static final int MAX = 100;
 
        // ❌ 编译错误（Java 16 之前）：不能有 static 方法
        // static void staticMethod() { }
    }
}

// ⚠️ 反面示例：这段代码会导致 Activity 内存泄漏！
public class MainActivity extends Activity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        // 创建一个成员内部类的匿名子类实例，作为 Runnable 投递到主线程消息队列
        // 这个 Runnable 会在 10 秒后执行
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                // 这个匿名内部类隐式持有 MainActivity.this 的引用
                System.out.println("延迟任务执行");
            }
        }, 10_000); // 延迟 10 秒
    }
}

GC Root (主线程)
  └── Looper
        └── MessageQueue
              └── Message
                    └── Runnable (匿名内部类实例)
                          └── this$0 ━━▶ MainActivity 实例 ← 无法回收！
                                            ├── View 树
                                            ├── Bitmap 资源
                                            └── 其他大对象...

public class MainActivity extends Activity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        // 使用静态内部类，不会隐式持有外部类引用
        new Handler().postDelayed(new SafeRunnable(this), 10_000);
    }
 
    // 静态内部类：不持有 MainActivity 的隐式引用
    private static class SafeRunnable implements Runnable {
 
        // 用 WeakReference 弱引用外部类实例
        // 当 GC 发现对象只被 WeakReference 引用时，会直接回收它
        private final WeakReference<MainActivity> activityRef;
 
        SafeRunnable(MainActivity activity) {
            this.activityRef = new WeakReference<>(activity);
        }
 
        @Override
        public void run() {
            // 从弱引用中尝试获取 Activity
            MainActivity activity = activityRef.get();
 
            // 如果 Activity 已经被回收，get() 返回 null，安全退出
            if (activity != null && !activity.isDestroyed()) {
                System.out.println("安全地执行延迟任务");
            }
            // 如果 activity == null，说明已被 GC 回收，什么都不做
        }
    }
}

public class MainActivity extends Activity {
 
    // 持有 Handler 引用，以便后续清理
    private final Handler handler = new Handler();
 
    // 持有 Runnable 引用
    private final Runnable task = new Runnable() {
        @Override
        public void run() {
            System.out.println("延迟任务执行");
        }
    };
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        handler.postDelayed(task, 10_000);
    }
 
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Activity 销毁时，移除所有待执行的回调
        // 这样 MessageQueue 中就不再持有 Runnable 的引用
        handler.removeCallbacks(task);
    }
}

public class SimpleList<E> {
 
    // 底层数组存储元素
    private Object[] elements;
    // 当前元素个数
    private int size;
 
    // 返回迭代器 —— 对外暴露 Iterator 接口，隐藏实现细节
    public Iterator<E> iterator() {
        return new ListIterator();
    }
 
    // 成员内部类实现迭代器
    // 这里使用成员内部类是合理的，因为：
    // 1. 迭代器需要访问外部类的 private 字段（elements, size）
    // 2. 迭代器的生命周期不会超过 List 本身
    private class ListIterator implements Iterator<E> {
 
        // 当前遍历的索引位置
        private int cursor = 0;
 
        @Override
        public boolean hasNext() {
            // 直接访问外部类的 size 字段
            return cursor < size;
        }
 
        @Override
        @SuppressWarnings("unchecked")
        public E next() {
            // 直接访问外部类的 elements 数组
            if (cursor >= size) {
                throw new NoSuchElementException();
            }
            return (E) elements[cursor++];
        }
    }
}

public class Outer {
    private int x = 5;
 
    class Inner {
        private int x = 10;
 
        void display() {
            int x = 15;
            System.out.println(x);
            System.out.println(this.x);
            System.out.println(Outer.this.x);
        }
    }
 
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.display();
    }
}

// 静态内部类的基本声明
public class Outer {
    // 外部类的实例字段
    private int instanceField = 10;
    // 外部类的静态字段
    private static int staticField = 20;
 
    // 使用 static 修饰 —— 这就是静态内部类
    static class Inner {
        void display() {
            // ✅ 可以访问外部类的静态成员（包括 private）
            System.out.println("静态字段: " + staticField);
 
            // ❌ 编译错误！不能直接访问外部类的实例成员
            // System.out.println(instanceField);
            // 因为没有 Outer.this 引用，根本不知道是"哪个"外部实例
        }
    }
}

public class ReferenceDemo {
    private int x = 1;
    private static int y = 2;
 
    // 成员内部类 —— 编译后构造器签名: MemberInner(ReferenceDemo outer)
    class MemberInner {
        void access() {
            System.out.println(x); // ✅ 通过隐式 Outer.this 访问
            System.out.println(y); // ✅ 静态成员当然也能访问
        }
    }
 
    // 静态内部类 —— 编译后构造器签名: StaticInner()，干干净净
    static class StaticInner {
        void access() {
            // System.out.println(x); // ❌ 编译错误，没有外部实例引用
            System.out.println(y);    // ✅ 只能访问静态成员
        }
 
        // 如果确实需要访问外部实例成员，必须显式传入
        void accessWithInstance(ReferenceDemo outer) {
            System.out.println(outer.x); // ✅ 显式传入，意图清晰
        }
    }
}

public class InstantiationDemo {
 
    class MemberInner { }
    static class StaticInner { }
 
    public static void main(String[] args) {
        // 成员内部类：必须先有外部类实例，语法也比较"怪异"
        InstantiationDemo outer = new InstantiationDemo();
        MemberInner mi = outer.new MemberInner(); // outer.new 语法
 
        // 静态内部类：直接 new，像普通类一样自然
        StaticInner si = new StaticInner();        // 在同一个外部类内部
        InstantiationDemo.StaticInner si2 = new InstantiationDemo.StaticInner(); // 在外部使用
    }
}

public class MemberTypeDemo {
 
    // 成员内部类
    class MemberInner {
        int instanceField = 1;           // ✅ 实例字段
        // static int staticField = 2;   // ❌ 不允许声明静态字段（Java 16 之前）
        // static void staticMethod() {} // ❌ 不允许声明静态方法（Java 16 之前）
        static final int CONSTANT = 3;   // ✅ 编译期常量例外
    }
 
    // 静态内部类 —— 没有任何限制
    static class StaticInner {
        int instanceField = 1;           // ✅ 实例字段
        static int staticField = 2;      // ✅ 静态字段
        static void staticMethod() {}    // ✅ 静态方法
 
        // 甚至可以嵌套更多内部类
        static class DeepNested { }      // ✅ 继续嵌套
    }
}

Outer.class
Outer$StaticInner.class

// 成员内部类的构造器（反编译结果）
// class Outer$MemberInner {
//     final Outer this$0;                    // 编译器生成的字段，存储外部引用
//     Outer$MemberInner(Outer outer) {       // 构造器接收外部实例
//         this.this$0 = outer;               // 保存引用
//         super();
//     }
// }
 
// 静态内部类的构造器（反编译结果）
// class Outer$StaticInner {
//     Outer$StaticInner() {                  // 无额外参数，干干净净
//         super();
//     }
// }

// ===== 成员内部类的内存布局 =====
//
//  Heap（堆内存）
//  ┌─────────────────────┐     ┌─────────────────────────┐
//  │   Outer 实例         │     │   MemberInner 实例       │
//  │  ┌───────────────┐  │     │  ┌─────────────────────┐ │
//  │  │ instanceField  │  │◄────│──│ this$0 (外部类引用)  │ │
//  │  │ staticField    │  │     │  │ innerField           │ │
//  │  └───────────────┘  │     │  └─────────────────────┘ │
//  └─────────────────────┘     └─────────────────────────┘
//         ▲                              │
//         └──────── 强引用 ──────────────┘
//
// ===== 静态内部类的内存布局 =====
//
//  Heap（堆内存）
//  ┌─────────────────────┐     ┌─────────────────────────┐
//  │   Outer 实例         │     │   StaticInner 实例       │
//  │  ┌───────────────┐  │     │  ┌─────────────────────┐ │
//  │  │ instanceField  │  │     │  │ innerField           │ │
//  │  │ staticField    │  │     │  │ （无 this$0 字段）    │ │
//  │  └───────────────┘  │     │  └─────────────────────┘ │
//  └─────────────────────┘     └─────────────────────────┘
//         ↑                              ↑
//         │        彼此独立，无引用关系      │
//         └──────────── ✕ ──────────────┘

public class MyActivity extends Activity {
 
    // ❌ 危险：成员内部类持有 Activity 引用
    // 如果 Handler 中有延迟消息，Activity 无法被 GC 回收
    class LeakyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            // 隐式持有 MyActivity.this
        }
    }
 
    // ✅ 安全：静态内部类不持有 Activity 引用
    static class SafeHandler extends Handler {
        // 如果需要访问 Activity，使用 WeakReference
        private final WeakReference<MyActivity> activityRef;
 
        SafeHandler(MyActivity activity) {
            this.activityRef = new WeakReference<>(activity); // 弱引用，不阻止 GC
        }
 
        @Override
        public void handleMessage(Message msg) {
            MyActivity activity = activityRef.get(); // 尝试获取
            if (activity != null && !activity.isFinishing()) {
                // 安全地使用 activity
                activity.updateUI(msg);
            }
            // 如果 activity 已被回收，get() 返回 null，优雅降级
        }
    }
}

// HashMap 的 Node 就是静态内部类 —— 这是经过深思熟虑的设计
// 一个 HashMap 可能包含数百万个 Node，如果每个都多存一个外部引用，浪费巨大
public class HashMap<K, V> {
    // static！因为 Node 不需要访问 HashMap 的实例方法
    static class Node<K, V> implements Map.Entry<K, V> {
        final int hash;    // 哈希值
        final K key;       // 键
        V value;           // 值
        Node<K, V> next;   // 链表下一个节点
        // 没有 HashMap.this 引用，节省内存
    }
}

public class HttpRequest {
    // 所有字段都是 final，对象不可变
    private final String url;          // 请求地址
    private final String method;       // 请求方法
    private final Map<String, String> headers; // 请求头
    private final String body;         // 请求体
    private final int timeout;         // 超时时间（毫秒）
 
    // 私有构造器，只能通过 Builder 创建
    private HttpRequest(Builder builder) {
        this.url = builder.url;
        this.method = builder.method;
        this.headers = Collections.unmodifiableMap(new HashMap<>(builder.headers));
        this.body = builder.body;
        this.timeout = builder.timeout;
    }
 
    // Getter 方法（省略）...
    public String getUrl() { return url; }
    public String getMethod() { return method; }
 
    // 静态内部类 Builder —— 不需要访问 HttpRequest 的实例成员
    public static class Builder {
        // 必填参数
        private final String url;
        // 可选参数，提供默认值
        private String method = "GET";
        private Map<String, String> headers = new HashMap<>();
        private String body = "";
        private int timeout = 30000; // 默认 30 秒
 
        // Builder 构造器只接收必填参数
        public Builder(String url) {
            this.url = Objects.requireNonNull(url, "URL must not be null");
        }
 
        // 每个 setter 返回 this，支持链式调用
        public Builder method(String method) {
            this.method = method;
            return this; // 返回自身，实现 fluent API
        }
 
        public Builder addHeader(String key, String value) {
            this.headers.put(key, value);
            return this;
        }
 
        public Builder body(String body) {
            this.body = body;
            return this;
        }
 
        public Builder timeout(int timeout) {
            if (timeout <= 0) {
                throw new IllegalArgumentException("Timeout must be positive");
            }
            this.timeout = timeout;
            return this;
        }
 
        // 最终构建方法
        public HttpRequest build() {
            return new HttpRequest(this); // 将 Builder 自身传给私有构造器
        }
    }
}

// 链式调用，可读性极佳
HttpRequest request = new HttpRequest.Builder("https://api.example.com/users")
        .method("POST")                          // 设置方法
        .addHeader("Content-Type", "application/json") // 添加请求头
        .addHeader("Authorization", "Bearer token123") // 添加认证头
        .body("{\"name\": \"Kiro\"}")             // 设置请求体
        .timeout(5000)                            // 设置超时
        .build();                                 // 构建不可变对象

// LinkedList 的节点 —— 静态内部类
public class LinkedList<E> {
    // Node 不需要访问 LinkedList 的实例方法
    // 它只是一个纯粹的数据容器
    private static class Node<E> {
        E item;        // 存储的元素
        Node<E> next;  // 后继节点
        Node<E> prev;  // 前驱节点
 
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
 
    // LinkedList 的实例字段
    transient int size = 0;
    transient Node<E> first; // 头节点
    transient Node<E> last;  // 尾节点
}

public class MathUtils {
 
    // 除法结果：商和余数，只在 MathUtils 的语境下有意义
    public static class DivisionResult {
        private final int quotient;   // 商
        private final int remainder;  // 余数
 
        public DivisionResult(int quotient, int remainder) {
            this.quotient = quotient;
            this.remainder = remainder;
        }
 
        public int getQuotient() { return quotient; }
        public int getRemainder() { return remainder; }
 
        @Override
        public String toString() {
            return quotient + " 余 " + remainder;
        }
    }
 
    // 返回封装好的结果对象
    public static DivisionResult divide(int dividend, int divisor) {
        if (divisor == 0) {
            throw new ArithmeticException("除数不能为零");
        }
        return new DivisionResult(dividend / divisor, dividend % divisor);
    }
}

// 使用
MathUtils.DivisionResult result = MathUtils.divide(17, 5);
System.out.println("商: " + result.getQuotient());   // 商: 3
System.out.println("余数: " + result.getRemainder()); // 余数: 2

public class Singleton {
 
    // 私有构造器，防止外部 new
    private Singleton() {
        System.out.println("Singleton 实例被创建");
    }
 
    // 静态内部类 —— JVM 保证类加载的线程安全性
    private static class Holder {
        // 类加载时初始化，由 JVM 保证只执行一次且线程安全
        static final Singleton INSTANCE = new Singleton();
    }
 
    // 对外暴露的获取方法
    public static Singleton getInstance() {
        return Holder.INSTANCE; // 第一次调用时才会触发 Holder 类的加载
    }
}

public class AccessDemo {
    // 外部类的各种成员
    private int privateInstance = 1;          // 私有实例字段
    private static int privateStatic = 2;     // 私有静态字段
    protected int protectedInstance = 3;      // 受保护实例字段
    int packageInstance = 4;                  // 包级实例字段
 
    private void privateMethod() {            // 私有实例方法
        System.out.println("private method");
    }
 
    private static void privateStaticMethod() { // 私有静态方法
        System.out.println("private static method");
    }
 
    static class StaticInner {
        void test() {
            // ✅ 可以访问外部类的 private static 成员
            System.out.println(privateStatic);
            privateStaticMethod();
 
            // ❌ 不能直接访问外部类的实例成员（无论什么访问修饰符）
            // System.out.println(privateInstance);   // 编译错误
            // System.out.println(protectedInstance);  // 编译错误
            // privateMethod();                        // 编译错误
        }
 
        void testWithInstance() {
            // ✅ 但如果你有外部类的实例，就可以访问它的 private 成员！
            AccessDemo outer = new AccessDemo();
            System.out.println(outer.privateInstance);  // ✅ 可以！
            System.out.println(outer.protectedInstance); // ✅ 可以！
            outer.privateMethod();                       // ✅ 可以！
            // 这就是"内部类特权"——同一个顶层类内部，private 不设防
        }
    }
}

public class BidirectionalAccess {
    static class Inner {
        private int secret = 42; // 私有字段
    }
 
    void accessInnerSecret() {
        Inner inner = new Inner();
        System.out.println(inner.secret); // ✅ 外部类可以访问内部类的 private
    }
}

public class ModifierDemo {
    // public —— 任何地方都可以使用 ModifierDemo.PublicInner
    public static class PublicInner { }
 
    // protected —— 同包 + 子类可以使用
    protected static class ProtectedInner { }
 
    // 包级（默认）—— 只有同包可以使用
    static class PackageInner { }
 
    // private —— 只有 ModifierDemo 自身可以使用
    // 最常见的选择！用于封装内部实现细节
    private static class PrivateInner { }
}

// ✅ 静态内部类：Map.Entry
// 理由：Entry 在概念上从属于 Map，离开 Map 谈 Entry 没有意义
// 且名字太通用，作为顶层类会造成命名冲突
Map.Entry<String, Integer> entry = ...;
 
// ✅ 静态内部类：Thread.State
// 理由：State 枚举只描述线程的状态，从属于 Thread
Thread.State state = Thread.State.RUNNABLE;
 
// ✅ 顶层类：ArrayList
// 理由：ArrayList 是一个独立的数据结构概念，被无数类使用
// 不从属于任何特定的类
List<String> list = new ArrayList<>();
 
// ✅ 顶层类：String
// 理由：String 是 Java 中最基础的类型之一，完全独立
String s = "hello";

public interface Converter<F, T> {
 
    T convert(F from); // 接口方法
 
    // 这个内部类隐式就是 static 的
    // 写不写 static 效果完全一样
    class Identity<T> implements Converter<T, T> {
        @Override
        public T convert(T from) {
            return from; // 原样返回，恒等转换
        }
    }
 
    // 同样，接口中的内部接口也是隐式 static 的
    interface Factory<T> {
        T create();
    }
}

// 使用接口中的静态内部类
Converter<String, String> identity = new Converter.Identity<>();
String result = identity.convert("hello"); // "hello"

public class Container<T> {
 
    private T value;
 
    // 成员内部类 —— 可以直接使用外部类的泛型参数 T
    class MemberIterator {
        T getCurrent() {
            return value; // ✅ 直接使用外部类的 T
        }
    }
 
    // 静态内部类 —— 不能使用外部类的 T
    static class StaticPair<A, B> {
        // T getFirst() { ... } // ❌ 编译错误！T 是外部类的泛型参数
        private A first;   // ✅ 使用自己声明的泛型参数
        private B second;  // ✅
 
        StaticPair(A first, B second) {
            this.first = first;
            this.second = second;
        }
 
        A getFirst() { return first; }
        B getSecond() { return second; }
    }
}

// 静态内部类的泛型独立于外部类
Container<String> container = new Container<>();
 
// StaticPair 的泛型参数和 Container 的 T 完全无关
Container.StaticPair<Integer, Double> pair = new Container.StaticPair<>(1, 2.0);

public class SimpleLinkedList<E> {
 
    // 静态内部类：链表节点
    // 使用 static 因为 Node 不需要访问 SimpleLinkedList 的实例方法
    // 它只是一个纯粹的数据载体
    private static class Node<E> {
        E data;          // 节点存储的数据
        Node<E> next;    // 指向下一个节点的引用
 
        Node(E data, Node<E> next) {
            this.data = data;  // 初始化数据
            this.next = next;  // 初始化后继指针
        }
    }
 
    private Node<E> head; // 头节点引用
    private int size;     // 链表长度
 
    // 在头部插入元素 —— O(1)
    public void addFirst(E element) {
        // 新节点的 next 指向当前头节点，然后新节点成为新的头
        head = new Node<>(element, head);
        size++; // 长度加一
    }
 
    // 获取指定位置的元素 —— O(n)
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException(
                "Index: " + index + ", Size: " + size
            );
        }
        Node<E> current = head;       // 从头节点开始
        for (int i = 0; i < index; i++) {
            current = current.next;    // 逐个向后移动
        }
        return current.data;           // 返回目标节点的数据
    }
 
    // 删除头部元素 —— O(1)
    public E removeFirst() {
        if (head == null) {
            throw new NoSuchElementException("链表为空");
        }
        E data = head.data;    // 保存头节点数据
        head = head.next;      // 头指针后移
        size--;                // 长度减一
        return data;           // 返回被删除的数据
    }
 
    // 获取链表长度
    public int size() {
        return size;
    }
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        Node<E> current = head;
        while (current != null) {
            sb.append(current.data);           // 追加当前节点数据
            if (current.next != null) {
                sb.append(" -> ");             // 节点之间用箭头分隔
            }
            current = current.next;            // 移动到下一个节点
        }
        sb.append("]");
        return sb.toString();
    }
}

// 使用示例
SimpleLinkedList<String> list = new SimpleLinkedList<>();
list.addFirst("C");    // [C]
list.addFirst("B");    // [B -> C]
list.addFirst("A");    // [A -> B -> C]
 
System.out.println(list);          // [A -> B -> C]
System.out.println(list.get(1));   // B
System.out.println(list.size());   // 3
 
list.removeFirst();                // 移除 A
System.out.println(list);          // [B -> C]

public class Outer {
    private static int count = 0;
 
    static class Inner {
        Inner() { count++; }
        int getCount() { return count; }
    }
 
    public static void main(String[] args) {
        Inner a = new Inner();
        Inner b = new Inner();
        Inner c = new Outer.Inner();
        System.out.println(c.getCount());
    }
}

public class Outer {
 
    // ① 定义在普通方法中（最常见的形式）
    public void doSomething() {
        // 局部内部类，作用域仅限于 doSomething() 方法体内
        class LocalHelper {
            void help() {
                System.out.println("I'm helping inside doSomething()");
            }
        }
        // 在方法内部实例化并使用
        LocalHelper helper = new LocalHelper();
        helper.help();
    }
 
    // ② 定义在静态方法中
    public static void staticMethod() {
        // 静态方法中的局部内部类，不持有外部类实例引用
        class StaticLocalHelper {
            void assist() {
                System.out.println("I'm inside a static method");
            }
        }
        new StaticLocalHelper().assist();
    }
 
    // ③ 定义在构造器中
    public Outer() {
        class ConstructorHelper {
            void init() {
                System.out.println("Helping during construction");
            }
        }
        new ConstructorHelper().init();
    }
 
    // ④ 定义在初始化块中
    {
        class InitBlockHelper {
            void setup() {
                System.out.println("Helping in instance initializer");
            }
        }
        new InitBlockHelper().setup();
    }
}

public class AccessRuleDemo {
 
    // 外部类的实例字段
    private String outerField = "外部类实例字段";
    // 外部类的静态字段
    private static String outerStaticField = "外部类静态字段";
 
    public void demonstrate(final String param) {
        // 方法的局部变量（effectively final）
        String localVar = "局部变量";
        // 可变的局部变量
        int counter = 0;
 
        class LocalInner {
            void showAccess() {
                // ✅ 可以访问外部类的实例字段（包括 private）
                System.out.println(outerField);
 
                // ✅ 可以访问外部类的静态字段
                System.out.println(outerStaticField);
 
                // ✅ 可以访问 final 或 effectively final 的方法参数
                System.out.println(param);
 
                // ✅ 可以访问 effectively final 的局部变量
                System.out.println(localVar);
 
                // ❌ 不能访问非 effectively final 的局部变量
                // System.out.println(counter); // 编译错误！
            }
        }
 
        // counter 在这里被修改，导致它不是 effectively final
        counter++;
 
        new LocalInner().showAccess();
    }
}

// 你写的代码
public void example() {
    final String msg = "hello";
    class Local {
        void print() { System.out.println(msg); }
    }
}
 
// 编译器实际生成的内部类（反编译后的等价形式）
class Outer$1Local {
    // 编译器自动生成的字段，保存捕获的变量副本
    final String val$msg;
    // 编译器自动生成的字段，保存外部类引用
    final Outer this$0;
 
    // 编译器生成的构造器，接收外部类引用和捕获的变量
    Outer$1Local(Outer outer, String msg) {
        this.this$0 = outer;
        this.val$msg = msg;
    }
 
    void print() {
        // 实际访问的是 val$msg 这个副本，而非栈上的原始变量
        System.out.println(this.val$msg);
    }
}

// ===== 方法执行时的内存布局 =====
//
//   栈 (Stack)                          堆 (Heap)
//  ┌─────────────────┐
//  │  example() 栈帧  │
//  │                 │               ┌──────────────────────┐
//  │  msg = "hello"  │──── 拷贝 ───▶│  Outer$1Local 实例    │
//  │                 │               │                      │
//  │  local (ref) ───│──────────────▶│  val$msg = "hello"   │
//  │                 │               │  this$0 = outer_ref  │
//  └─────────────────┘               └──────────────────────┘
//                                              │
//  方法结束后栈帧销毁，                          │ 对象可能仍然存活
//  但 msg 的值已被安全拷贝                       ▼
//  到堆上的 val$msg 中               （通过接口引用被外部持有）

public void method() {
    // ❌ 不能使用 public / protected / private 访问修饰符
    // 因为局部内部类的作用域已经被方法体天然限制了，访问修饰符毫无意义
    // public class WrongLocal {}   // 编译错误
 
    // ❌ 不能使用 static 修饰符（Java 16 之前）
    // 局部内部类依附于方法的执行上下文，static 与此矛盾
    // static class WrongLocal {}   // 编译错误（Java 15 及以下）
 
    // ✅ 可以使用 abstract 修饰符
    abstract class AbstractLocal {
        abstract void doWork();
    }
 
    // ✅ 可以使用 final 修饰符
    final class FinalLocal {
        void doWork() {
            System.out.println("I'm final, cannot be subclassed");
        }
    }
 
    // ✅ abstract 的局部类可以被同一方法内的另一个局部类继承
    class ConcreteLocal extends AbstractLocal {
        @Override
        void doWork() {
            System.out.println("Concrete implementation");
        }
    }
}

public class IteratorFactory {
 
    /**
     * 返回一个自定义的整数范围迭代器
     * 调用者只知道返回的是 Iterator〈Integer〉，完全不知道内部实现类的存在
     */
    public static Iterator<Integer> rangeIterator(int start, int end) {
        // 局部内部类：实现细节完全封装在方法内部
        class RangeIterator implements Iterator<Integer> {
            // 当前游标位置
            private int cursor = start;
 
            @Override
            public boolean hasNext() {
                // 判断游标是否还未到达终点
                return cursor < end;
            }
 
            @Override
            public Integer next() {
                // 如果没有下一个元素，抛出异常
                if (!hasNext()) {
                    throw new NoSuchElementException("Range exhausted");
                }
                // 返回当前值并将游标后移
                return cursor++;
            }
        }
 
        // 向上转型为 Iterator 接口返回，隐藏 RangeIterator 类型
        return new RangeIterator();
    }
}
 
// 使用方式：调用者完全不知道 RangeIterator 的存在
// Iterator<Integer> it = IteratorFactory.rangeIterator(1, 5);
// while (it.hasNext()) {
//     System.out.println(it.next()); // 输出 1, 2, 3, 4
// }

public class DataProcessor {
 
    public List<String> processRecords(List<Record> records) {
        // 这个辅助类只在 processRecords 方法中有意义
        // 没必要提升为成员内部类或顶层类
        class RecordValidator {
            // 验证计数器
            private int validCount = 0;
            // 跳过计数器
            private int skipCount = 0;
 
            // 验证单条记录是否合法
            boolean isValid(Record r) {
                if (r == null || r.getData().isEmpty()) {
                    skipCount++;       // 记录跳过数
                    return false;
                }
                validCount++;          // 记录有效数
                return true;
            }
 
            // 返回处理摘要
            String summary() {
                return String.format("Valid: %d, Skipped: %d", validCount, skipCount);
            }
        }
 
        // 在方法内使用局部内部类
        RecordValidator validator = new RecordValidator();
        List<String> results = new ArrayList<>();
 
        for (Record r : records) {
            if (validator.isValid(r)) {
                results.add(r.getData().toUpperCase());
            }
        }
 
        // 打印处理摘要
        System.out.println(validator.summary());
        return results;
    }
}

public class Comparison {
 
    public void usingLocalClass() {
        // 局部内部类：有名字，可以定义构造器，可以创建多个实例
        class MyComparator implements Comparator<String> {
            // ✅ 可以定义自己的构造器
            MyComparator() {
                System.out.println("Comparator created");
            }
 
            @Override
            public int compare(String a, String b) {
                return a.length() - b.length();
            }
        }
 
        // ✅ 可以创建多个实例
        Comparator<String> c1 = new MyComparator();
        Comparator<String> c2 = new MyComparator();
    }
 
    public void usingAnonymousClass() {
        // 匿名内部类：没有名字，不能定义构造器，定义和实例化合为一步
        Comparator<String> c = new Comparator<String>() {
            // ❌ 不能定义构造器（因为没有类名）
            @Override
            public int compare(String a, String b) {
                return a.length() - b.length();
            }
        };
        // ❌ 不能再创建第二个"同类型"的实例（除非再写一遍）
    }
}

public class Host {
    public void methodA() {
        class Helper { }       // 编译产物：Host$1Helper.class
    }
 
    public void methodB() {
        class Helper { }       // 编译产物：Host$2Helper.class（同名但序号不同）
        class Worker { }       // 编译产物：Host$1Worker.class
    }
}
 
// 编译后生成的文件列表：
// Host.class
// Host$1Helper.class    ← methodA 中的 Helper
// Host$2Helper.class    ← methodB 中的 Helper（序号递增避免冲突）
// Host$1Worker.class    ← methodB 中的 Worker

public class Quiz {
    public Runnable createTask() {
        int count = 10;
        class Task implements Runnable {
            @Override
            public void run() {
                System.out.println("Count is: " + count);
            }
        }
        count = 20;
        return new Task();
    }
}

// 匿名内部类的通用语法模板
// 注意：整个表达式最后有一个分号，因为它本质上是一条赋值/传参语句
父类或接口 变量名 = new 父类或接口(构造参数) {
    // 类体：字段、方法重写、新增方法（但外部无法调用新增方法）
    @Override
    public void someMethod() {
        // 实现逻辑
    }
};  // ← 这个分号不能丢

public class AnonymousBasicDemo {
    public static void main(String[] args) {
        // 1. 传统方式：先定义一个具名类，再实例化
        // 需要单独创建一个 MyRunnable.java 或在此文件中写一个内部类
        // 如果这个实现只用一次，这样做显得冗余
 
        // 2. 匿名内部类方式：定义与实例化一步完成
        Runnable task = new Runnable() {  // new 后面跟的是接口名，不是类名
            @Override
            public void run() {           // 重写接口中的抽象方法
                System.out.println("我是匿名内部类的 run 方法");
                System.out.println("当前线程: " + Thread.currentThread().getName());
            }
        };  // 分号结束这条赋值语句
 
        // 使用这个匿名内部类实例
        Thread thread = new Thread(task);  // 将其传给 Thread 构造器
        thread.start();                    // 启动线程
    }
}

public class AnonymousThreeForms {
 
    // ========== 形态一：实现接口 ==========
    // 这是最常见的用法，匿名内部类提供接口的具体实现
    public void formOne() {
        Comparable<String> comp = new Comparable<String>() {  // 实现 Comparable 接口
            @Override
            public int compareTo(String o) {                  // 必须实现接口的所有抽象方法
                return 0;                                     // 简单返回 0 表示相等
            }
        };
        System.out.println(comp.compareTo("test"));           // 输出: 0
    }
 
    // ========== 形态二：继承抽象类 ==========
    // 匿名内部类继承一个抽象类，并实现其抽象方法
    abstract static class Animal {                            // 定义一个抽象类
        String name;                                          // 抽象类可以有字段
        Animal(String name) {                                 // 抽象类可以有构造器
            this.name = name;
        }
        abstract void speak();                                // 抽象方法，子类必须实现
    }
 
    public void formTwo() {
        // 注意：new Animal("Dog") 中的 "Dog" 会传给 Animal 的构造器
        Animal dog = new Animal("Dog") {                      // 继承抽象类 Animal
            @Override
            void speak() {                                    // 实现抽象方法
                System.out.println(name + " says: Woof!");    // 可以访问父类的字段
            }
        };
        dog.speak();                                          // 输出: Dog says: Woof!
    }
 
    // ========== 形态三：继承具体类（重写方法） ==========
    // 匿名内部类继承一个普通类，覆盖其中的方法
    public void formThree() {
        // 继承 Thread 类，重写 run 方法
        Thread customThread = new Thread("MyThread") {        // 调用 Thread(String name) 构造器
            @Override
            public void run() {                               // 重写 Thread 的 run 方法
                System.out.println("线程名: " + getName());   // getName() 继承自 Thread
                System.out.println("自定义线程逻辑执行中...");
            }
        };
        customThread.start();                                 // 启动线程
    }
 
    public static void main(String[] args) {
        AnonymousThreeForms demo = new AnonymousThreeForms();
        demo.formOne();
        demo.formTwo();
        demo.formThree();
    }
}

import javax.swing.*;       // Swing GUI 组件
import java.awt.*;          // AWT 布局和事件
import java.awt.event.*;    // 事件监听器接口
 
public class EventListenerDemo extends JFrame {
 
    public EventListenerDemo() {
        setTitle("匿名内部类事件监听演示");                    // 设置窗口标题
        setSize(400, 300);                                    // 设置窗口大小
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);       // 关闭窗口时退出程序
        setLayout(new FlowLayout());                          // 使用流式布局
 
        // ========== 按钮点击事件 ==========
        JButton btnClick = new JButton("点击我");             // 创建按钮
        btnClick.addActionListener(new ActionListener() {     // 注册匿名内部类作为监听器
            @Override
            public void actionPerformed(ActionEvent e) {      // 按钮被点击时触发
                JOptionPane.showMessageDialog(                // 弹出对话框
                    EventListenerDemo.this,                   // 引用外部类实例作为父窗口
                    "按钮被点击了！事件源: " + e.getSource()   // 获取事件源信息
                );
            }
        });
        add(btnClick);                                        // 将按钮添加到窗口
 
        // ========== 鼠标悬停事件 ==========
        JLabel label = new JLabel("把鼠标移到我上面");         // 创建标签
        label.addMouseListener(new MouseAdapter() {           // MouseAdapter 是抽象类，提供空实现
            @Override
            public void mouseEntered(MouseEvent e) {          // 鼠标进入组件区域时触发
                label.setText("鼠标进来了！");                 // 修改标签文字
                label.setForeground(Color.RED);               // 文字变红
            }
 
            @Override
            public void mouseExited(MouseEvent e) {           // 鼠标离开组件区域时触发
                label.setText("把鼠标移到我上面");             // 恢复原始文字
                label.setForeground(Color.BLACK);             // 文字恢复黑色
            }
        });
        add(label);                                           // 将标签添加到窗口
 
        // ========== 窗口关闭事件 ==========
        addWindowListener(new WindowAdapter() {               // WindowAdapter 也是抽象类
            @Override
            public void windowClosing(WindowEvent e) {        // 窗口即将关闭时触发
                System.out.println("窗口正在关闭...");        // 可以在这里做资源清理
                System.out.println("再见！");
            }
        });
    }
 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {           // 确保 GUI 在事件调度线程中创建
            @Override
            public void run() {
                new EventListenerDemo().setVisible(true);     // 创建并显示窗口
            }
        });
    }
}

public class CallbackPatternDemo {
 
    // ========== 定义回调接口 ==========
    // 回调接口通常只有一个或少数几个方法
    interface OnResultListener<T> {
        void onSuccess(T result);     // 操作成功时的回调
        void onFailure(String error); // 操作失败时的回调
    }
 
    // ========== 模拟异步数据加载 ==========
    // 方法接收一个回调对象，在操作完成后通知调用者
    static void loadDataAsync(String url, OnResultListener<String> listener) {
        new Thread(new Runnable() {                           // 在新线程中执行（模拟异步）
            @Override
            public void run() {
                try {
                    System.out.println("开始加载: " + url);   // 打印加载信息
                    Thread.sleep(1500);                       // 模拟网络延迟 1.5 秒
 
                    if (url.contains("error")) {              // 模拟失败场景
                        listener.onFailure("网络请求失败: 404 Not Found");  // 回调失败方法
                    } else {
                        String data = "{\"name\":\"Kiro\",\"type\":\"AI\"}"; // 模拟返回数据
                        listener.onSuccess(data);             // 回调成功方法
                    }
                } catch (InterruptedException e) {            // 处理线程中断异常
                    listener.onFailure("操作被中断: " + e.getMessage());
                }
            }
        }).start();                                           // 启动线程
    }
 
    public static void main(String[] args) {
        System.out.println("=== 场景一：成功回调 ===");
 
        // 使用匿名内部类作为回调
        loadDataAsync("https://api.example.com/data", new OnResultListener<String>() {
            @Override
            public void onSuccess(String result) {            // 成功时执行这里
                System.out.println("数据加载成功！");
                System.out.println("收到数据: " + result);
                // 在这里可以继续处理数据：解析 JSON、更新 UI 等
            }
 
            @Override
            public void onFailure(String error) {             // 失败时执行这里
                System.out.println("加载失败: " + error);
                // 在这里可以做错误处理：重试、提示用户等
            }
        });
 
        System.out.println("=== 场景二：失败回调 ===");
 
        loadDataAsync("https://api.example.com/error", new OnResultListener<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("不会执行到这里");
            }
 
            @Override
            public void onFailure(String error) {
                System.err.println("错误处理: " + error);     // 输出到标准错误流
            }
        });
 
        System.out.println("主线程继续执行，不会被阻塞...");   // 异步的核心：主线程不等待
    }
}

import java.util.*;   // 导入集合框架
 
public class ComparatorAnonymousDemo {
 
    static class Student {                                    // 学生类
        String name;                                          // 姓名
        int age;                                              // 年龄
        double score;                                         // 成绩
 
        Student(String name, int age, double score) {         // 构造器
            this.name = name;
            this.age = age;
            this.score = score;
        }
 
        @Override
        public String toString() {                            // 重写 toString 方便打印
            return String.format("Student{name='%s', age=%d, score=%.1f}", name, age, score);
        }
    }
 
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();           // 创建学生列表
        students.add(new Student("Alice", 22, 88.5));         // 添加学生数据
        students.add(new Student("Bob", 20, 92.0));
        students.add(new Student("Charlie", 21, 88.5));
        students.add(new Student("Diana", 20, 95.5));
 
        // ========== 按成绩降序排序 ==========
        Collections.sort(students, new Comparator<Student>() {  // 传入匿名 Comparator
            @Override
            public int compare(Student s1, Student s2) {        // 定义比较规则
                // Double.compare 避免浮点数直接相减的精度问题
                return Double.compare(s2.score, s1.score);      // s2 在前 → 降序
            }
        });
        System.out.println("按成绩降序:");
        students.forEach(System.out::println);                  // 方法引用打印每个元素
 
        // ========== 多条件排序：先按成绩降序，成绩相同按年龄升序 ==========
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int scoreCompare = Double.compare(s2.score, s1.score);  // 先比成绩（降序）
                if (scoreCompare != 0) {                                // 成绩不同，直接返回
                    return scoreCompare;
                }
                return Integer.compare(s1.age, s2.age);                 // 成绩相同，比年龄（升序）
            }
        });
        System.out.println("\n按成绩降序，同分按年龄升序:");
        students.forEach(System.out::println);
 
        // ========== 对比：Java 8 Lambda 写法（更简洁） ==========
        students.sort((s1, s2) -> Double.compare(s2.score, s1.score));  // 一行搞定
        // 或者使用 Comparator 链式 API
        students.sort(
            Comparator.comparingDouble((Student s) -> s.score)          // 按成绩
                      .reversed()                                       // 降序
                      .thenComparingInt(s -> s.age)                     // 同分按年龄升序
        );
    }
}

public class AnonymousLimitations {
 
    interface Greeting {
        void greet();
    }
 
    // ========== 限制一：不能定义构造器 ==========
    // 匿名内部类没有类名，因此无法定义构造器
    // 替代方案：使用实例初始化块
    public void noConstructor() {
        Greeting g = new Greeting() {
            String message;                                   // 可以定义字段
 
            {                                                 // 实例初始化块（替代构造器）
                message = "Hello from initializer block!";    // 在这里完成初始化
                System.out.println("初始化块执行了");
            }
 
            @Override
            public void greet() {
                System.out.println(message);                  // 使用初始化块中设置的值
            }
        };
        g.greet();                                            // 输出: Hello from initializer block!
    }
 
    // ========== 限制二：不能定义静态成员 ==========
    public void noStaticMembers() {
        Greeting g = new Greeting() {
            // static int count = 0;                          // ✗ 编译错误！不能有静态字段
            // static void helper() {}                        // ✗ 编译错误！不能有静态方法
            // static final int MAX = 100;                    // ✓ 编译时常量例外（Java 16+）
 
            @Override
            public void greet() {
                System.out.println("Hello");
            }
        };
    }
 
    // ========== 限制三：只能实现一个接口或继承一个类 ==========
    interface A { void a(); }
    interface B { void b(); }
 
    public void singleInheritance() {
        // 不能同时实现 A 和 B
        // 如果需要同时实现多个接口，必须使用具名类
        A implA = new A() {                                   // 只能实现一个接口
            @Override
            public void a() { System.out.println("A"); }
        };
    }
 
    // ========== 限制四：新增的方法外部无法调用 ==========
    public void cannotCallNewMethods() {
        Greeting g = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello");
                extraMethod();                                // 内部可以调用自己的新方法
            }
 
            // 新增的方法
            public void extraMethod() {                       // 这个方法外部无法访问
                System.out.println("Extra!");
            }
        };
 
        g.greet();                                            // ✓ 可以调用，接口中声明了
        // g.extraMethod();                                   // ✗ 编译错误！Greeting 接口中没有此方法
        // 因为 g 的编译时类型是 Greeting，编译器只认识 Greeting 中声明的方法
    }
 
    // ========== 限制五：不能用于 instanceof 判断（无类名可引用） ==========
    public void noInstanceOf() {
        Greeting g = new Greeting() {
            @Override
            public void greet() {}
        };
        // 只能判断接口类型，不能判断匿名类本身的类型
        System.out.println(g instanceof Greeting);            // ✓ true
        // System.out.println(g instanceof ???);              // 无法引用匿名类的类型
        System.out.println(g.getClass().getName());           // 输出类似: AnonymousLimitations$1
    }
}