现代Java特性精选

// 传统写法：类型信息重复出现
ArrayList<String> names = new ArrayList<String>();
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

// 使用 var：编译器自动推断类型
var names = new ArrayList<String>();   // 推断为 ArrayList<String>
var reader = new BufferedReader(new InputStreamReader(System.in)); // 推断为 BufferedReader

var count = 10;          // 编译器推断为 int（不是 Integer）
var message = "Hello";   // 编译器推断为 String
var pi = 3.14;           // 编译器推断为 double
 
// 编译后的字节码与下面的写法完全等价：
int count = 10;
String message = "Hello";
double pi = 3.14;

// ✅ 合法场景
var list = new ArrayList<String>();       // 局部变量声明 + 初始化
var stream = list.stream();               // 方法返回值推断
var entry = Map.entry("key", "value");    // 工厂方法返回值推断
 
for (var item : list) {                   // 增强 for 循环中的迭代变量
    System.out.println(item);
}
 
for (var i = 0; i < 10; i++) {            // 传统 for 循环中的索引变量
    System.out.println(i);
}
 
try (var in = new FileInputStream("f")) { // try-with-resources 中的资源变量
    // ...
}

// ❌ 非法场景
var x;                        // 没有初始化，编译器无法推断
var nothing = null;           // null 没有类型信息
var lambda = () -> "hello";   // Lambda 需要目标类型（functional interface）
var methodRef = String::length; // 方法引用同理
 
// ❌ 不能用于方法参数、返回值、成员变量
public var getName() { ... }  // 编译错误
private var age = 25;         // 编译错误（成员变量不行）
public void setName(var n) {} // 编译错误

// 明确指定泛型参数 → 推断为 ArrayList<String>
var list1 = new ArrayList<String>();
 
// 菱形运算符 + var → 推断为 ArrayList<Object>！
// 因为编译器两边都没有足够的类型信息
var list2 = new ArrayList<>();  // ⚠️ 实际类型是 ArrayList<Object>
 
list2.add("hello");  // 编译通过
list2.add(123);      // 也通过！因为是 Object

// ✅ 好的用法：右侧已经清楚表明类型，var 减少冗余
var connection = DriverManager.getConnection(url);  // 显然是 Connection
var mapper = new ObjectMapper();                     // 显然是 ObjectMapper
var users = userRepository.findAll();                // 返回类型在方法名中已暗示
 
// ❌ 坏的用法：右侧看不出类型，var 让人一头雾水
var result = process(data);       // result 是什么类型？完全不知道
var x = calculate();              // x 是 int？double？BigDecimal？
var obj = getPayload();           // 毫无类型线索

// 传统 switch 语句
String dayType;
switch (day) {
    case MONDAY:
    case TUESDAY:
    case WEDNESDAY:
    case THURSDAY:
    case FRIDAY:
        dayType = "工作日";  // 必须在外部声明变量
        break;               // 忘写 break 就会 fall-through 到下一个 case
    case SATURDAY:
    case SUNDAY:
        dayType = "周末";
        break;
    default:
        dayType = "未知";
        break;
}

// switch 表达式 + 箭头语法
String dayType = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "工作日";  // 多个 case 用逗号合并
    case SATURDAY, SUNDAY -> "周末";                                 // 无需 break，不会 fall-through
    // 注意：作为表达式使用时，必须穷举所有可能值，否则需要 default
};  // switch 表达式是一个值，赋给 dayType，末尾有分号

var result = switch (status) {
    case "OK" -> 200;                          // 1. 单个表达式（最常见）
 
    case "NOT_FOUND" -> {                      // 2. 代码块（多条语句时使用）
        log.warn("Resource not found");        //    块内可以写任意逻辑
        yield 404;                             //    用 yield 返回值（后面详解）
    }
 
    case "ERROR" -> throw new RuntimeException("Server error"); // 3. 抛出异常
 
    default -> 0;
};

int numericGrade = switch (letterGrade) {
    case "A" -> 4;   // 单表达式，直接返回
    case "B" -> 3;
    case "C" -> 2;
    case "D" -> 1;
    case "F" -> {
        // 代码块中需要执行额外逻辑
        System.out.println("挂科了，需要补考");  // 附加操作
        logFailure(studentId);                    // 附加操作
        yield 0;                                  // 用 yield 返回值
    }
    default -> {
        System.out.println("无效的成绩等级: " + letterGrade);
        yield -1;                                 // default 分支也用 yield
    }
};

// 冒号语法 + yield（不推荐，但合法）
int result = switch (input) {
    case 1:
        System.out.println("处理情况 1");
        yield 10;     // 用 yield 代替 break，同时返回值
    case 2:
        yield 20;
    default:
        yield 0;
};
// 注意：冒号语法仍然存在 fall-through 风险，所以推荐用箭头语法

// 枚举类型
enum Season { SPRING, SUMMER, AUTUMN, WINTER }
 
// ✅ 穷举了所有枚举值，不需要 default
String description = switch (season) {
    case SPRING -> "万物复苏";
    case SUMMER -> "烈日炎炎";
    case AUTUMN -> "秋高气爽";
    case WINTER -> "银装素裹";
};
// 如果未来枚举新增了一个值（如 MONSOON），这里会编译报错，强制你处理
 
