/**
 * 单向链表节点
 */
class Node<E> {
    E data;       // 数据域
    Node<E> next; // 指针域，指向下一个节点

    public Node(E data) {
        this.data = data;
        this.next = null;
    }
}

/**
 * 单向链表实现
 */
public class SinglyLinkedList<E> {
    private Node<E> head; // 头节点
    private int size;     // 链表长度

    public SinglyLinkedList() {
        this.head = new Node<>(null); // 虚拟头节点
        this.size = 0;
    }

    /**
     * 在链表头部添加元素
     * 时间复杂度：O(1)
     */
    public void addFirst(E element) {
        Node<E> newNode = new Node<>(element);
        newNode.next = head.next;
        head.next = newNode;
        size++;
    }

    /**
     * 在链表尾部添加元素
     * 时间复杂度：O(n)
     */
    public void addLast(E element) {
        Node<E> newNode = new Node<>(element);
        Node<E> current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
        size++;
    }

    /**
     * 在指定位置插入元素
     * 时间复杂度：O(n)
     */
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        Node<E> newNode = new Node<>(element);
        Node<E> current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        newNode.next = current.next;
        current.next = newNode;
        size++;
    }

    /**
     * 删除指定位置的元素
     * 时间复杂度：O(n)
     */
    public E remove(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;
        }
        Node<E> removedNode = current.next;
        current.next = removedNode.next;
        size--;
        return removedNode.data;
    }

    /**
     * 获取指定位置的元素
     * 时间复杂度：O(n)
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        Node<E> current = head.next;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.data;
    }

    /**
     * 链表长度
     */
    public int size() {
        return size;
    }

    /**
     * 判断链表是否为空
     */
    public boolean isEmpty() {
        return size == 0;
    }
}

/**
 * 双向链表节点
 */
class DNode<E> {
    E data;
    DNode<E> prev; // 前驱指针
    DNode<E> next; // 后继指针

    public DNode(E data) {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

/**
 * 双向链表实现
 */
public class DoublyLinkedList<E> {
    private DNode<E> head; // 头节点
    private DNode<E> tail; // 尾节点
    private int size;

    public DoublyLinkedList() {
        this.head = new DNode<>(null);
        this.tail = new DNode<>(null);
        this.head.next = tail;
        this.tail.prev = head;
        this.size = 0;
    }

    /**
     * 在头部添加元素
     */
    public void addFirst(E element) {
        DNode<E> newNode = new DNode<>(element);
        newNode.next = head.next;
        newNode.prev = head;
        head.next.prev = newNode;
        head.next = newNode;
        size++;
    }

    /**
     * 在尾部添加元素
     */
    public void addLast(E element) {
        DNode<E> newNode = new DNode<>(element);
        newNode.next = tail;
        newNode.prev = tail.prev;
        tail.prev.next = newNode;
        tail.prev = newNode;
        size++;
    }

    /**
     * 删除指定节点
     */
    public void remove(DNode<E> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
    }
}

/**
 * 栈接口
 */
public interface Stack<E> {
    void push(E element);  // 压栈
    E pop();               // 弹栈
    E peek();              // 查看栈顶
    int size();            // 大小
    boolean isEmpty();     // 是否为空
}

/**
 * 基于数组的栈实现
 */
public class ArrayStack<E> implements Stack<E> {
    private Object[] elements;
    private int top;           // 栈顶指针
    private int capacity;      // 栈容量

    public ArrayStack(int capacity) {
        this.capacity = capacity;
        this.elements = new Object[capacity];
        this.top = -1;
    }

    @Override
    public void push(E element) {
        if (top >= capacity - 1) {
            throw new StackOverflowError("Stack is full!");
        }
        elements[++top] = element;
    }

    @Override
    @SuppressWarnings("unchecked")
    public E pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty!");
        }
        return (E) elements[top--];
    }

    @Override
    @SuppressWarnings("unchecked")
    public E peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty!");
        }
        return (E) elements[top];
    }

    @Override
    public int size() {
        return top + 1;
    }

    @Override
    public boolean isEmpty() {
        return top == -1;
    }
}

/**
 * 有效的括号匹配
 */
