Java 从入门到精通：高级特性与底层原理实战全指南

// JDK 5 之前：类型不安全
List list = new ArrayList();
list.add("Hello");
list.add(123);  // 编译不报错
String s = (String) list.get(1);  // 运行时报 ClassCastException

List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123);  // 编译直接报错，类型安全在编译期保证

// 泛型类
public class Box<T> {
    private T content;
    public void put(T content) { this.content = content; }
    public T get() { return content; }
}

// 泛型方法：类型参数在返回值之前声明
public static <T> T firstNonNull(T a, T b) {
    return a != null ? a : b;
}

// 调用时类型推断
String result = firstNonNull(null, "default");  // 自动推断 T = String

// ? extends T：上界通配符（生产者，只读）
// 表示"某种 T 或 T 的子类"
List<? extends Number> numbers = new ArrayList<Integer>();
Number n = numbers.get(0);  // ✅ 可以读（一定是 Number 或子类）
// numbers.add(1);  // ❌ 编译错误：不知道具体是哪种 Number，不能写

// ? super T：下界通配符（消费者，只写）
// 表示"某种 T 或 T 的父类"
List<? super Integer> integers = new ArrayList<Number>();
// Number n = integers.get(0);  // ❌ 编译错误：只能保证读出来是 Object
integers.add(1);  // ✅ 可以写（Integer 一定是列表元素的子类）

// 无界通配符 ?
List<?> unknown = new ArrayList<String>();
Object obj = unknown.get(0);  // 只能读为 Object

// 标准库中的经典例子
public static <T extends Comparable<? super T>> void sort(List<T> list) {
    // T 需要能被比较（产生 Comparable 值），所以用 extends
    // Comparable 消费 T（compareTo 接收 T 参数），但 Comparable 本身用 ? super T
    // 这样父类的 Comparator 也能用于子类排序
}

// 源码
Box<String> stringBox = new Box<>();
Box<Integer> intBox = new Box<>();

// 编译后等价于
Box stringBox = new Box();
Box intBox = new Box();

System.out.println(stringBox.getClass() == intBox.getClass());  // true
// 因为运行时都是 Box.class

// ❌ 不能创建泛型数组
// List<String>[] array = new List<String>[10];  // 编译错误

// ❌ 不能做泛型类型的运行时检查
// if (obj instanceof List<String>) { }  // 编译错误

// ✅ 可以用无界通配符检查
if (obj instanceof List<?>) { }  // 合法

// ❌ 不能捕获泛型类型的异常
// catch (T e) { }  // 编译错误

// 单一约束
public class Container<T extends Number & Comparable<T>> {
    // T 必须同时是 Number 的子类且实现 Comparable<T>
}

// 多个约束用 where（Java 没有 where，用 & 连接）
// 注意：& 后面如果跟接口，可以有多个；如果跟类，只能有一个且必须在第一个

// 方法签名中的约束
public static <T extends Comparable<T>> T max(Collection<T> collection) {
    return collection.stream().max(Comparator.naturalOrder()).orElse(null);
}

// 获取 Class 对象的三种方式
Class<?> clazz1 = Class.forName("com.example.User");  // 最常见
Class<?> clazz2 = User.class;                         // 编译期已知类型
Class<?> clazz3 = userInstance.getClass();            // 运行时获取

// 获取构造器
Constructor<?> constructor = clazz1.getDeclaredConstructor(String.class, int.class);
constructor.setAccessible(true);  // 跳过访问检查（访问 private 构造器）
User user = (User) constructor.newInstance("Alice", 25);

// 获取方法
Method method = clazz1.getDeclaredMethod("getName");
String name = (String) method.invoke(user);

// 获取字段
Field field = clazz1.getDeclaredField("age");
field.setAccessible(true);
int age = field.getInt(user);
field.setInt(user, 26);  // 修改字段值