// ❌ 非枚举类型（如 String、int），无法穷举，必须有 default
int code = switch (command) {
    case "start" -> 1;
    case "stop"  -> 2;
    // 编译错误！String 无法穷举，必须加 default
};

// 计算不同会员等级的折扣
public double calculateDiscount(String memberLevel, double originalPrice) {
    // switch 表达式直接返回折扣率
    double discountRate = switch (memberLevel.toUpperCase()) {
        case "DIAMOND" -> 0.30;    // 钻石会员 7 折
        case "GOLD"    -> 0.20;    // 金牌会员 8 折
        case "SILVER"  -> 0.10;    // 银牌会员 9 折
        case "BRONZE"  -> 0.05;    // 铜牌会员 95 折
        default -> {
            // 非会员或未知等级，记录日志后不打折
            log.info("非会员用户，等级标识: {}", memberLevel);
            yield 0.0;             // yield 返回 0 折扣
        }
    };
 
    // 直接使用表达式的结果进行计算
    return originalPrice * (1 - discountRate);
}

// 传统写法：拼接 + 转义，可读性极差
String json = "{\n" +
    "  \"name\": \"张三\",\n" +
    "  \"age\": 25,\n" +
    "  \"skills\": [\"Java\", \"Spring\"]\n" +
    "}";
 
String sql = "SELECT u.id, u.name, u.email\n" +
    "FROM users u\n" +
    "JOIN orders o ON u.id = o.user_id\n" +
    "WHERE o.status = 'ACTIVE'\n" +
    "ORDER BY u.name";

// 文本块语法：三引号开头，换行后开始内容，三引号结尾
String json = """
        {
            "name": "张三",
            "age": 25,
            "skills": ["Java", "Spring"]
        }
        """;
 
String sql = """
        SELECT u.id, u.name, u.email
        FROM users u
        JOIN orders o ON u.id = o.user_id
        WHERE o.status = 'ACTIVE'
        ORDER BY u.name
        """;

public void example() {
    // 结尾 """ 的位置决定了缩进基准线
    String text = """
            Line 1
            Line 2
            Line 3
            """;
    // 结果：每行前面没有空格（""" 和内容对齐，公共缩进被剥离）
    // "Line 1\nLine 2\nLine 3\n"
}

源码中的文本块：
│                                          │
│    String s = """                         │
│            Hello        ← 12个空格前缀     │
│            World        ← 12个空格前缀     │
│            """;         ← 结尾"""在第12列   │
│                                          │
│  编译器计算：                              │
│  最小公共缩进 = min(12, 12, 12) = 12      │
│  剥离12个空格后：                          │
│  → "Hello\nWorld\n"                       │

String indented = """
        Hello
        World
    """;  // 结尾 """ 比内容少缩进 4 格
// 结果："    Hello\n    World\n"（每行保留 4 个空格）

// \s → 保留尾部空格（trailing space）
// 普通情况下，编译器会自动去除每行末尾的空白字符
// 用 \s 可以强制保留
String table = """
        Name   \s
        Age    \s
        Email  \s
        """;
// 每行末尾的空格被 \s 保护，不会被剥离
 
// \ → 行尾续行符（line continuation）
// 取消该位置的换行，将下一行拼接到当前行
String singleLine = """
        This is a very long sentence that \
        we want to keep on a single line \
        in the resulting string.""";
// 结果："This is a very long sentence that we want to keep on a single line in the resulting string."

// 使用 formatted()（Java 15+ 的实例方法，推荐）
String name = "张三";
int age = 25;
 
String json = """
        {
            "name": "%s",
            "age": %d
        }
        """.formatted(name, age);
// 结果：
// {
//     "name": "张三",
//     "age": 25
// }
 
// 也可以用传统的 String.format()
String html = String.format("""
        <html>
            <body>
                <h1>Hello, %s!</h1>
            </body>
        </html>
        """, name);

// 1. SQL 查询（最常见的场景之一）
String query = """
        SELECT p.id,
               p.product_name,
               p.price,
               c.category_name
        FROM products p
        INNER JOIN categories c ON p.category_id = c.id
        WHERE p.price > ?
          AND c.active = true
        ORDER BY p.price DESC
        LIMIT 50
        """;
 
// 2. JSON 模板
String requestBody = """
        {
            "method": "POST",
            "headers": {
                "Content-Type": "application/json",
                "Authorization": "Bearer %s"
            },
            "body": {
                "userId": %d,
                "action": "purchase"
            }
        }
        """.formatted(token, userId);
 
// 3. HTML 片段
String emailTemplate = """
        <div style="font-family: Arial, sans-serif;">
            <h2>订单确认</h2>
            <p>尊敬的 %s，您的订单 #%s 已确认。</p>
            <p>预计送达时间：%s</p>
        </div>
        """.formatted(customerName, orderId, deliveryDate);
 
// 4. 多行正则表达式（提高可读性）
String regex = """
        ^(?<year>\\d{4})     # 年份
        -(?<month>\\d{2})    # 月份
        -(?<day>\\d{2})      # 日期
        $""";

// 这两种写法编译后完全等价
String a = """
        Hello
        World""";
 
String b = "Hello\nWorld";
 
System.out.println(a.equals(b));  // true
System.out.println(a == b);       // true（常量池中是同一个对象）

var x = switch ("hello") {
    case "hello" -> {
        var greeting = """
                Hi,
                World""";
        yield greeting.lines().count();
    }
    default -> 0L;
};
System.out.println(x);

