密封类 Sealed Classes（JDK 15 预览 / JDK 17 正式）

public class SealedBasic {
    // === JDK 17：sealed interface 限制实现者 ===
    sealed interface PaymentMethod
            permits CreditCard, WeChatPay, Alipay {
        String pay(double amount);
    }

    // 实现类一：final 终止继承
    static final class CreditCard implements PaymentMethod {
        @Override
        public String pay(double amount) {
            return "信用卡支付: ¥" + amount;
        }
    }

    // 实现类二：non-sealed 开放继承
    static non-sealed class WeChatPay implements PaymentMethod {
        @Override
        public String pay(double amount) {
            return "微信支付: ¥" + amount;
        }
    }

    // 实现类三：sealed 继续控制
    static final class Alipay implements PaymentMethod {
        @Override
        public String pay(double amount) {
            return "支付宝支付: ¥" + amount;
        }
    }

    // ❌ 不在 permits 白名单中，编译错误
    // static class BitcoinPay implements PaymentMethod {}  // 编译错误

    public static void main(String[] args) {
        PaymentMethod[] methods = {
                new CreditCard(),
                new WeChatPay(),
                new Alipay()
        };

        for (PaymentMethod method : methods) {
            System.out.println(method.pay(99.99));
        }
    }
}

public class SealedSwitch {
    // === 代数数据类型：密封类 + Record ===
    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 {}

    // === Switch 表达式利用穷尽性：无需 default ===
    static 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 static void main(String[] args) {
        Shape[] shapes = {
                new Circle(5),
                new Rectangle(4, 6),
                new Triangle(3, 8)
        };

        for (Shape shape : shapes) {
            System.out.printf("%s 的面积 = %.2f%n", shape, area(shape));
        }
    }
}

public class SealedOrderSystem {
    // === 密封接口定义订单状态的有限集合 ===
    sealed interface OrderStatus
            permits Pending, Processing, Shipped, Delivered, Cancelled {}

    record Pending(String orderId, String createdAt) implements OrderStatus {}
    record Processing(String orderId, String processor, int progressPercent) implements OrderStatus {}
    record Shipped(String orderId, String trackingNumber, String shippedAt) implements OrderStatus {}
    record Delivered(String orderId, String deliveredAt, String signedBy) implements OrderStatus {}
    record Cancelled(String orderId, String reason, String cancelledBy) implements OrderStatus {}

    // === 利用穷尽性处理每个状态 ===
    static String handleStatus(OrderStatus status) {
        return switch (status) {
            case Pending p -> "订单 %s 已创建，等待支付。创建时间：%s".formatted(p.orderId(), p.createdAt());
            case Processing pp -> "订单 %s 处理中（%d%%），负责人：%s"
                    .formatted(pp.orderId(), pp.progressPercent(), pp.processor());
            case Shipped s -> "订单 %s 已发货，快递单号：%s，发货时间：%s"
                    .formatted(s.orderId(), s.trackingNumber(), s.shippedAt());
            case Delivered d -> "订单 %s 已签收，签收人：%s，签收时间：%s"
                    .formatted(d.orderId(), d.signedBy(), d.deliveredAt());
            case Cancelled c -> "订单 %s 已取消，原因：%s，操作人：%s"
                    .formatted(c.orderId(), c.reason(), c.cancelledBy());
        };
    }

    public static void main(String[] args) {
        OrderStatus[] orders = {
                new Pending("ORD-001", "2026-06-14 09:00"),
                new Processing("ORD-001", "小崔", 60),
                new Shipped("ORD-001", "SF1234567890", "2026-06-14 15:30"),
                new Delivered("ORD-001", "2026-06-15 10:20", "大翔"),
                new Cancelled("ORD-002", "客户主动取消", "Frank")
        };

        System.out.println("=== 飞翔科技订单追踪系统 ===\n");
        for (OrderStatus order : orders) {
            System.out.println(handleStatus(order));
        }
    }
}

public class SealedScopePitfall {
    // 在同一个 .java 文件中，子类可以在同一个编译单元
    sealed interface Animal permits Dog, Cat {}

    static final class Dog implements Animal {}
    static final class Cat implements Animal {}

    // ✅ 同一文件内的子类 OK
    public static void main(String[] args) {
        Animal a1 = new Dog();
        Animal a2 = new Cat();
        System.out.println("a1 = " + a1.getClass().getSimpleName());
        System.out.println("a2 = " + a2.getClass().getSimpleName());
    }
}

public class SealedSubclassModifierPitfall {
    sealed interface Vehicle permits Car {}

    // ❌ 编译错误：Car 必须声明为 final / sealed / non-sealed
    // static class Car implements Vehicle {}  // 错误

    // ✅ 正确：明确声明继承策略
    static final class Car implements Vehicle {
        String model = "飞翔科技专用车";
    }

    public static void main(String[] args) {
        Car car = new Car();
        System.out.println(car.model);
    }
}

public class SealedDirectPermitPitfall {
    sealed interface Shape permits Circle {}

    static final class Circle implements Shape {}

    // ❌ 间接实现者不能出现在 permits 中，也不需要
    // Circle 已经是 final，不可能有子类间接实现 Shape
    // static class SpecialCircle extends Circle {}  // 编译错误：Circle 是 final

    public static void main(String[] args) {
        Shape s = new Circle();
        System.out.println("形状: " + s.getClass().getSimpleName());
    }
}