public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') {
            stack.push(c);  // 左括号入栈
        } else {
            if (stack.isEmpty()) {
                return false;  // 没有左括号可以匹配
            }
            char top = stack.pop();
            if ((c == ')' && top != '(') ||
                (c == ']' && top != '[') ||
                (c == '}' && top != '{')) {
                return false;  // 括号不匹配
            }
        }
    }
    
    return stack.isEmpty();  // 栈空说明完全匹配
}

/**
 * 队列接口
 */
public interface Queue<E> {
    void enqueue(E element);  // 入队
    E dequeue();              // 出队
    E front();                // 查看队首
    boolean isEmpty();        // 是否为空
    int size();               // 大小
}

/**
 * 基于数组的循环队列实现
 */
public class CircularQueue<E> implements Queue<E> {
    private Object[] elements;
    private int front;        // 队首指针
    private int rear;         // 队尾指针
    private int capacity;     // 队列容量
    private int size;

    public CircularQueue(int capacity) {
        this.capacity = capacity;
        this.elements = new Object[capacity];
        this.front = 0;
        this.rear = 0;
        this.size = 0;
    }

    @Override
    public void enqueue(E element) {
        if (size == capacity) {
            throw new IllegalStateException("Queue is full!");
        }
        elements[rear] = element;
        rear = (rear + 1) % capacity;
        size++;
    }

    @Override
    @SuppressWarnings("unchecked")
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty!");
        }
        E element = (E) elements[front];
        front = (front + 1) % capacity;
        size--;
        return element;
    }

    @Override
    @SuppressWarnings("unchecked")
    public E front() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty!");
        }
        return (E) elements[front];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public int size() {
        return size;
    }
}

/**
 * 使用队列实现二叉树层序遍历
 */
public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> result = new ArrayList<>();
    if (root == null) return result;
    
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while (!queue.isEmpty()) {
        int levelSize = queue.size();
        List<Integer> level = new ArrayList<>();
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode node = queue.poll();
            level.add(node.val);
            
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        result.add(level);
    }
    
    return result;
}

// 举例：程序计数器的工作方式
public class PCRDemo {
    public static void main(String[] args) {
        int a = 1;        // 字节码指令 0: iconst_1
        int b = 2;        // 字节码指令 2: iconst_2
        int c = a + b;    // 字节码指令 3: iadd
        // 程序计数器记录当前执行到哪条指令
    }
}

public class StackDemo {
    public static void main(String[] args) {
        methodA();
    }

    public static void methodA() {
        int a = 10;
        methodB(a);
    }

    public static void methodB(int num) {
        int result = num * 2;
        System.out.println(result);
    }
}

// 栈溢出示例：递归没有终止条件
public class StackOverflowDemo {
    public static void recursive() {
        recursive();  // 无限递归，最终 StackOverflowError
    }

    public static void main(String[] args) {
        recursive();
    }
}

// 堆内存演示：创建大量对象
public class HeapDemo {
    public static void main(String[] args) {
        // 不断创建对象，观察内存变化
        List<byte[]> list = new ArrayList<>();
        while (true) {
            // 每个 byte 数组约 1MB
            list.add(new byte[1024 * 1024]);
            System.out.println("已分配：" + list.size() + " MB");
        }
    }
}

public class MethodAreaDemo {
    // 静态变量存储在方法区
    private static int staticVar = 100;

    // 常量存储在方法区的常量池
    public static final String CONSTANT = "Hello";

    static {
        // 静态代码块也在方法区
        System.out.println("类加载时执行");
    }

    public void method() {
        // 普通方法不在方法区，具体在虚拟机栈的栈帧中
    }
}

// OOM 示例：常量池溢出（Java 7 之前会发生）
public class OOMDemo {
    public static void main(String[] args) {
        // 使用 String.intern() 将字符串放入常量池
        // 如果不断添加字符串到常量池，最终会 OOM
        List<String> list = new ArrayList<>();
        int i = 0;
        while (true) {
            list.add(String.valueOf(i++).intern());
        }
    }
}

// 循环引用示例：引用计数法无法处理
public class CircleReference {
    public CircleReference ref;