// 传统 POJO 写法 —— 仅仅为了承载 x, y 两个字段
public final class Point {
 
    // 1. 私有不可变字段
    private final int x;
    private final int y;
 
    // 2. 全参构造器
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    // 3. getter（Java Bean 风格）
    public int getX() {
        return x;
    }
 
    public int getY() {
        return y;
    }
 
    // 4. equals —— 逐字段比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                          // 同一引用直接返回 true
        if (o == null || getClass() != o.getClass()) return false; // 类型不同返回 false
        Point point = (Point) o;
        return x == point.x && y == point.y;                 // 逐字段比较
    }
 
    // 5. hashCode —— 与 equals 保持一致
    @Override
    public int hashCode() {
        return Objects.hash(x, y);                           // 基于所有字段计算哈希
    }
 
    // 6. toString —— 方便调试输出
    @Override
    public String toString() {
        return "Point[x=" + x + ", y=" + y + "]";           // 可读的字符串表示
    }
}

// 这一行等价于上面 40+ 行的传统 POJO
public record Point(int x, int y) { }

public class RecordDemo {
    // 声明一个 record
    public record Point(int x, int y) { }
 
    public static void main(String[] args) {
        Point p1 = new Point(3, 4);          // 使用自动生成的全参构造器
        Point p2 = new Point(3, 4);          // 创建另一个相同值的实例
 
        // 访问器方法：注意没有 get 前缀
        System.out.println(p1.x());          // 输出: 3
        System.out.println(p1.y());          // 输出: 4
 
        // toString() 自动生成
        System.out.println(p1);              // 输出: Point[x=3, y=4]
 
        // equals() 基于值比较，而非引用比较
        System.out.println(p1.equals(p2));   // 输出: true
        System.out.println(p1 == p2);        // 输出: false（不同对象引用）
 
        // hashCode() 一致性
        System.out.println(p1.hashCode() == p2.hashCode()); // 输出: true
    }
}

// javap -p Point.class 的输出（简化）
public final class Point extends java.lang.Record {
    private final int x;       // 不可变字段
    private final int y;       // 不可变字段
 
    public Point(int x, int y);
    public int x();            // 访问器
    public int y();            // 访问器
    public boolean equals(Object o);
    public int hashCode();
    public String toString();
}

// record 可以实现接口
public interface Printable {
    void prettyPrint();                      // 自定义打印方法
}
 
// 实现接口的 record
public record User(String name, int age) implements Printable {
    @Override
    public void prettyPrint() {              // 实现接口方法
        System.out.println("用户: " + name + ", 年龄: " + age);
    }
}

public record Range(int min, int max) {
 
    // 紧凑构造器：没有参数列表！
    // 编译器会在末尾自动添加 this.min = min; this.max = max;
    public Range {
        // 参数校验
        if (min > max) {
            throw new IllegalArgumentException(
                "min（" + min + "）不能大于 max（" + max + "）"
            );
        }
        // 数据规范化：可以直接修改参数变量（注意不是字段）
        // 例如确保 min 不为负数
        if (min < 0) {
            min = 0;                         // 修改的是参数，不是字段
        }
        // 编译器在此处隐式插入：
        // this.min = min;
        // this.max = max;
    }
}

public record Email(String localPart, String domain) {
 
    // 规范构造器：参数列表必须与组件列表一致
    public Email(String localPart, String domain) {
        // 手动校验
        Objects.requireNonNull(localPart, "localPart 不能为 null");
        Objects.requireNonNull(domain, "domain 不能为 null");
 
        // 规范化：统一转小写
        this.localPart = localPart.trim().toLowerCase();  // 必须手动赋值
        this.domain = domain.trim().toLowerCase();         // 必须手动赋值
    }
}

public record Point(int x, int y) {
 
    // 额外构造器：创建原点
    public Point() {
        this(0, 0);                          // 必须委托给规范构造器
    }
 
    // 额外构造器：从极坐标创建
    public Point(double r, double theta) {
        this(                                // 必须委托给规范构造器
            (int) (r * Math.cos(theta)),     // 极坐标转直角坐标 x
            (int) (r * Math.sin(theta))      // 极坐标转直角坐标 y
        );
    }
}

public record Product(String name, double price, int quantity) {
 
    // 1. 静态字段 —— 允许
    public static final double TAX_RATE = 0.13;       // 税率常量
 
    // 2. 静态方法 —— 允许
    public static Product free(String name) {          // 工厂方法
        return new Product(name, 0, 0);
    }
 
    // 3. 实例方法 —— 允许（这是 record 非常实用的能力）
    public double totalPrice() {                       // 计算总价
        return price * quantity;                       // 直接访问组件
    }
 
    public double totalWithTax() {                     // 含税总价
        return totalPrice() * (1 + TAX_RATE);          // 调用自身方法
    }
 
    // 4. 紧凑构造器 —— 校验
    public Product {
        if (price < 0) {                               // 价格不能为负
            throw new IllegalArgumentException("价格不能为负数");
        }
        if (quantity < 0) {                            // 数量不能为负
            throw new IllegalArgumentException("数量不能为负数");
        }
    }
 
    // 5. 覆盖自动生成的 toString()
    @Override
    public String toString() {
        return name + " | 单价: " + price + " | 数量: " + quantity
             + " | 总价: " + totalPrice();
    }
 
