Java 22 对密封类（Sealed Classes）进行了重要的增强，使得这一特性在类型安全和设计灵活性方面更加出色。以下是对密封类的详细介绍，包括基础概念、增强特性、丰富的使用场景示例，以及实际项目中的应用示例。

1. 基础介绍

什么是密封类（Sealed Classes）

密封类是 Java 17 引入的一种新特性，允许开发者限制哪些类可以继承特定的类。这种特性提供了一种更严格的类型控制机制，有助于构建安全、可维护的代码。

密封类的基本特性

限制继承：开发者可以指定哪些类可以扩展密封类，从而控制继承层次。增强类型安全性：通过限制子类，密封类可以确保更严格的类型检查。可读性和可维护性：密封类使得继承关系更加清晰，便于理解和维护。

2. Java 22 的增强特性

2.1 跨包继承

在 Java 22 中，密封类的子类可以跨包定义。这意味着开发者可以在不同的包中创建允许的子类，增强了密封类的灵活性。

2.2 允许多个子类

密封类可以有多个允许的子类，这些子类可以在同一包或不同包中实现。这使得设计层次结构更加灵活。

2.3 更好的错误信息

增强后的密封类提供了更详细的编译时错误信息，帮助开发者更容易理解不符合密封类限制的代码。

3. 使用场景

3.1 定义有限的继承层次

在设计复杂的系统时，使用密封类定义一个有限的继承层次，增强类型安全。例如，可以定义一个 <code>Vehicle 密封类，限制其子类为 Car、Truck 和 Motorcycle。

3.2 状态模式

在状态模式中，使用密封类表示不同的状态及其行为。例如，可以定义一个 OrderState 密封类，限制其子类为 Pending、Shipped 和 Delivered。

3.3 协议设计

在处理协议或命令模式时，使用密封类定义可接受的命令或请求类型，增强系统的可扩展性。例如，可以定义一个 Command 密封类，限制其子类为 StartCommand 和 StopCommand。

3.4 事件处理

在事件驱动架构中，使用密封类定义不同类型的事件，确保事件的类型安全。例如，可以定义一个 Event 密封类，限制其子类为 UserLoginEvent 和 UserLogoutEvent。

3.5 数据传输对象

在数据传输场景中，使用密封类定义不同的数据类型，确保传递的数据符合预期。例如，可以定义一个 Response 密封类，限制其子类为 SuccessResponse 和 ErrorResponse。

4. 示例代码

4.1 定义车辆的密封类

// 定义密封类 Vehicle

sealed class Vehicle permits Car, Truck, Motorcycle { -- -->

public abstract int getWheels();

}

// 定义 Car 类

final class Car extends Vehicle {

@Override

public int getWheels() {

return 4;

}

}

// 定义 Truck 类

final class Truck extends Vehicle {

@Override

public int getWheels() {

return 6;

}

}

// 定义 Motorcycle 类

final class Motorcycle extends Vehicle {

@Override

public int getWheels() {

return 2;

}

}

4.2 使用车辆的密封类

public class VehicleExample {

public static void main(String[] args) {

Vehicle car = new Car();

Vehicle truck = new Truck();

Vehicle motorcycle = new Motorcycle();

System.out.println("Car wheels: " + car.getWheels());

System.out.println("Truck wheels: " + truck.getWheels());

System.out.println("Motorcycle wheels: " + motorcycle.getWheels());

}

}

4.3 定义订单状态的密封类

// 定义密封类 OrderState

sealed class OrderState permits Pending, Shipped, Delivered {

public abstract String getStatus();

}

// 定义 Pending 类

final class Pending extends OrderState {

@Override

public String getStatus() {

return "Order is pending.";

}

}

// 定义 Shipped 类

final class Shipped extends OrderState {

@Override

public String getStatus() {

return "Order has been shipped.";

}

}

// 定义 Delivered 类

final class Delivered extends OrderState {

@Override

public String getStatus() {

return "Order has been delivered.";

}

}

4.4 使用订单状态的密封类

public class OrderStateExample {

public static void main(String[] args) {

OrderState order1 = new Pending();

OrderState order2 = new Shipped();

OrderState order3 = new Delivered();

System.out.println(order1.getStatus());

System.out.println(order2.getStatus());

System.out.println(order3.getStatus());

}

}

4.5 定义命令的密封类

// 定义密封类 Command

sealed class Command permits StartCommand, StopCommand {

public abstract void execute();

}

// 定义 StartCommand 类

final class StartCommand extends Command {

@Override

public void execute() {

System.out.println("Starting the process...");

}

}

// 定义 StopCommand 类

