class Parent {
    static String staticVar = initStaticVar(); // 1. 静态变量

    static {
        System.out.println("1. 父类的静态代码块");
    }

    String instanceVar = initInstanceVar(); // 3. 实例变量

    {
        System.out.println("3. 父类的实例代码块");
    }

    Parent() {
        System.out.println("4. 父类的构造方法");
    }

    static String initStaticVar() {
        System.out.println("0. 父类的静态变量初始化");
        return "staticVar";
    }

    String initInstanceVar() {
        System.out.println("2. 父类的实例变量初始化");
        return "instanceVar";
    }
}

class Child extends Parent {
    static {
        System.out.println("5. 子类的静态代码块");
    }

    {
        System.out.println("7. 子类的实例代码块");
    }

    Child() {
        System.out.println("8. 子类的构造方法");
    }
}

public class ClassLoadOrder {
    public static void main(String[] args) {
        new Child(); // 创建子类对象
    }
}

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

class Engine {
    void start() {
        System.out.println("Engine is starting");
    }
}

class Car {
    private Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }

    void start() {
        engine.start();
        System.out.println("Car is starting");
    }
}

private static final long serialVersionUID = 1L;

private void test() {
    Class<?> clazz = Class.forName("com.example.MyClass");
    Object instance = clazz.getConstructor().newInstance();

    Field field = clazz.getDeclaredField("name");
    field.setAccessible(true);
    field.set(instance, "Hello");

    Method method = clazz.getMethod("printName");
    method.invoke(instance);
}

Class<?> driverClass = Class.forName("com.mysql.cj.jdbc.Driver");

private void test() {
    if (clazz.isAnnotationPresent(Service.class)) {
        // 执行服务类的初始化逻辑
    }
}

// 1. 定义接口
interface Subject {
    void request();
}

// 2. 真实对象
class RealSubject implements Subject {
    public void request() {
        System.out.println("真实对象的请求");
    }
}

// 3. 代理类
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() {
        preRequest();
        realSubject.request(); // 调用真实对象的方法
        postRequest();
    }

    private void preRequest() {
        System.out.println("代理前置处理");
    }

    private void postRequest() {
        System.out.println("代理后置处理");
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        RealSubject real = new RealSubject();
        Proxy proxy = new Proxy(real);
        proxy.request();
    }
}

public class SingletonLazy {
    // 静态实例变量，初始为 null
    private static SingletonLazy instance;

    // 私有构造方法，防止外部实例化
    private SingletonLazy() {
    }

    public static SingletonLazy getInstance() {
        // 只有在需要时才创建
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

public class SingletonEager {
    // 直接初始化
    private static final SingletonEager instance = new SingletonEager();

    // 私有构造方法
    private SingletonEager() {
    }

    public static SingletonEager getInstance() {
        // 直接返回实例
        return instance;
    }
}

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

    private SingletonDCL() {
    }

    public static SingletonDCL getInstance() {
        // 先检查实例是否存在
        if (instance == null) {
            // 线程同步
            synchronized (SingletonDCL.class) {
                // 二次检查
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}

private void test() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());

    System.out.println(evenNumbers); // 输出 [2, 4]
}

public void test() {
    if (user != null) {
        if (user.getDept() != null) {
            String deptName = user.getDept().getName();
            if (StrUtil.isBlank(deptName)) {
                System.out.println("未指定部门");
            } else {
                System.out.println(deptName);
            }
        } else {
            System.out.println("未指定部门");
        }
    }
}

private void test() {
    String deptName = Optional.ofNullable(user)           // 创建 Optional
            .map(User::getDept)                            // 提取 Dept
            .map(Dept::getName)                             // 提取 Dept 的名字
            .filter(StrUtil::isNotBlank)                   // 判断是否为空
            .orElse("未指定部门");                          // 终结操作（默认值）

    System.out.println(deptName);
}

private void test() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    numbers.parallelStream().forEach(n -> {
        System.out.println(n + " - " + Thread.currentThread().getName());
    });
}