    // ❌ 不允许：实例字段（非组件字段）
    // private int discount;  // 编译错误！record 不允许声明额外的实例字段
}

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
 
public record Team(String name, List<String> members) {
 
    // 紧凑构造器：实现防御性拷贝，达到深层不可变
    public Team {
        Objects.requireNonNull(name, "队名不能为 null");
        Objects.requireNonNull(members, "成员列表不能为 null");
        // 防御性拷贝：创建不可变副本，切断外部引用
        members = List.copyOf(members);
    }
}

public class ImmutabilityDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");                              // 初始成员
        names.add("Bob");                                // 初始成员
 
        Team team = new Team("Dev", names);              // 创建 record
 
        // 尝试通过原始列表修改
        names.add("Charlie");                            // 修改外部列表
        System.out.println(team.members());              // [Alice, Bob] —— 不受影响！
 
        // 尝试通过访问器修改
        // team.members().add("Dave");                   // 抛出 UnsupportedModificationException
    }
}

// ===== 无防御性拷贝（浅层不可变，危险！）=====
//
//   外部变量 names ──────┐
//                        ▼
//   Team.members ──→ [ArrayList] ← 同一个对象！外部修改会影响 record
//
//
// ===== 有防御性拷贝（深层不可变，安全）=====
//
//   外部变量 names ──→ [ArrayList]        ← 外部的，随便改
//
//   Team.members ────→ [UnmodifiableList] ← record 持有独立副本，且不可修改

// 泛型 record：通用的键值对
public record Pair<A, B>(A first, B second) {
 
    // 静态工厂方法，利用类型推断简化创建
    public static <A, B> Pair<A, B> of(A first, B second) {
        return new Pair<>(first, second);    // 类型由参数推断
    }
 
    // 交换键值
    public Pair<B, A> swap() {
        return new Pair<>(second, first);    // 返回类型参数互换的新 Pair
    }
}
 
// 泛型 record：API 统一响应体
public record ApiResponse<T>(int code, String message, T data) {
 
    // 成功响应的工厂方法
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "OK", data);
    }
 
    // 失败响应的工厂方法
    public static <T> ApiResponse<T> error(int code, String message) {
        return new ApiResponse<>(code, message, null);
    }
 
    // 判断是否成功
    public boolean isSuccess() {
        return code >= 200 && code < 300;    // 2xx 状态码视为成功
    }
}

public class GenericRecordDemo {
    public static void main(String[] args) {
        // Pair 的使用
        Pair<String, Integer> entry = Pair.of("age", 25);  // 类型推断
        System.out.println(entry);                          // Pair[first=age, second=25]
        System.out.println(entry.swap());                   // Pair[first=25, second=age]
 
        // ApiResponse 的使用
        var resp = ApiResponse.success(List.of("Java", "Kotlin"));
        System.out.println(resp.code());                    // 200
        System.out.println(resp.data());                    // [Java, Kotlin]
        System.out.println(resp.isSuccess());               // true
    }
}

// 用 sealed interface + record 定义一个表达式 AST（抽象语法树）
public sealed interface Expr
    permits Expr.Num, Expr.Add, Expr.Mul, Expr.Neg {
 
    // 数字字面量
    record Num(double value) implements Expr { }
 
    // 加法：左操作数 + 右操作数
    record Add(Expr left, Expr right) implements Expr { }
 
    // 乘法：左操作数 × 右操作数
    record Mul(Expr left, Expr right) implements Expr { }
 
    // 取反：-操作数
    record Neg(Expr operand) implements Expr { }
}

public class ExprEvaluator {
 
    // 递归求值方法 —— 模式匹配 switch（Java 21+）
    public static double eval(Expr expr) {
        return switch (expr) {
            case Expr.Num(var value)            // 解构 Num，提取 value
                 -> value;
            case Expr.Add(var left, var right)  // 解构 Add，提取左右子表达式
                 -> eval(left) + eval(right);   // 递归求值后相加
            case Expr.Mul(var left, var right)  // 解构 Mul
                 -> eval(left) * eval(right);   // 递归求值后相乘
            case Expr.Neg(var operand)          // 解构 Neg
                 -> -eval(operand);             // 递归求值后取反
        };
        // 注意：因为 Expr 是 sealed 的，编译器知道所有子类型已穷举
        // 所以不需要 default 分支！
    }
 
    public static void main(String[] args) {
        // 构建表达式：-(3 + 4) * 2
        Expr expr = new Expr.Mul(
            new Expr.Neg(
                new Expr.Add(
                    new Expr.Num(3),             // 数字 3
                    new Expr.Num(4)              // 数字 4
                )
            ),
            new Expr.Num(2)                      // 数字 2
        );
 
        System.out.println(eval(expr));          // 输出: -14.0
    }
}

import java.io.Serializable;
 
// record 实现 Serializable
public record Config(String host, int port) implements Serializable {
 
    // 紧凑构造器中的校验，在反序列化时同样执行
    public Config {
        if (port < 0 || port > 65535) {
            throw new IllegalArgumentException("端口号必须在 0-65535 之间");
        }
    }
}

// ===== 传统类反序列化 =====
// ObjectInputStream 使用 Unsafe/反射 直接写入字段
// 完全绕过构造器 → 校验逻辑不执行 → 可能产生非法对象！
//
// ===== record 反序列化 =====
// ObjectInputStream 调用规范构造器重建对象
// 构造器中的校验逻辑正常执行 → 非法数据被拦截 → 安全！