// Spring 内部简化伪代码
public Object createBean(Class<?> beanClass) throws Exception {
    // 1. 找到合适的构造器
    Constructor<?> constructor = beanClass.getDeclaredConstructor();

    // 2. 创建实例
    Object instance = constructor.newInstance();

    // 3. 扫描字段上的 @Autowired 注解
    for (Field field : beanClass.getDeclaredFields()) {
        if (field.isAnnotationPresent(Autowired.class)) {
            Object dependency = getBean(field.getType());
            field.setAccessible(true);
            field.set(instance, dependency);  // 注入依赖
        }
    }

    // 4. 调用 @PostConstruct 标注的方法
    for (Method method : beanClass.getDeclaredMethods()) {
        if (method.isAnnotationPresent(PostConstruct.class)) {
            method.setAccessible(true);
            method.invoke(instance);
        }
    }

    return instance;
}

public class LoggingProxy {
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T target) {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                System.out.println("Before: " + method.getName());
                Object result = method.invoke(target, args);
                System.out.println("After: " + method.getName());
                return result;
            }
        );
    }
}

// 使用
UserService realService = new UserServiceImpl();
UserService proxy = LoggingProxy.createProxy(realService);
proxy.createUser("Alice");
// 输出:
// Before: createUser
// After: createUser

// 方式一：缓存 Method 对象
private static final Method cachedMethod;
static {
    try {
        cachedMethod = User.class.getMethod("getName");
    } catch (NoSuchMethodException e) {
        throw new RuntimeException(e);
    }
}
// 后续调用直接使用缓存的 Method
String name = (String) cachedMethod.invoke(user);

// 方式二：使用 MethodHandle（JDK 7+，更快）
MethodHandle handle = MethodHandles.lookup()
    .findVirtual(User.class, "getName", MethodType.methodType(String.class));
String name = (String) handle.invoke(user);

// 方式三：使用 VarHandle（JDK 9+，字段访问最快）
// 适合字段级别的高性能反射访问

// JDK 26 之前
Field field = User.class.getDeclaredField("id");
field.setAccessible(true);
field.set(user, "hacked-id");  // 可以修改 private final 字段

// JDK 26 起
field.set(user, "hacked-id");  // 抛出 IllegalAccessException
// private final 字段一旦初始化，就真的不可变了

// 内置注解
@Override          // 编译期检查方法是否正确重写
@Deprecated        // 标记废弃，调用处会警告
@SuppressWarnings  // 压制编译器警告
@SafeVarargs       // 标记可变参数方法类型安全
@FunctionalInterface  // 编译期检查是否为合法函数式接口

// 元注解（用来定义注解的注解）
@Target(ElementType.METHOD)      // 该注解可以用在什么地方
@Retention(RetentionPolicy.RUNTIME)  // 保留到运行时（可反射读取）
@Documented                      // 包含在 Javadoc 中
@Inherited                       // 子类自动继承该注解
@Repeatable                      // 允许在同一位置重复使用

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecution {
    String value() default "";        // 默认值
    LogLevel level() default LogLevel.INFO;
    boolean recordArgs() default true;
}

public enum LogLevel { DEBUG, INFO, WARN, ERROR }

public class LogExecutionAspect {
    public static <T> T createProxy(T target) {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                LogExecution log = method.getAnnotation(LogExecution.class);
                if (log != null && log.recordArgs()) {
                    System.out.println("[LOG] " + method.getName() +
                        " args: " + Arrays.toString(args));
                }
                try {
                    Object result = method.invoke(target, args);
                    return result;
                } catch (Exception e) {
                    if (log != null && log.level() == LogLevel.ERROR) {
                        System.err.println("[ERROR] " + method.getName() + ": " + e.getMessage());
                    }
                    throw e;
                }
            }
        );
    }
}

// 使用
@LogExecution(recordArgs = true, level = LogLevel.ERROR)
public void deleteUser(String userId) {
    // 业务逻辑
}

// 编译期注解处理器（简化示例）
@SupportedAnnotationTypes("com.example.AutoToString")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class AutoToStringProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(AutoToString.class)) {
            // 在编译期生成 toString() 方法的字节码/源码
            generateToStringMethod(element);
        }
        return true;  // 注解已处理
    }
}

@Repeatable(Schedules.class)
@interface Schedule {
    String day();
}

@interface Schedules {
    Schedule[] value();
}

// 使用
@Schedule(day = "Monday")
@Schedule(day = "Wednesday")
@Schedule(day = "Friday")
public void meeting() { }

// 读取
Schedule[] schedules = method.getAnnotationsByType(Schedule.class);

