Java Sealed Classes：受限的继承 - 智猿学院-IT界的百科全书

好的，各位观众老爷，程序员小哥哥小姐姐们，欢迎来到今天的 “Java Sealed Classes：受限的继承，无限的可能” 技术脱口秀！ 🎤

今天咱们要聊的，是Java语言里一个相当有趣的新特性——Sealed Classes，中文名叫“密封类”。听到“密封”这两个字，是不是感觉有点神秘，有点禁欲系？别怕，它不是要封印你的代码，而是要给你的继承关系加上一把锁，让它更安全，更可控，也更优雅！

第一幕：继承，甜蜜的负担

在Java的世界里，继承就像恋爱，起初是美好的，父类默默奉献，子类予取予求，一片和谐景象。但是，时间久了，问题就来了。

子类泛滥成灾： 继承就像潘多拉的魔盒，一旦打开，谁都可以来继承你的类，搞不好哪天冒出来一个八竿子打不着的子类，把你的设计搅得天翻地覆。想象一下，你精心设计的Animal类，结果出来一个FlyingSpaghettiMonster（飞行意大利面怪物）继承它，还声称自己能飞，能吃，还能传播意大利面福音，这谁顶得住啊？ 🍝
类型判断的噩梦： 当你需要根据对象的类型做不同的处理时，一连串的 instanceof 判断简直是代码界的噩梦。 if (animal instanceof Dog) { ... } else if (animal instanceof Cat) { ... } else if (animal instanceof FlyingSpaghettiMonster) { ... } ，这代码写得，连自己都想打自己。这种代码不仅丑陋，而且容易出错，每次新增一个子类，你都要去修改这些判断逻辑，维护起来简直是灾难。
安全隐患： 有些类，你只想让特定的几个类继承，不想让别人随意篡改你的设计。比如，一个支付系统里的PaymentMethod类，你可能只允许CreditCardPayment, PayPalPayment, WechatPayment这几种支付方式，如果别人随意增加一种支付方式，可能会导致安全漏洞。

所以，继承这玩意儿，用好了是神兵利器，用不好就是一颗定时炸弹。💣

第二幕： Sealed Classes，锁住继承的魔盒

为了解决这些问题，Java 17引入了Sealed Classes。 Sealed Classes就像一把精致的锁，它可以让你明确指定哪些类可以继承你的类，就像给你的继承关系加上了白名单。

什么是Sealed Class？

简单来说，Sealed Class就是用 sealed 关键字修饰的类或接口。它限制了哪些类可以直接继承或实现它。只有在 permits 子句中明确列出的类才能继承或实现它。

语法糖时间：

sealed class Animal permits Dog, Cat, Bird {
    // ...
}

final class Dog extends Animal {
    // ...
}

final class Cat extends Animal {
    // ...
}

final class Bird extends Animal {
    // ...
}

sealed class Animal permits Dog, Cat, Bird：这行代码声明了一个密封类Animal，并且明确指定只有Dog，Cat，Bird这三个类可以继承它。
final class Dog extends Animal：注意，继承密封类的子类必须是以下三种情况之一：
- final：表示这个类不能再被继承了，到此为止。
- sealed：表示这个类也是一个密封类，可以继续限制它的子类。
- non-sealed：表示这个类解除了密封限制，可以被任何类继承。（慎用！）

Sealed Classes的优点，简直不要太多！

可控的继承关系： 你可以精确控制哪些类可以继承你的类，避免了子类泛滥的问题。就像给你的代码设置了一个VIP通道，只有你想让进的人才能进。
更安全的类型判断： 编译器可以知道所有可能的子类类型，从而进行更智能的类型推断。这意味着你可以使用更简洁、更安全的 switch 表达式，而不是一堆丑陋的 instanceof。妈妈再也不用担心我写出冗余的类型判断代码了！ 🎉
更强的代码表达力： Sealed Classes可以清晰地表达你的设计意图，让代码更易于理解和维护。它就像代码里的路标，告诉别人：“嘿，朋友，这个类的继承关系就是这样的，不要乱来哦！”
模式匹配的福音： Sealed Classes和模式匹配简直是天生一对！你可以用更简洁、更强大的模式匹配语法来处理不同类型的子类。这感觉就像开了外挂一样！ 🚀

第三幕： Sealed Classes，实战演练

光说不练假把式，接下来我们来几个实战例子，让大家感受一下Sealed Classes的魅力。

案例一：支付方式

假设我们要设计一个支付系统，支持信用卡支付、PayPal支付和微信支付。我们可以使用Sealed Classes来限制支付方式的类型。

sealed interface PaymentMethod permits CreditCardPayment, PayPalPayment, WechatPayment {
    String processPayment(double amount);
}

final class CreditCardPayment implements PaymentMethod {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public String processPayment(double amount) {
        return "Processing credit card payment for $" + amount;
    }
}

final class PayPalPayment implements PaymentMethod {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public String processPayment(double amount) {
        return "Processing PayPal payment for $" + amount;
    }
}

final class WechatPayment implements PaymentMethod {
    private String qrCode;

    public WechatPayment(String qrCode) {
        this.qrCode = qrCode;
    }

    @Override
    public String processPayment(double amount) {
        return "Processing Wechat payment for $" + amount;
    }
}

public class PaymentProcessor {
    public static void main(String[] args) {
        PaymentMethod payment1 = new CreditCardPayment("1234-5678-9012-3456");
        PaymentMethod payment2 = new PayPalPayment("[email protected]");
        PaymentMethod payment3 = new WechatPayment("wechat-qr-code");

        System.out.println(processPayment(payment1, 100.0));
        System.out.println(processPayment(payment2, 50.0));
        System.out.println(processPayment(payment3, 25.0));
    }