// Jackson 示例
import com.fasterxml.jackson.databind.ObjectMapper;
 
public record UserDTO(String username, String email, int age) { }
 
// 序列化 / 反序列化
ObjectMapper mapper = new ObjectMapper();
 
UserDTO user = new UserDTO("kiro", "kiro@example.com", 3);
String json = mapper.writeValueAsString(user);             // 序列化为 JSON
// {"username":"kiro","email":"kiro@example.com","age":3}
 
UserDTO restored = mapper.readValue(json, UserDTO.class);  // 从 JSON 反序列化
System.out.println(restored.username());                    // kiro

import java.time.Instant;
import java.util.List;
import java.util.Map;
import java.util.UUID;
 
// 1. 事件基础接口（sealed）
public sealed interface DomainEvent
    permits OrderCreated, OrderPaid, OrderCancelled {
 
    UUID eventId();                                      // 事件唯一标识
    Instant occurredAt();                                // 发生时间
}
 
// 2. 具体事件 —— 全部用 record 实现
public record OrderCreated(
    UUID eventId,                                        // 事件 ID
    Instant occurredAt,                                  // 发生时间
    String orderId,                                      // 订单号
    List<LineItem> items                                 // 订单行项目
) implements DomainEvent {
 
    // 紧凑构造器：防御性拷贝 + 校验
    public OrderCreated {
        items = List.copyOf(items);                      // 不可变副本
        if (items.isEmpty()) {
            throw new IllegalArgumentException("订单至少需要一个商品");
        }
    }
 
    //便捷工厂方法
    public static OrderCreated now(String orderId, List<LineItem> items) {
        return new OrderCreated(
            UUID.randomUUID(),                           // 自动生成事件 ID
            Instant.now(),                               // 当前时间戳
            orderId,
            items
        );
    }
}
 
// 订单已支付
public record OrderPaid(
    UUID eventId,
    Instant occurredAt,
    String orderId,
    double amount,                                       // 支付金额
    String paymentMethod                                 // 支付方式
) implements DomainEvent {
 
    public static OrderPaid now(String orderId, double amount, String method) {
        return new OrderPaid(UUID.randomUUID(), Instant.now(), orderId, amount, method);
    }
}
 
// 订单已取消
public record OrderCancelled(
    UUID eventId,
    Instant occurredAt,
    String orderId,
    String reason                                        // 取消原因
) implements DomainEvent {
 
    public OrderCancelled {
        if (reason == null || reason.isBlank()) {        // 取消必须给出原因
            throw new IllegalArgumentException("取消原因不能为空");
        }
    }
 
    public static OrderCancelled now(String orderId, String reason) {
        return new OrderCancelled(UUID.randomUUID(), Instant.now(), orderId, reason);
    }
}
 
// 3. 订单行项目 —— 也是 record
public record LineItem(String productName, int quantity, double unitPrice) {
 
    public LineItem {
        if (quantity <= 0) {                             // 数量必须为正
            throw new IllegalArgumentException("数量必须大于 0");
        }
        if (unitPrice < 0) {                             // 单价不能为负
            throw new IllegalArgumentException("单价不能为负数");
        }
    }
 
    public double subtotal() {                           // 小计金额
        return quantity * unitPrice;
    }
}

// 4. 事件处理器 —— 模式匹配 switch 分发
public class EventProcessor {
 
    public static String describe(DomainEvent event) {
        return switch (event) {
            case OrderCreated e -> String.format(        // 解构 OrderCreated
                "新订单 [%s] 创建，包含 %d 件商品",
                e.orderId(), e.items().size()
            );
            case OrderPaid e -> String.format(           // 解构 OrderPaid
                "订单 [%s] 已支付 %.2f 元（%s）",
                e.orderId(), e.amount(), e.paymentMethod()
            );
            case OrderCancelled e -> String.format(      // 解构 OrderCancelled
                "订单 [%s] 已取消，原因: %s",
                e.orderId(), e.reason()
            );
            // sealed 接口 → 编译器确认穷举，无需 default
        };
    }
 
    public static void main(String[] args) {
        // 创建订单行项目
        var items = List.of(
            new LineItem("Java 编程思想", 1, 108.0),     // 书籍
            new LineItem("机械键盘", 1, 599.0)           // 外设
        );
 
        // 模拟事件流
        var events = List.of(
            OrderCreated.now("ORD-001", items),          // 创建订单
            OrderPaid.now("ORD-001", 707.0, "支付宝"),    // 支付订单
            OrderCancelled.now("ORD-002", "用户主动取消") // 取消另一个订单
        );
 
        // 处理每个事件
        events.forEach(e -> {
            System.out.println(describe(e));             // 分发并打印描述
            System.out.println("  事件ID: " + e.eventId());
            System.out.println("  时间: " + e.occurredAt());
            System.out.println();
        });
    }
}

// 声明一个密封类 Shape，只允许 Circle、Rectangle、Triangle 继承
public sealed class Shape permits Circle, Rectangle, Triangle {
    // Shape 的公共属性和方法
    private final String color; // 颜色属性
 
    public Shape(String color) { // 构造方法
        this.color = color;      // 初始化颜色
    }
 