final class StopCommand extends Command {

@Override

public void execute() {

System.out.println("Stopping the process...");

}

}

4.6 使用命令的密封类

public class CommandExample {

public static void main(String[] args) {

Command start = new StartCommand();

Command stop = new StopCommand();

start.execute();

stop.execute();

}

}

4.7 定义事件的密封类

// 定义密封类 Event

sealed class Event permits UserLoginEvent, UserLogoutEvent {

public abstract String getEventType();

}

// 定义 UserLoginEvent 类

final class UserLoginEvent extends Event {

@Override

public String getEventType() {

return "User logged in.";

}

}

// 定义 UserLogoutEvent 类

final class UserLogoutEvent extends Event {

@Override

public String getEventType() {

return "User logged out.";

}

}

4.8 使用事件的密封类

public class EventExample {

public static void main(String[] args) {

Event loginEvent = new UserLoginEvent();

Event logoutEvent = new UserLogoutEvent();

System.out.println(loginEvent.getEventType());

System.out.println(logoutEvent.getEventType());

}

}

4.9 定义响应的密封类

// 定义密封类 Response

sealed class Response permits SuccessResponse, ErrorResponse {

public abstract String getMessage();

}

// 定义 SuccessResponse 类

final class SuccessResponse extends Response {

private final String message;

public SuccessResponse(String message) {

this.message = message;

}

@Override

public String getMessage() {

return "Success: " + message;

}

}

// 定义 ErrorResponse 类

final class ErrorResponse extends Response {

private final String error;

public ErrorResponse(String error) {

this.error = error;

}

@Override

public String getMessage() {

return "Error: " + error;

}

}

4.10 使用响应的密封类

public class ResponseExample {

public static void main(String[] args) {

Response success = new SuccessResponse("Data retrieved successfully.");

Response error = new ErrorResponse("Failed to retrieve data.");

System.out.println(success.getMessage());

System.out.println(error.getMessage());

}

}

5. 实际项目中的应用示例

项目背景

假设我们正在开发一个在线支付系统。我们需要处理不同类型的支付方式，例如信用卡、PayPal 和银行转账。使用密封类可以清晰地定义这些支付方式及其特定行为。

示例代码

5.1 定义支付方式的密封类

// 定义密封类 PaymentMethod

sealed class PaymentMethod permits CreditCard, PayPal, BankTransfer {

public abstract void processPayment(double amount);

}

// 定义 CreditCard 类

final class CreditCard extends PaymentMethod {

private final String cardNumber;

public CreditCard(String cardNumber) {

this.cardNumber = cardNumber;

}

@Override

public void processPayment(double amount) {

System.out.println("Processing credit card payment of $" + amount);

// 处理支付逻辑

}

}

// 定义 PayPal 类

final class PayPal extends PaymentMethod {

private final String email;

public PayPal(String email) {

this.email = email;

}

@Override

public void processPayment(double amount) {

System.out.println("Processing PayPal payment of $" + amount);

// 处理支付逻辑

}

}

// 定义 BankTransfer 类

final class BankTransfer extends PaymentMethod {

private final String accountNumber;

public BankTransfer(String accountNumber) {

this.accountNumber = accountNumber;

}

@Override

public void processPayment(double amount) {

System.out.println("Processing bank transfer payment of $" + amount);

// 处理支付逻辑

}

}

5.2 使用支付方式的密封类

public class PaymentProcessing {

public static void main(String[] args) {

PaymentMethod payment1 = new CreditCard("1234-5678-9876-5432");

PaymentMethod payment2 = new PayPal("user@example.com");

PaymentMethod payment3 = new BankTransfer("001-234-567");

// 处理不同支付方式

payment1.processPayment(150.00);

payment2.processPayment(75.50);

payment3.processPayment(200.00);

}

}

5.3 解释

密封类定义：PaymentMethod 是一个密封类，定义了三种允许的支付方式：CreditCard、PayPal 和 BankTransfer。实现支付逻辑：每种支付方式都实现了 processPayment() 方法，处理相应的付款逻辑。使用示例：在 PaymentProcessing 类中，创建三种支付方式的实例并调用 processPayment() 方法，展示了密封类在实际项目中的应用。

6. 总结

Java 22 对密封类的增强使得这一特性在设计和实现方面更加灵活。通过允许跨包继承和支持多个子类，密封类提供了更高的类型安全性和可维护性。在实际项目中，密封类能够有效加强代码的可读性和可维护性，特别是在需要限制继承关系和定义复杂的状态模型时。通过合理利用密封类，开发者可以构建更具扩展性和安全性的应用程序。