    public static void main(String[] args) {
        CircleReference a = new CircleReference();  // a 引用计数 = 1
        CircleReference b = new CircleReference();  // b 引用计数 = 1

        a.ref = b;  // b 引用计数 = 2
        b.ref = a;  // a 引用计数 = 2

        // 此时 a 和 b 都不再被其他对象引用（除了互相引用）
        // 引用计数都是 2，但实际上已经"死"了

        a = null;  // a 引用计数 = 1
        b = null;  // b 引用计数 = 1

        // 虽然 a 和 b 已经不可达，但引用计数不为 0
        // 引用计数法无法回收这对对象！
    }
}

public class GC RootsDemo {
    // GC Roots 1：类的静态属性引用的对象
    private static GCRootsDemo instance;

    // GC Roots 2：虚拟机栈中引用的对象
    private byte[] data;  // 占较大内存，避免被优化

    public static void main(String[] args) {
        // 局部变量表中的引用，作为 GC Roots
        GCRootsDemo demo = new GCRootsDemo();  // demo 是 GC Root
        demo.data = new byte[10 * 1024 * 1024];  // 10MB

        // demo 仍然被 instance 引用，不能回收
        instance = demo;

        // 解除 demo 引用
        demo = null;

        // 此时 demo 对象只被 instance 引用
        // 仍然是可达的，不能被回收
    }
}

// 类的加载：Class 对象是访问类元数据的入口
public class LoadingDemo {
    public static void main(String[] args) {
        // 获取 Class 对象的方式
        // 方式一：Class.forName()
        Class<?> clazz1 = Class.forName("java.lang.String");

        // 方式二：.class 属性
        Class<?> clazz2 = String.class;

        // 方式三：对象的 getClass() 方法
        String str = "hello";
        Class<?> clazz3 = str.getClass();

        // 三个 Class 对象是同一个（类的 Class 对象在 JVM 中唯一）
        System.out.println(clazz1 == clazz2);  // true
        System.out.println(clazz2 == clazz3);  // true
    }
}

public class PreparationDemo {
    // 类变量：准备阶段赋默认值
    private static int staticVar = 100;

    // 常量：准备阶段赋最终值
    private static final int CONSTANT = 200;

    // 编译时常量在准备阶段就被替换为具体值
    // 因为它是 static final，编译器就知道值是多少
}

// 解析示例
public class ResolutionDemo {
    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("java.lang.String");
        
        // 获取方法或字段时，JVM 会进行解析
        // 符号引用 -> 直接引用
        java.lang.reflect.Field field = 
            clazz.getDeclaredField("value");
        // field 是一个直接引用，指向 actual character array
    }
}

public class InitializationDemo {
    static {
        System.out.println("InitializationDemo 被初始化！");
    }

    public static void main(String[] args) {
        // 触发 InitializationDemo 初始化
        System.out.println("main 方法执行");
        
        // 触发 A 初始化
        // A a = new A();  // 如果有 A 类，会触发其初始化
    }
}

class A {
    static {
        System.out.println("A 被初始化！");
    }
}

// 自定义类加载器示例
public class MyClassLoader extends ClassLoader {
    private String classPath;

    public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException(name);
        }
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] loadClassData(String className) {
        // 从文件系统读取 class 文件
        String fileName = classPath + File.separatorChar 
            + className.replace('.', File.separatorChar) + ".class";
        try (InputStream is = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int data;
            while ((data = is.read()) != -1) {
                baos.write(data);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            return null;
        }
    }
}

public class AtomicityDemo implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            count++;  // 这不是原子操作！
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicityDemo demo = new AtomicityDemo();
        Thread t1 = new Thread(demo);
        Thread t2 = new Thread(demo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        // 期望：20000，实际可能小于 20000
        System.out.println("最终结果：" + demo.count);
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicDemo implements Runnable {
    private AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            count.incrementAndGet();  // 原子操作
        }
    }

    public int getCount() {
        return count.get();
    }
}

public class VisibilityDemo extends Thread {
    // 加上 volatile 关键字
    private volatile boolean running = true;

    @Override
    public void run() {
        while (running) {
            // 无限循环
        }
        System.out.println("线程结束了");
    }

    public void stopRunning() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        VisibilityDemo demo = new VisibilityDemo();
        demo.start();
        
        Thread.sleep(1000);
        demo.stopRunning();  // 尝试停止线程
        