// 方式一：继承 Thread
new Thread() {
    @Override public void run() { System.out.println("Running"); }
}.start();

// 方式二：实现 Runnable（推荐）
new Thread(() -> System.out.println("Running")).start();

// 方式三：Callable + Future（有返回值）
ExecutorService executor = Executors.newFixedThreadPool(4);
Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Done";
});
String result = future.get();  // 阻塞等待结果

// 推荐的线程池创建方式（手动控制参数，避免 OOM）
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    4,              // corePoolSize：核心线程数
    8,              // maximumPoolSize：最大线程数
    60, TimeUnit.SECONDS,  // 空闲线程存活时间
    new ArrayBlockingQueue<>(100),  // 任务队列
    new ThreadFactory() {
        private final AtomicInteger counter = new AtomicInteger();
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "worker-" + counter.incrementAndGet());
            t.setDaemon(false);
            return t;
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略：调用者线程执行
);

// 链式异步编排
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务 1
    return fetchDataFromApi();
}).thenApply(data -> {
    // 处理结果
    return data.toUpperCase();
}).thenAccept(result -> {
    // 消费结果
    System.out.println(result);
}).exceptionally(ex -> {
    // 异常处理
    System.err.println("Error: " + ex.getMessage());
    return null;
});

// 多个 CompletableFuture 组合
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "World");

// 全部完成后执行
CompletableFuture.allOf(f1, f2).thenRun(() -> {
    String combined = f1.join() + " " + f2.join();
    System.out.println(combined);  // "Hello World"
});

// 任一完成后执行
CompletableFuture.anyOf(f1, f2).thenAccept(result -> {
    System.out.println("First completed: " + result);
});

// synchronized：内置锁，JVM 级别优化（偏向锁 → 轻量级锁 → 重量级锁）
public synchronized void increment() {
    count++;
}

// ReentrantLock：API 级别锁，更灵活
private final ReentrantLock lock = new ReentrantLock();

public void doSomething() {
    lock.lock();
    try {
        // 临界区
    } finally {
        lock.unlock();  // 必须在 finally 中释放
    }
}

// ReentrantLock 高级功能
ReentrantLock lock = new ReentrantLock();

// 尝试获取锁（不阻塞）
if (lock.tryLock()) {
    try { /* ... */ } finally { lock.unlock(); }
}

// 超时等待
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try { /* ... */ } finally { lock.unlock(); }
}

// 公平锁（按请求顺序分配）
ReentrantLock fairLock = new ReentrantLock(true);

ReadWriteLock rwLock = new ReentrantReadWriteLock();

public String read() {
    rwLock.readLock().lock();
    try {
        return data;  // 多个读线程可并发
    } finally {
        rwLock.readLock().unlock();
    }
}

public void write(String newData) {
    rwLock.writeLock().lock();  // 写锁互斥
    try {
        this.data = newData;
    } finally {
        rwLock.writeLock().unlock();
    }
}

// AtomicInteger：基于 CAS 的原子整数
AtomicInteger counter = new AtomicInteger(0);

counter.incrementAndGet();      // 原子自增，线程安全
counter.compareAndSet(5, 10);   // 如果当前值是5，则设为10
counter.getAndUpdate(x -> x * 2);  // 原子更新

// 原子引用
AtomicReference<User> userRef = new AtomicReference<>();
userRef.compareAndSet(null, new User("Alice"));

// LongAdder：高并发下比 AtomicLong 更快（分段计数）
LongAdder longAdder = new LongAdder();
longAdder.increment();
long total = longAdder.sum();  // 求总和

// 传统线程：每个线程绑定一个 OS 线程，内存开销大（约 1MB/线程）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // 虚拟线程：轻量级，每个仅几百字节，可以轻松创建百万级
    IntStream.range(0, 1_000_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));  // 挂起时不占用 OS 线程
            return i;
        });
    });
}  // 自动等待所有虚拟线程完成

// JEP 525（Java 26 第六次预览）
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    // 启动子任务
    Subtask<User> userTask = scope.fork(() -> findUser(userId));
    Subtask<Order> orderTask = scope.fork(() -> fetchOrder(orderId));

    // 等待所有子任务完成，任一失败则取消其余
    scope.join().throwIfFailed();

    // 处理结果
    User user = userTask.get();
    Order order = orderTask.get();
    return new Response(user, order);
}  // 作用域结束，所有子任务保证已完成或已取消