    public String getColor() {   // 获取颜色
        return color;
    }
 
    public abstract double area(); // 抽象方法：计算面积
}

// 1. final —— 终结继承链，不允许再被继承
public final class Circle extends Shape {
    private final double radius; // 半径
 
    public Circle(String color, double radius) {
        super(color);            // 调用父类构造
        this.radius = radius;    // 初始化半径
    }
 
    @Override
    public double area() {       // 实现面积计算
        return Math.PI * radius * radius; // πr²
    }
}
 
// 2. sealed —— 继续密封，再次限定下一层子类
public sealed class Rectangle extends Shape permits Square {
    private final double width;  // 宽
    private final double height; // 高
 
    public Rectangle(String color, double width, double height) {
        super(color);            // 调用父类构造
        this.width = width;      // 初始化宽
        this.height = height;    // 初始化高
    }
 
    @Override
    public double area() {       // 实现面积计算
        return width * height;   // 宽 × 高
    }
}
 
// Square 是 Rectangle 的唯一允许子类，用 final 终结
public final class Square extends Rectangle {
    public Square(String color, double side) {
        super(color, side, side); // 正方形：宽 = 高 = 边长
    }
}
 
// 3. non-sealed —— 打开口子，恢复为普通的开放继承
public non-sealed class Triangle extends Shape {
    private final double base;   // 底边
    private final double height; // 高
 
    public Triangle(String color, double base, double height) {
        super(color);            // 调用父类构造
        this.base = base;        // 初始化底边
        this.height = height;    // 初始化高
    }
 
    @Override
    public double area() {       // 实现面积计算
        return 0.5 * base * height; // ½ × 底 × 高
    }
}

// 文件：Expression.java
// 所有子类都在同一个文件中，permits 可以省略
public sealed abstract class Expression {
    // 编译器自动推断 permits Literal, Add, Multiply
}
 
// 字面量表达式
final class Literal extends Expression {
    private final int value;     // 字面值
 
    Literal(int value) {         // 构造方法
        this.value = value;      // 初始化
    }
 
    int value() { return value; } // 获取值
}
 
// 加法表达式
final class Add extends Expression {
    private final Expression left;  // 左操作数
    private final Expression right; // 右操作数
 
    Add(Expression left, Expression right) {
        this.left = left;           // 初始化左操作数
        this.right = right;         // 初始化右操作数
    }
 
    Expression left() { return left; }   // 获取左操作数
    Expression right() { return right; } // 获取右操作数
}
 
// 乘法表达式
final class Multiply extends Expression {
    private final Expression left;  // 左操作数
    private final Expression right; // 右操作数
 
    Multiply(Expression left, Expression right) {
        this.left = left;           // 初始化左操作数
        this.right = right;         // 初始化右操作数
    }
 
    Expression left() { return left; }   // 获取左操作数
    Expression right() { return right; } // 获取右操作数
}

// 密封接口：定义 JSON 值的所有可能类型
public sealed interface JsonValue
        permits JsonString, JsonNumber, JsonBoolean, JsonNull, JsonArray, JsonObject {
    // 将 JSON 值转为字符串表示
    String toJsonString();
}
 
// JSON 字符串 —— 用 record 实现，天然 final
public record JsonString(String value) implements JsonValue {
    @Override
    public String toJsonString() {       // 实现接口方法
        return "\"" + value + "\"";      // 加双引号
    }
}
 
// JSON 数字
public record JsonNumber(double value) implements JsonValue {
    @Override
    public String toJsonString() {       // 实现接口方法
        return String.valueOf(value);    // 数字转字符串
    }
}
 
// JSON 布尔值
public record JsonBoolean(boolean value) implements JsonValue {
    @Override
    public String toJsonString() {       // 实现接口方法
        return String.valueOf(value);    // true 或 false
    }
}
 
// JSON null
public record JsonNull() implements JsonValue {
    @Override
    public String toJsonString() {       // 实现接口方法
        return "null";                   // 固定返回 "null"
    }
}
 
// JSON 数组 —— 用 sealed 继续限制，或 non-sealed 开放
public record JsonArray(java.util.List<JsonValue> elements) implements JsonValue {
    @Override
    public String toJsonString() {       // 实现接口方法
        return elements.stream()         // 流式处理每个元素
                .map(JsonValue::toJsonString) // 递归转字符串
                .collect(java.util.stream.Collectors.joining(", ", "[", "]")); // 拼接为 [a, b, c]
    }
}
 
// JSON 对象
public record JsonObject(java.util.Map<String, JsonValue> entries) implements JsonValue {
    @Override
    public String toJsonString() {       // 实现接口方法
        return entries.entrySet().stream() // 流式处理每个键值对
                .map(e -> "\"" + e.getKey() + "\": " + e.getValue().toJsonString()) // "key": value
                .collect(java.util.stream.Collectors.joining(", ", "{", "}")); // 拼接为 {k: v}
    }
}

// 用 sealed + record 建模一个简单的算术表达式 AST
public sealed interface Expr {
    // permits 省略，因为所有实现都在同一文件
 
    // 数字字面量
    record Num(double value) implements Expr {}
 
    // 二元运算：左操作数 + 运算符 + 右操作数
    record BinOp(Expr left, String operator, Expr right) implements Expr {}
 
    // 一元取负
    record Negate(Expr operand) implements Expr {}
 