    public static String processPayment(PaymentMethod paymentMethod, double amount) {
        return switch (paymentMethod) {
            case CreditCardPayment cc -> cc.processPayment(amount);
            case PayPalPayment pp -> pp.processPayment(amount);
            case WechatPayment wc -> wc.processPayment(amount);
        };
    }
}

在这个例子中，PaymentMethod是一个密封接口，它只允许CreditCardPayment，PayPalPayment和WechatPayment这三个类实现它。在processPayment方法中，我们可以使用 switch 表达式来进行类型判断，编译器会保证我们处理了所有可能的支付方式，避免了遗漏的情况。这代码写得，简直优雅到飞起！ 💃

案例二：表达式求值

假设我们要设计一个简单的表达式求值器，支持加法、减法和乘法。我们可以使用Sealed Classes来定义表达式的类型。

sealed interface Expression permits Constant, Addition, Subtraction, Multiplication {
}

record Constant(int value) implements Expression {
}

record Addition(Expression left, Expression right) implements Expression {
}

record Subtraction(Expression left, Expression right) implements Expression {
}

record Multiplication(Expression left, Expression right) implements Expression {
}

public class ExpressionEvaluator {
    public static void main(String[] args) {
        Expression expression = new Addition(new Constant(5), new Multiplication(new Constant(2), new Constant(3)));
        System.out.println("Result: " + evaluate(expression));
    }

    public static int evaluate(Expression expression) {
        return switch (expression) {
            case Constant c -> c.value();
            case Addition a -> evaluate(a.left()) + evaluate(a.right());
            case Subtraction s -> evaluate(s.left()) - evaluate(s.right());
            case Multiplication m -> evaluate(m.left()) * evaluate(m.right());
        };
    }
}

在这个例子中，Expression是一个密封接口，它只允许Constant，Addition，Subtraction和Multiplication这四个类实现它。我们使用 record 来简化类的定义，并使用 switch 表达式来进行表达式求值。这代码不仅简洁，而且易于扩展，如果我们要增加新的表达式类型，只需要在 Expression 接口的 permits 子句中添加新的类，并在 evaluate 方法中添加相应的处理逻辑即可。这简直是代码界的乐高积木！ 🧱

案例三：状态机

假设我们要设计一个简单的状态机，表示一个订单的不同状态：创建、处理中、已发货、已完成、已取消。

sealed interface OrderState permits Created, Processing, Shipped, Completed, Cancelled {}

record Created() implements OrderState {}
record Processing() implements OrderState {}
record Shipped() implements OrderState {}
record Completed() implements OrderState {}
record Cancelled() implements OrderState {}

public class OrderStateMachine {

    public static void main(String[] args) {
        OrderState currentState = new Created();

        currentState = transitionState(currentState, "process");
        System.out.println("Current state: " + currentState);

        currentState = transitionState(currentState, "ship");
        System.out.println("Current state: " + currentState);

        currentState = transitionState(currentState, "complete");
        System.out.println("Current state: " + currentState);
    }

    public static OrderState transitionState(OrderState currentState, String action) {
        return switch (currentState) {
            case Created c -> {
                if ("process".equals(action)) yield new Processing();
                else yield c;
            }
            case Processing p -> {
                if ("ship".equals(action)) yield new Shipped();
                else if ("cancel".equals(action)) yield new Cancelled();
                else yield p;
            }
            case Shipped s -> {
                if ("complete".equals(action)) yield new Completed();
                else yield s;
            }
            case Completed comp -> comp;
            case Cancelled canc -> canc;
        };
    }
}

这个例子清晰地展示了订单状态的流转，使用 Sealed Classes 和 Record 极大简化了代码结构，并利用 Switch 表达式确保状态转换的完整性。

第四幕： Sealed Classes，注意事项

虽然Sealed Classes很强大，但也有一些需要注意的地方。

继承的限制： 只有在 permits 子句中明确列出的类才能继承密封类。如果你想让一个类继承密封类，但没有在 permits 子句中列出它，编译器会报错。
子类的可见性： 继承密封类的子类必须与密封类在同一个模块或同一个包中。这意味着你不能在不同的模块或包中定义密封类的子类。
解封的风险： 使用 non-sealed 关键字可以解除密封限制，但要慎用！一旦解除了密封限制，任何类都可以继承你的类，这可能会破坏你的设计。

第五幕： Sealed Classes，未来展望

Sealed Classes是Java语言的一个重要补充，它可以帮助我们编写更安全、更可控、更优雅的代码。随着Java语言的不断发展，Sealed Classes的应用场景将会越来越广泛。我们可以期待在未来的Java版本中，Sealed Classes会与其他特性更好地结合，为我们带来更多的惊喜。

总结陈词：

Sealed Classes就像一把锁，锁住了继承的魔盒，让我们的代码更加安全可控；又像一扇门，敞开了模式匹配的新世界，让我们的代码更加简洁优雅。掌握了Sealed Classes，你就能在代码的世界里更加游刃有余，写出更加高质量的Java代码！ 👏

最后，记住，写代码就像谈恋爱，要负责任，要有所约束，才能长长久久！愿大家的程序都像 Sealed Classes 一样，安全、稳定、优雅！

感谢大家的观看，我们下期再见！ 👋

发表回复 取消回复

发表回复取消回复