JVM 运行时数据区
├── 线程私有
│   ├── 程序计数器（PC Register）：当前线程执行的字节码行号
│   ├── 虚拟机栈（JVM Stack）：方法调用栈帧（局部变量表、操作数栈）
│   └── 本地方法栈（Native Method Stack）：Native 方法调用
├── 线程共享
│   ├── 堆（Heap）：对象实例、数组（GC 的主要区域）
│   │   ├── 新生代（Young Generation）
│   │   │   ├── Eden 区（新对象分配）
│   │   │   └── Survivor 区（S0/S1，Minor GC 后存活对象）
│   │   └── 老年代（Old Generation）
│   │       └── 经历多次 GC 后仍然存活的对象
│   └── 元空间（Metaspace）：类元数据、常量池、方法信息
│       └── JDK 8 替代了永久代（PermGen），使用本地内存
└── 直接内存（Direct Memory）：NIO 的 ByteBuffer.allocateDirect()

// 1. 类加载阶段：JVM 将 .class 文件加载到元空间
Class<?> clazz = Class.forName("com.example.User");

// 2. 对象创建：new 指令在堆上分配内存
User user = new User("Alice");  // Eden 区分配

// 3. 对象访问：通过引用访问对象
String name = user.getName();

// 4. 对象可达性分析：GC 从 GC Roots 开始追踪
//    - GC Roots 包括：栈帧中的局部变量、静态变量、JNI 引用等
//    - 无法从 GC Roots 到达的对象 → 可回收

// 5. 对象晋升：Eden → Survivor → Old Generation
//    - 默认经过 15 次 Minor GC 后晋升到老年代（-XX:MaxTenuringThreshold）
//    - 大对象直接进入老年代（-XX:PretenureSizeThreshold）

G1 将堆划分为多个大小相等的 Region，不再区分新生代/老年代的物理边界。
优势：可预测的停顿时间（-XX:MaxGCPauseMillis=200）

# 启用 G1 并配置参数
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:G1HeapRegionSize=4m \
     -Xms4g -Xmx4g \
     -jar app.jar

ZGC 使用染色指针和读屏障技术，停顿时间不超过 1ms。
JDK 21 引入分代 ZGC（Generational ZGC），结合分代回收优势，吞吐量大幅提升。

# 启用 ZGC（JDK 21+）
java -XX:+UseZGC -Xms4g -Xmx4g -jar app.jar

# 分代 ZGC（默认启用）
java -XX:+UseZGC -XX:+ZGenerational -Xms4g -Xmx4g -jar app.jar

# 1. OOM 时自动 dump 堆
java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/tmp/heapdump.hprof \
     -jar app.jar

# 2. 手动触发 dump
jmap -dump:format=b,file=heap.hprof <pid>

# 3. 分析 dump 文件
# 使用 MAT（Memory Analyzer Tool）、JProfiler、YourKit 等工具

# 4. 查看 GC 日志
java -Xlog:gc*:file=gc.log:time,uptime,level,tags \
     -jar app.jar

# 5. 实时监控
jstat -gcutil <pid> 1000  # 每秒输出 GC 统计
jcmd <pid> GC.run         # 手动触发 GC

// 场景一：静态集合未清理
public class Cache {
    private static final Map<String, Object> cache = new HashMap<>();
    public static void put(String key, Object value) {
        cache.put(key, value);  // 永远不删除，最终 OOM
    }
}

// 场景二：未关闭资源
InputStream is = new FileInputStream("file.txt");
// is.close();  // 忘记关闭
// 正确做法：
try (InputStream is = new FileInputStream("file.txt")) {
    // try-with-resources 自动关闭
}

// 场景三：ThreadLocal 未清理
private static final ThreadLocal<Context> context = new ThreadLocal<>();
context.set(new Context());
// context.remove();  // 线程池复用时，ThreadLocal 不会自动清理

// C1（Client Compiler）：快速编译，优化较少，适合启动阶段
// C2（Server Compiler）：深度优化，编译慢，适合运行阶段
// GraalVM AOT：提前编译为本地机器码，启动即高性能