    // 求值方法 —— 利用模式匹配 switch（Java 21+）
    default double eval() {
        return switch (this) {                          // 对当前表达式进行模式匹配
            case Num(var v) -> v;                       // 数字直接返回值
            case BinOp(var l, var op, var r) ->         // 二元运算
                switch (op) {                           // 根据运算符分派
                    case "+" -> l.eval() + r.eval();    // 加法
                    case "-" -> l.eval() - r.eval();    // 减法
                    case "*" -> l.eval() * r.eval();    // 乘法
                    case "/" -> l.eval() / r.eval();    // 除法
                    default -> throw new IllegalArgumentException("Unknown op: " + op);
                };
            case Negate(var operand) -> -operand.eval(); // 取负
        };
        // 注意：因为 sealed 穷举了所有子类型，这里不需要 default 分支！
    }
}

public class ExprDemo {
    public static void main(String[] args) {
        // 构建表达式：(3 + 5) * -2
        Expr expr = new Expr.BinOp(                     // 最外层是乘法
                new Expr.BinOp(                         // 左操作数是加法
                        new Expr.Num(3),                // 3
                        "+",                            // +
                        new Expr.Num(5)                 // 5
                ),
                "*",                                    // ×
                new Expr.Negate(new Expr.Num(2))        // -2
        );
 
        System.out.println(expr);        // 自动 toString
        System.out.println(expr.eval()); // 输出: -16.0
    }
}

// 密封接口：支付方式
public sealed interface Payment
        permits CreditCard, BankTransfer, DigitalWallet {
}
 
public record CreditCard(String number, String expiry) implements Payment {}
public record BankTransfer(String iban) implements Payment {}
public record DigitalWallet(String provider, String account) implements Payment {}
 
// 处理支付 —— 编译器保证穷举
public class PaymentProcessor {
    public static String process(Payment payment) {
        return switch (payment) {                                // 模式匹配 switch
            case CreditCard cc    -> "Charging card: " + cc.number();    // 信用卡
            case BankTransfer bt  -> "Transferring to: " + bt.iban();    // 银行转账
            case DigitalWallet dw -> "Paying via " + dw.provider();      // 数字钱包
            // 无需 default！编译器知道 Payment 只有这三种实现
        };
    }
}

public class SealedReflection {
    public static void main(String[] args) {
        Class<?> shapeClass = Shape.class;
 
        // isSealed() —— 判断是否为密封类
        System.out.println(shapeClass.isSealed());       // true
 
        // getPermittedSubclasses() —— 获取所有允许的子类
        Class<?>[] permitted = shapeClass.getPermittedSubclasses();
        for (Class<?> sub : permitted) {                 // 遍历所有允许的子类
            System.out.println("Permitted: " + sub.getName()); // 打印子类全限定名
        }
        // 输出:
        // Permitted: Circle
        // Permitted: Rectangle
        // Permitted: Triangle
    }
}

// 订单状态 —— 密封接口
public sealed interface OrderState {
 
    // 已创建：携带创建时间
    record Created(java.time.Instant createdAt) implements OrderState {}
 
    // 已支付：携带支付金额和交易号
    record Paid(double amount, String transactionId) implements OrderState {}
 
    // 已发货：携带物流单号
    record Shipped(String trackingNumber) implements OrderState {}
 
    // 已完成：携带完成时间
    record Completed(java.time.Instant completedAt) implements OrderState {}
 
    // 已取消：携带取消原因
    record Cancelled(String reason) implements OrderState {}
}
 
// 订单状态流转逻辑
public class OrderStateMachine {
 
    // 根据当前状态决定下一步操作
    public static String describeNextAction(OrderState state) {
        return switch (state) {                                          // 穷举匹配
            case OrderState.Created c   ->                               // 已创建
                    "Order created at " + c.createdAt() + ", awaiting payment";
            case OrderState.Paid p      ->                               // 已支付
                    "Payment of $" + p.amount() + " received (tx: " + p.transactionId() + "), ready to ship";
            case OrderState.Shipped s   ->                               // 已发货
                    "Shipped with tracking: " + s.trackingNumber() + ", awaiting delivery";
            case OrderState.Completed c ->                               // 已完成
                    "Order completed at " + c.completedAt();
            case OrderState.Cancelled c ->                               // 已取消
                    "Order cancelled: " + c.reason();
            // 无需 default —— 编译器确保所有状态都已处理
        };
    }
}

// 传统写法：三步走，啰嗦且容易出错
public void process(Object obj) {
    // 第一步：类型检查
    if (obj instanceof String) {
        // 第二步：显式强制转换（明明已经确认是 String 了）
        String s = (String) obj;
        // 第三步：才能使用
        System.out.println(s.toUpperCase());
    }
}

// 现代写法：一步到位
public void process(Object obj) {
    // instanceof 后直接声明「模式变量」s
    // 如果 obj 是 String 类型，自动绑定到变量 s，无需手动 cast
    if (obj instanceof String s) {
        // 直接使用 s，类型已经是 String
        System.out.println(s.toUpperCase());
    }
}

