#静态内部类与非静态内部类

// 源码
class Outer {
    int outerField = 10;
    class Inner {
        int innerField = 20;
        void access() {
            System.out.println(outerField);
        }
    }
}

// 编译器生成的字节码（Outer$Inner.class）
// 编译器自动添加外部类引用：
class Outer$Inner {
    // 编译器生成：持有外部类的引用
    final Outer this$0;

    Outer$Inner(Outer outer) {
        this.this$0 = outer;
    }

    void access() {
        System.out.println(this$0.outerField);
    }
}

// 源码
class Outer {
    static int staticField = 10;
    static class StaticInner {
        int innerField = 20;
        void access() {
            System.out.println(staticField); // 直接访问
        }
    }
}

// 编译后（Outer$StaticInner.class）
// 就是一个普通的 final 类，没有外部类引用
class Outer$StaticInner {
    // 没有外部类引用字段
    void access() {
        System.out.println(Outer.staticField);
    }
}

class Outer {
    class Inner {
        static int CONST = 100; // ✅ 常量可以（有 final 修饰）
        static int counter;     // ❌ 编译错误
    }
}

// 如果允许，语义是什么？
Outer o1 = new Outer();
Outer o2 = new Outer();
Outer.Inner.counter; // o1 的 counter 还是 o2 的 counter？

// 明确语义：
Outer.Inner staticField; // 类级别，和任何实例无关
o1.new Inner().counter;  // 实例级别，但 staticField 却是类级别？

static final int CONST = 100;
// 常量在编译期就被内联了，不占用类加载时的存储空间
// 没有运行时状态，不需要区分"属于哪个实例"

class Outer {
    class HeavyInner {
        byte[] hugeData = new byte[10 * 1024 * 1024]; // 10MB
    }

    void startAsync() {
        // 场景：异步回调持有内部类引用
        executor.submit(new HeavyInner() {
            @Override
            public void run() {
                // 异步执行，内部类对象被 executor 持有
                // 而内部类对象持有外部类引用
                // → 外部类无法被 GC 回收
            }
        });
    }
}

class Outer {
    // ✅ 静态内部类：不在实例层面，不持有外部类引用
    static class HeavyInner {
        byte[] hugeData = new byte[10 * 1024 * 1024];
    }

    void startAsync() {
        // 静态内部类不持有外部类引用
        // 但如果需要访问外部类实例，通过显式参数传入
        executor.submit(() -> process(new WeakReference<>(this)));
    }
}

public class Singleton {
    // 静态内部类实现延迟加载 + 线程安全
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }

    private Singleton() { }
}

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;

    public static class Builder {
        private int servingSize = 0;
        private int servings = 0;
        private int calories = 0;

        public Builder servingSize(int val) {
            servingSize = val; return this;
        }
        public Builder servings(int val) {
            servings = val; return this;
        }
        public Builder calories(int val) {
            calories = val; return this;
        }
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        this.servingSize = builder.servingSize;
        this.servings = builder.servings;
        this.calories = builder.calories;
    }
}

// 使用
NutritionFacts cocaCola = new NutritionFacts.Builder()
    .servingSize(240).servings(8).calories(100).build();

// JDK 中 Map 的 Entry 接口经常用静态内部类实现
public interface Map<K, V> {
    interface Entry<K, V> {
        K getKey();
        V getValue();
        // ...
    }
}

// HashMap 的实现：
public class HashMap<K, V> {
    static class Node<K, V> implements Entry<K, V> {
        final int hash;
        final K key;
        V value;
        Node<K, V> next;
    }
}

// HashMap 的关键字段：
public class HashMap<K, V> {
    transient Node<K, V>[] table; // 哈希桶数组
    transient int size;
    // ...
}

// Node（键值对节点）：
static class Node<K, V> implements Map.Entry<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next;
    // ...
}

// 如果用非静态内部类：
// 每个 Node 都持有 HashMap 引用 → 内存浪费
// 当 HashMap 扩容重新 hash 时，大量 Node 对象被创建/销毁
// 持有无用的引用 → GC 压力增大