// 查看 JIT 编译信息
java -XX:+PrintCompilation -jar app.jar
// 输出: 123  456    3  java.lang.String::hashCode (55 bytes)
//       ^   ^     ^  ^
//     编译ID 编译方法级别 编译字节数

// 方法内联：JVM 自动将小方法内联到调用点
// -XX:MaxInlineSize=35  // 最大内联字节码大小（默认 35）
// -XX:FreqInlineSize=325  // 频繁调用方法的最大内联大小

# 生成 AOT 缓存
java -XX:AOTMode=store -jar app.jar
# 下次启动时自动加载 AOT 缓存，跳过 JIT 预热阶段
# 启动时间显著缩短，特别适合容器化部署

1. 加载（Loading）：将 .class 文件字节码读入 JVM，创建 Class 对象
2. 链接（Linking）
   ├── 验证（Verification）：字节码合法性检查
   ├── 准备（Preparation）：为 static 字段分配内存，赋默认值
   └── 解析（Resolution）：符号引用转为直接引用
3. 初始化（Initialization）：执行 static 代码块和 static 字段初始值

Bootstrap ClassLoader（启动类加载器）
    ├── 加载 Java 核心类库（java.lang.*, java.util.* 等）
    ├── C++ 实现，Java 代码无法引用
    │
    ├──> Extension ClassLoader（扩展类加载器）
    │       ├── 加载 ext 目录中的类
    │       ├── sun.misc.Launcher$ExtClassLoader
    │       │
    │       └──> Application ClassLoader（应用类加载器）
    │               ├── 加载 classpath 中的类
    │               ├── sun.misc.Launcher$AppClassLoader
    │               │
    │               └──> Custom ClassLoader（自定义类加载器）

public class MyClassLoader extends ClassLoader {
    private final Path classPath;

    public MyClassLoader(Path classPath) {
        super(MyClassLoader.class.getClassLoader());  // 父加载器
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 父加载器先加载（双亲委派）
        try {
            return getParent().loadClass(name);
        } catch (ClassNotFoundException e) {
            // 父加载器无法加载，自己加载
        }

        try {
            Path path = classPath.resolve(name.replace('.', '/') + ".class");
            byte[] bytes = Files.readAllBytes(path);
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
}

// 传统方式需要几十行代码
public record User(String name, int age, String email) {
    // 紧凑构造函数（用于参数校验）
    public User {
        if (age < 0) throw new IllegalArgumentException("Age cannot be negative");
    }

    // 自定义方法
    public String greeting() {
        return "Hello, " + name;
    }
}

// 使用
User user = new User("Alice", 25, "alice@example.com");
System.out.println(user.name());      // getter 是 name() 而不是 getName()
System.out.println(user.greeting());  // "Hello, Alice"

// 旧写法
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// 新写法
if (obj instanceof String s) {
    System.out.println(s.length());  // s 在 if 块中自动可用
}

// 旧写法
String formatted = switch (obj.getClass().getSimpleName()) {
    case "Integer" -> "int: " + ((Integer) obj).intValue();
    case "Long"    -> "long: " + ((Long) obj).longValue();
    case "String"  -> "string: " + ((String) obj);
    default        -> "unknown";
};

// 新写法
String formatted = switch (obj) {
    case Integer i -> "int: " + i.intValue();
    case Long l    -> "long: " + l.longValue();
    case String s  -> "string: " + s;
    case null      -> "null";
    default        -> "unknown: " + obj;
};

sealed interface Shape permits Circle, Rectangle, Triangle { }
record Circle(double radius) implements Shape { }
record Rectangle(double width, double height) implements Shape { }
record Triangle(double base, double height) implements Shape { }

double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> 0.5 * t.base() * t.height();
    };  // 编译器保证穷尽，无需 default
}

// 密封类：只允许指定的类继承
public sealed interface Result permits Success, Failure { }

public final class Success implements Result {
    private final Object data;
    public Success(Object data) { this.data = data; }
    public Object getData() { return data; }
}

public final class Failure implements Result {
    private final Throwable error;
    public Failure(Throwable error) { this.error = error; }
    public Throwable getError() { return error; }
}

// 不能有其他类实现 Result
// public class Unknown implements Result { }  // 编译错误