public void flowScopeDemo(Object obj) {
 
    // ✅ 场景一：if 块内部 —— 最基本的作用域
    if (obj instanceof String s) {
        // s 在这里可用，因为进入此块意味着匹配成功
        System.out.println(s.length());
    }
    // ❌ s 在这里不可用，因为可能走了 else 分支，匹配未必成功
 
    // ✅ 场景二：短路与运算符 && —— 编译器能推断左侧为 true
    if (obj instanceof String s && s.length() > 5) {
        // && 的右侧能使用 s，因为 && 短路求值保证左侧为 true
        System.out.println("长字符串: " + s);
    }
 
    // ❌ 场景三：短路或运算符 || —— 编译器无法保证
    // if (obj instanceof String s || s.length() > 5) {
    //     编译错误！|| 的右侧不能使用 s
    //     因为走到右侧说明左侧为 false，即 obj 不是 String，s 未绑定
    // }
 
    // ✅ 场景四：取反后在 else 块中使用
    if (!(obj instanceof String s)) {
        // s 在这里不可用
        System.out.println("不是字符串");
        return; // 提前返回
    }
    // s 在这里可用！因为能走到这里说明上面的 if 为 false
    // 即 !(obj instanceof String s) 为 false → obj instanceof String s 为 true
    System.out.println(s.toUpperCase());
}

// 定义几种图形（这里用 sealed 接口更佳，后面会联动讲解）
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 {}
 
public class ShapeCalculator {
 
    // 传统写法：冗长的 cast 链
    public static double areaOld(Shape shape) {
        if (shape instanceof Circle) {
            Circle c = (Circle) shape;                    // 手动 cast
            return Math.PI * c.radius() * c.radius();
        } else if (shape instanceof Rectangle) {
            Rectangle r = (Rectangle) shape;              // 手动 cast
            return r.width() * r.height();
        } else if (shape instanceof Triangle) {
            Triangle t = (Triangle) shape;                // 手动 cast
            return 0.5 * t.base() * t.height();
        }
        throw new IllegalArgumentException("未知图形");
    }
 
    // 现代写法：模式匹配 instanceof，干净利落
    public static double areaNew(Shape shape) {
        // 类型检查 + 转换 + 变量绑定，一气呵成
        if (shape instanceof Circle c) {
            return Math.PI * c.radius() * c.radius();     // 直接用 c
        } else if (shape instanceof Rectangle r) {
            return r.width() * r.height();                 // 直接用 r
        } else if (shape instanceof Triangle t) {
            return 0.5 * t.base() * t.height();            // 直接用 t
        }
        throw new IllegalArgumentException("未知图形");
    }
}

public void nullSafety(Object obj) {
    // obj 为 null 时，instanceof 返回 false，不会进入 if 块
    // 因此模式变量 s 不会被绑定，也不存在 NullPointerException 的风险
    if (obj instanceof String s) {
        // 这里 s 一定不是 null，可以安全调用方法
        System.out.println(s.length());
    }
}

public class Point {
    private final int x; // x 坐标
    private final int y; // y 坐标
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    @Override
    public boolean equals(Object obj) {
        // 传统写法需要三行：instanceof 检查 → cast → 比较
        // 现代写法一行搞定类型检查和转换
        return obj instanceof Point p    // 类型检查 + 绑定
            && this.x == p.x            // 字段逐一比较
            && this.y == p.y;           // && 短路保证 p 已绑定
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(x, y); // 与 equals 保持一致
    }
}

// 用 switch 表达式重写图形面积计算
public static double area(Shape shape) {
    return switch (shape) {
        // 每个 case 直接匹配类型并绑定变量，无需 instanceof 也无需 cast
        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();
        // 如果 Shape 是 sealed 接口且所有子类都已覆盖，可以不写 default
    };
}

public static String describe(Object obj) {
    return switch (obj) {
 
        // 1️⃣ null 标签 —— switch 终于能处理 null 了！
        //    传统 switch 遇到 null 会抛 NullPointerException
        //    模式匹配 switch 允许显式匹配 null
        case null           -> "这是 null";
 
        // 2️⃣ 类型模式 —— 匹配类型并绑定变量
        case Integer i      -> "整数: " + i;
 
        // 3️⃣ 守卫模式（Guarded Pattern）—— 类型模式 + when 条件
        //    when 关键字是 Java 21 新增的，用于在类型匹配后追加布尔条件
        case String s when s.isEmpty()  -> "空字符串";
        case String s when s.length() > 10 -> "长字符串: " + s.substring(0, 10) + "...";
 
        // 4️⃣ 普通类型模式 —— 兜底匹配所有 String（上面的守卫没命中的）
        case String s       -> "字符串: " + s;
 
        // 5️⃣ Record 解构模式 —— 直接提取 record 的组件
        case Point(int x, int y) -> "坐标: (" + x + ", " + y + ")";
 
        // 6️⃣ default 兜底 —— 处理所有未匹配的情况
        default             -> "未知类型: " + obj.getClass().getSimpleName();
    };
}

public static String classifyNumber(Number num) {
    return switch (num) {
        // 先匹配类型为 Integer，再用 when 检查值的范围
        case Integer i when i < 0    -> "负整数";
        case Integer i when i == 0   -> "零";
        case Integer i when i > 0    -> "正整数";
 
        // Double 类型的守卫条件
        case Double d when d.isNaN()       -> "不是数字 (NaN)";
        case Double d when d.isInfinite()  -> "无穷大";
        case Double d                      -> "浮点数: " + d;
 
        // Long 类型
        case Long l -> "长整数: " + l;
 
        // 兜底
        default -> "其他数值类型";
    };
}