        // 如果没有 volatile，主线程修改 running 后
        // 子线程可能看不到（缓存问题），导致无法停止
    }
}

// 有序性问题示例
public class OrderingDemo {
    private int a = 0;
    private boolean flag = false;

    public void writer() {
        a = 1;          // 1. 给 a 赋值
        flag = true;    // 2. 设置 flag
    }

    public void reader() {
        if (flag) {     // 3. 读取 flag
            int i = a;  // 4. 读取 a
            System.out.println(i);
        }
    }
}

public class VolatileDemo {
    // volatile 保证：每次读取都从主内存读，写完立即刷新到主内存
    private volatile int count = 0;

    public void increment() {
        count++;  // 不是原子操作，但 volatile 保证可见性
    }
}

public class SynchronizedDemo {

    // 1. 修饰实例方法 - 锁对象本身
    public synchronized void method1() {
        // 同一时刻只有一个线程能执行这个方法
    }

    // 2. 修饰静态方法 - 锁类对象
    public static synchronized void method2() {
        // 同一时刻只有一个线程能执行这个方法
    }

    // 3. 修饰代码块 - 锁指定对象
    public void method3() {
        synchronized (this) {  // 锁当前对象
            // 同步代码
        }
    }

    public void method4() {
        synchronized (SynchronizedDemo.class) {  // 锁类对象
            // 同步代码
        }
    }
}

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 七大参数
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2,                      // corePoolSize：核心线程数
            5,                      // maximumPoolSize：最大线程数
            60L,                    // keepAliveTime：空闲线程存活时间
            TimeUnit.SECONDS,       // 时间单位
            new LinkedBlockingQueue<>(3),  // workQueue：任务队列
            Executors.defaultThreadFactory(),  // threadFactory：线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // handler：拒绝策略
        );

        // 提交 8 个任务测试
        for (int i = 1; i <= 8; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 由线程 "
                    + Thread.currentThread().getName() + " 执行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

public class ExecutorsDemo {
    public static void main(String[] args) {
        // 1. 固定线程数线程池（适合CPU密集型）
        ExecutorService fixedPool = 
            Executors.newFixedThreadPool(5);

        // 2. 单线程线程池（保证顺序执行）
        ExecutorService singlePool = 
            Executors.newSingleThreadExecutor();

        // 3. 缓存线程池（适合IO密集型，任务多但执行快）
        ExecutorService cachedPool = 
            Executors.newCachedThreadPool();

        // 4. 定时线程池
        ScheduledExecutorService scheduledPool = 
            Executors.newScheduledThreadPool(3);

        // 5. 工作窃取线程池
        ExecutorService workStealingPool = 
            Executors.newWorkStealingPool();

        // 注意：实际生产中推荐使用 ThreadPoolExecutor
        // Executors 创建的线程池可能有 OOM 风险
    }
}

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 1; i <= 3; i++) {
            final int playerId = i;
            new Thread(() -> {
                System.out.println("选手 " + playerId + " 准备完成");
                latch.countDown();  // 完成一项准备
            }).start();
        }

        // 等待所有选手准备完成
        latch.await();
        System.out.println("所有选手准备完毕，开始比赛！");
    }
}

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有玩家都准备好了，游戏开始！");
        });

        for (int i = 1; i <= 3; i++) {
            final int playerId = i;
            new Thread(() -> {
                System.out.println("玩家 " + playerId + " 加载中...");
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("玩家 " + playerId + " 准备完成，等待其他人...");
                    barrier.await();  // 等待其他玩家
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

public class SemaphoreDemo {
    // 模拟停车位，只有 3 个
    private static final int SPOTS = 3;
    private static final Semaphore semaphore = new Semaphore(SPOTS);

    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            final int carId = i;
            new Thread(() -> {
                try {
                    semaphore.acquire();  // 获取许可证
                    System.out.println("车辆 " + carId + " 进入停车场");
                    Thread.sleep((long) (Math.random() * 3000));
                    System.out.println("车辆 " + carId + " 离开停车场");
                    semaphore.release();  // 释放许可证
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = 
            new ConcurrentHashMap<>();

        // 常用操作
        map.put("A", 1);
        map.putIfAbsent("B", 2);  // 不存在才插入
        map.get("A");
        map.remove("A");
        map.size();

        // 原子操作
        map.putIfAbsent("counter", 0);
        // 原子递增
        map.replace("counter", map.get("counter"), 
            map.get("counter") + 1);
        
        // Java 8+ 支持 compute 方法
        map.compute("counter", (k, v) -> v == null ? 1 : v + 1);

        // computeIfPresent：key 存在才更新
        map.computeIfPresent("counter", (k, v) -> v + 1);

        // computeIfAbsent：key 不存在才添加
        map.computeIfAbsent("newCounter", k -> 10);
    }
}

// HashMap 核心属性
public class HashMap<K, V> extends AbstractMap<K, V> 
    implements Map<K, V>, Cloneable, Serializable {

    // 默认初始容量（16）
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

    // 最大容量（2^30）
    static final int MAXIMUM_CAPACITY = 1 << 30;

    // 负载因子（0.75，元素达到容量的75%时扩容）
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 树化阈值（链表转红黑树）
    static final int TREEIFY_THRESHOLD = 8;

    // 解除树化阈值（红黑树转链表）
    static final int UNTREEIFY_THRESHOLD = 6;

    // 最小树化容量（整个 HashMap 桶数 >= 64 才允许树化）
    static final int MIN_TREEIFY_CAPACITY = 64;

    // 存储数据的数组
    transient Node<K, V>[] table;

    // 元素个数
    transient int size;
}

// HashMap 的 hash 算法
static final int hash(Object key) {
    int h;
    // 扰动函数：让高位参与运算，减少碰撞
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 计算桶位置
int index = hash(key) & (capacity - 1);

// 例如：capacity = 16 = 2^4，capacity - 1 = 15 = 0b1111
// hash(key) = 31 = 0b11111
// index = 0b11111 & 0b1111 = 0b1111 = 15

// 扩容方法
Node<K, V>[] resize() {
    // 新容量 = 旧容量 * 2
    newCap = oldCap << 1;
    
    // 新阈值 = 旧阈值 * 2
    newThr = oldThr << 1;
    
    // 创建新数组
    Node<K, V>[] newTable = new Node[newCap];
    
    // 迁移元素（重点）
    for (int j = 0; j < oldCap; j++) {
        Node<K, V> e;
        if ((e = oldTab[j]) != null) {
            oldTab[j] = null;
            if (e.next == null) {
                // 只有一个节点，直接计算新位置
                newTab[e.hash & (newCap - 1)] = e;
            } else if (e instanceof TreeNode) {
                // 红黑树拆分
                ((TreeNode<K, V>) e).split(this, newTable, j, oldCap);
            } else {
                // 链表拆分（JDK 1.8 尾插法）
                Node<K, V> loHead = null, loTail = null;
                Node<K, V> hiHead = null, hiTail = null;
                Node<K, V> next;
                do {
                    next = e.next;
                    // 原位置节点
                    if ((e.hash & oldCap) == 0) {
                        if (loTail == null) loHead = e;
                        else loTail.next = e;
                        loTail = e;
                    } else {
                        // 扩容后的新位置节点
                        if (hiTail == null) hiHead = e;
                        else hiTail.next = e;
                        hiTail = e;
                    }
                } while ((e = next) != null);
                
                // 原位置放到新数组
                if (loTail != null) {
                    loTail.next = null;
                    newTab[j] = loHead;
                }
                // 新位置放到新数组
                if (hiTail != null) {
                    hiTail.next = null;
                    newTab[j + oldCap] = hiHead;
                }
            }
        }
    }
    return newTable;
}

public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = 
            new ConcurrentHashMap<>();

        // CAS + synchronized 保证了并发安全
        map.put("A", 1);
        map.putIfAbsent("B", 2);  // CAS 操作

        // 原子操作
        map.putIfAbsent("counter", 0);
        map.put("counter", map.get("counter") + 1);

        // 推荐：使用 compute 原子更新
        map.compute("counter", (k, v) -> v == null ? 1 : v + 1);
    }
}

public class HungrySingleton {
    // 类加载时就创建实例，线程安全
    private static final HungrySingleton INSTANCE = new HungrySingleton();

    // 私有构造函数
    private HungrySingleton() {
        // 防止反射创建多个实例
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象已存在！");
        }
    }

    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static LazySingleton getInstance() {
        if (instance == null) {  // 线程不安全
            instance = new LazySingleton();
        }
        return instance;
    }
}

public class DoubleCheckSingleton {
    // volatile 防止指令重排序
    private static volatile DoubleCheckSingleton instance;

    private DoubleCheckSingleton() {}

    public static DoubleCheckSingleton getInstance() {
        if (instance == null) {  // 第一次检查
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {  // 第二次检查
                    instance = new DoubleCheckSingleton();
                    // 可能的指令重排序：
                    // 1. 分配内存
                    // 2. 调用构造函数
                    // 3. instance 指向内存
                    // volatile 防止重排序，保证 2 在 3 之前
                }
            }
        }
        return instance;
    }
}

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}

    // 静态内部类，只有在被调用时才会加载，且加载过程是线程安全的
    private static class SingletonHolder {
        private static final StaticInnerClassSingleton INSTANCE = 
            new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

// 产品接口
interface Phone {
    void call();
}

// 具体产品
class IPhone implements Phone {
    @Override
    public void call() {
        System.out.println("用 iPhone 打电话");
    }
}

class AndroidPhone implements Phone {
    @Override
    public void call() {
        System.out.println("用安卓手机打电话");
    }
}

// 工厂
class SimplePhoneFactory {
    public static Phone createPhone(String type) {
        switch (type) {
            case "iPhone":
                return new IPhone();
            case "Android":
                return new AndroidPhone();
            default:
                throw new IllegalArgumentException("未知类型");
        }
    }
}

// 抽象工厂
interface PhoneFactory {
    Phone createPhone();
}

// 具体工厂
class IPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new IPhone();
    }
}

class AndroidFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new AndroidPhone();
    }
}

// 使用
public class FactoryMethodDemo {
    public static void main(String[] args) {
        PhoneFactory factory = new IPhoneFactory();
        Phone phone = factory.createPhone();
        phone.call();
    }
}

// 产品族接口
interface Laptop {
    void display();
}

interface Phone {
    void call();
}

// 苹果产品族
class MacBook implements Laptop {
    @Override
    public void display() {
        System.out.println("MacBook 显示");
    }
}

class iPhone implements Phone {
    @Override
    public void call() {
        System.out.println("iPhone 打电话");
    }
}

// 抽象工厂
interface DeviceFactory {
    Laptop createLaptop();
    Phone createPhone();
}

// 苹果工厂
class AppleFactory implements DeviceFactory {
    @Override
    public Laptop createLaptop() {
        return new MacBook();
    }

    @Override
    public Phone createPhone() {
        return new iPhone();
    }
}

// 策略接口
interface SortStrategy {
    void sort(int[] array);
}

// 具体策略：冒泡排序
class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用冒泡排序");
        // 冒泡排序实现...
    }
}

// 具体策略：快速排序
class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用快速排序");
        // 快速排序实现...
    }
}

// 上下文：使用策略的对象
class Sorter {
    private SortStrategy strategy;

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void sort(int[] array) {
        strategy.sort(array);
    }
}

// 使用
public class StrategyDemo {
    public static void main(String[] args) {
        int[] array = {3, 1, 4, 1, 5, 9, 2, 6};

        Sorter sorter = new Sorter();

        sorter.setStrategy(new BubbleSort());
        sorter.sort(array);

        sorter.setStrategy(new QuickSort());
        sorter.sort(array);
    }
}

// 接口
interface Image {
    void display();
}

// 真实对象
class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();  // 模拟加载
    }

    @Override
    public void display() {
        System.out.println("显示图片：" + filename);
    }

    private void loadFromDisk() {
        System.out.println("从磁盘加载：" + filename);
    }
}

// 代理对象
class ImageProxy implements Image {
    private RealImage realImage;
    private String filename;

    public ImageProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        // 懒加载：真正需要时才加载真实对象
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

// 使用
public class ProxyDemo {
    public static void main(String[] args) {
        Image image = new ImageProxy("photo.jpg");
        
        // 此时不会加载真实图片
        System.out.println("图片代理已创建");
        
        // 真正显示时才加载
        image.display();
        image.display();  // 第二次不需要重新加载
    }
}