String name = "Alice";
int age = 25;

// 旧写法
String info = String.format("Name: %s, Age: %d", name, age);

// 新写法（STR 是内置模板处理器）
String info = STR."Name: \{name}, Age: \{age}";

// 可以自定义模板处理器
String json = JSON."""
    {
        "name": "\{name}",
        "age": \{age}
    }
    """;

// 调用 C 标准库的 strlen
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();
MethodHandle strlen = linker.downcallHandle(
    stdlib.find("strlen").orElseThrow(),
    FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
);

try (Arena arena = Arena.ofConfined()) {
    MemorySegment cString = arena.allocateUtf8String("Hello, World!");
    long len = (long) strlen.invoke(cString);
    System.out.println("Length: " + len);  // 12
}

// Lombok 方式
@Builder
public class User {
    private String name;
    private int age;
    private String email;
}

// 使用
User user = User.builder()
    .name("Alice")
    .age(25)
    .email("alice@example.com")
    .build();

// 传统策略模式
interface DiscountStrategy {
    double applyDiscount(double price);
}

class NoDiscount implements DiscountStrategy {
    public double applyDiscount(double price) { return price; }
}

class PercentageDiscount implements DiscountStrategy {
    private final double percentage;
    public PercentageDiscount(double p) { this.percentage = p; }
    public double applyDiscount(double price) { return price * (1 - percentage); }
}

// 函数式替代（推荐）
public class PriceCalculator {
    public static double apply(double price, UnaryOperator<Double> strategy) {
        return strategy.apply(price);
    }
}

// 使用
double finalPrice = PriceCalculator.apply(100.0, p -> p * 0.9);  // 9折

public sealed interface Message permits TextMessage, ImageMessage, VideoMessage {
    String content();
}

public record TextMessage(String text) implements Message {
    public String content() { return text; }
}
public record ImageMessage(String url, int width, int height) implements Message {
    public String content() { return "[Image: " + url + "]"; }
}
public record VideoMessage(String url, int duration) implements Message {
    public String content() { return "[Video: " + url + "]"; }
}

// 工厂方法
public class MessageFactory {
    public static Message create(String type, String content) {
        return switch (type) {
            case "text"  -> new TextMessage(content);
            case "image" -> new ImageMessage(content, 800, 600);
            case "video" -> new VideoMessage(content, 120);
            default -> throw new IllegalArgumentException("Unknown type: " + type);
        };
    }
}

// ❌ 错误用法
Optional<User> optionalUser = userRepository.findById(id);
if (optionalUser.isPresent()) {
    User user = optionalUser.get();
    System.out.println(user.getName());
}

// ✅ 正确用法
userRepository.findById(id)
    .ifPresent(user -> System.out.println(user.getName()));

// 有默认值
String name = userRepository.findById(id)
    .map(User::getName)
    .orElse("Unknown");

// 抛异常
User user = userRepository.findById(id)
    .orElseThrow(() -> new UserNotFoundException(id));

// 链式操作
Optional<String> email = userRepository.findById(id)
    .filter(u -> u.isActive())
    .map(User::getEmail)
    .filter(e -> e.endsWith("@example.com"));

# 内存设置
-Xms2g                    # 初始堆大小
-Xmx4g                    # 最大堆大小
-XX:MetaspaceSize=256m    # 元空间初始大小
-XX:MaxMetaspaceSize=512m # 元空间上限

# GC 选择
-XX:+UseG1GC              # 使用 G1（JDK 9+ 默认）
-XX:+UseZGC               # 使用 ZGC
-XX:MaxGCPauseMillis=200  # G1 最大停顿目标（毫秒）

# 调试
-XX:+HeapDumpOnOutOfMemoryError  # OOM 时自动 dump
-XX:HeapDumpPath=/tmp/heap.hprof # dump 文件路径
-Xlog:gc*:file=gc.log      # GC 日志（JDK 9+）
-XX:+PrintGCDetails        # 详细 GC 日志（JDK 8）

# 性能
-XX:+UseStringDeduplication  # G1 字符串去重
-XX:+AlwaysPreTouch          # 启动时预分配内存（减少首次 GC 延迟）
-XX:MaxInlineSize=35         # 方法内联阈值