Java 密封类详解

引言

Java自诞生以来，其类型系统一直基于类继承与接口实现构建。然而在传统模型中，开发者无法精确控制哪些子类可以扩展某个类，这往往导致继承层次结构过于开放，带来可维护性、安全性与语义准确性的问题。为此，Java在第15版中引入“密封类”作为预览特性，并在Java 17中正式发布。

密封类（Sealed Classes）允许开发者显式指定哪些类可以继承某个类或实现某个接口，从而实现继承结构的封闭式设计。这种机制在许多面向模式匹配的编程场景中至关重要，如对枚举型数据结构的模拟、安全策略的表达等。

密封类的引入，不仅提升了语言的表达能力，也增强了编译期错误检查能力，并与Java日益增强的模式匹配系统（如switch增强、record类、类型推断）形成良好协同。

"密封类是Java继承模型的一次现代化升级，让类型系统更具表达力与控制力。"

下面将从语法、约束、应用场景到高级特性与最佳实践等方面，全面解读密封类的设计理念与实际应用。

密封类的语法与声明

密封类的基本语法通过sealed关键字声明，并使用permits子句列出允许的子类。

基本语法结构

public sealed class Shape permits Circle, Rectangle {
    // 基类成员
}

final class Circle extends Shape {
    // 圆形实现
}

final class Rectangle extends Shape {
    // 矩形实现
}

关键字说明

• sealed：修饰类或接口，表示这是一个密封类/接口。

• permits：用于指定哪些类可以继承该密封类。也可以省略，Java编译器会从同一文件中自动推断。

子类必须显式使用final（不可被继承）、sealed（继续密封）或non-sealed（取消密封）之一进行修饰。

接口的密封定义

public sealed interface Operation permits Add, Subtract {}

final class Add implements Operation {}
final class Subtract implements Operation {}

这种形式适合表达具有确定实现集合的策略、指令或行为类型。

permits可省略的情况

当密封类、其所有子类都定义在同一个编译单元（.java文件）中时，permits子句可以省略。

public sealed class Animal {
    final class Dog extends Animal {}
    final class Cat extends Animal {}
}

在其他情况下，必须显式声明permits。

 

密封类的规则与约束

密封类的核心在于其限制继承的能力，为确保这一特性，Java对密封类及其子类定义了多项语法与结构规则。

基本规则

1. 子类必须显式声明继承策略：

   • final：子类不再被继承。

   • sealed：继续限制下一层继承。

   • non-sealed：解除密封，允许任意类继承。

2. 子类必须在permits中声明，或同文件内推断出。

3. 密封类与子类必须在同一个模块或包中定义。

4. 所有允许的子类必须在编译期可见且已定义，否则会编译失败。

示例：多级密封结构

public sealed class Vehicle permits Car, Truck {}

public sealed class Car extends Vehicle permits Sedan, Coupe {}
final class Sedan extends Car {}
final class Coupe extends Car {}

non-sealed class Truck extends Vehicle {}

在上例中：

• Car继续密封，其子类限定为Sedan和Coupe。

• Truck取消密封，后续可被任意类继承。

编译限制提示

如果声明了密封类，但其子类未满足上述规则，Java编译器将抛出类似以下错误：

class Car is not allowed to extend sealed class Vehicle

密封类的典型用例

密封类作为一种控制继承结构的语言机制，在实际开发中具有重要价值。它尤其适用于以下典型用例：

1. 受控的领域建模（Domain Modeling）

在面向对象设计中，我们通常会为领域模型定义一组受控的状态或行为。例如，一个支付系统中可能有如下几种支付方式：

public sealed interface PaymentMethod permits CreditCard, PayPal, BankTransfer {}

final class CreditCard implements PaymentMethod {}
final class PayPal implements PaymentMethod {}
final class BankTransfer implements PaymentMethod {}

密封接口PaymentMethod确保只有明确列出的三种方式可用，防止在系统中引入未授权的支付方式，符合领域封闭性原则。

2. 模拟枚举的扩展形式（比枚举更灵活）

虽然Java提供了枚举（enum）来表示固定常量集合，但枚举的行为和状态受限，不支持继承或策略封装。密封类提供一种更灵活的替代方案：

public sealed interface Instruction permits Load, Store {}

record Load(String source) implements Instruction {}
record Store(String destination) implements Instruction {}

通过record类与密封接口的结合，可构建具有值语义和明确结构的指令集合，适合编译器、虚拟机指令、工作流建模等高级场景。

3. 更安全的模式匹配与穷尽性检查

密封类与模式匹配配合使用，可让Java在编译期检查switch语句或表达式是否覆盖所有可能子类，避免遗漏：

static String describeShape(Shape shape) {
    return switch (shape) {
        case Circle c -> "这是圆形";
        case Rectangle r -> "这是矩形";
    };
}

如果未覆盖所有密封类允许的子类，编译器会报错。这在逻辑分支高度依赖类型时极为关键。

4. 权限受限的插件系统或指令集

在设计插件或模块系统时，有时希望只允许某些受信任的实现类注册到系统中。使用密封类可以限制扩展源头，并在模块内强制控制子类来源。

 

密封类与其他类型的比较

Java中的继承控制机制包括final类、abstract类、接口、枚举等，密封类作为新引入的成员，在控制继承范围方面提供了前所未有的灵活性。理解它与传统机制的异同，有助于我们在设计类结构时做出更合适的决策。

1. 密封类 vs 抽象类

特性	抽象类	密封类
是否可被实例化	否	可以（若未标记为abstract）
子类限制	无法控制具体子类	明确指定子类集合
模板方法设计	支持	支持
构造粒度控制	支持	支持

虽然抽象类可用于定义通用行为，但在控制继承方向和数量方面，密封类更具优势。

示例

public abstract class Animal {
    abstract void speak();
}

public sealed class Animal permits Dog, Cat {
    abstract void speak();
}

前者任何类都可以继承，后者仅限于列出的Dog、Cat。

---

2. 密封类 vs final类

特性	final类	密封类
是否可继承	否	可控制是否继承
可扩展性	关闭	有选择地开放
应用场景	安全类（如String）	安全且可控的层次结构

final类完全关闭继承，而密封类提供了中间选项：明确允许部分子类继承。

示例

public final class String {}

public sealed class Shape permits Circle, Square {}

---

3. 密封类 vs 接口

接口本身代表了一组能力，不提供继承限制，任何类都可以实现。密封接口则对实现者做出限定，适用于策略集、命令模式等。

特性	普通接口	密封接口
实现类限制	无	显式列出实现类
结构控制	松散	严格

示例

public interface Command {}

public sealed interface Command permits StartCommand, StopCommand {}

---

4. 密封类 vs 枚举

枚举是Java中对固定实例集的表达方式，适合于值的有限集合。但枚举无法继承，扩展性差。

密封类提供了类似枚举的封闭性，同时保留类的继承、封装、策略行为等能力。

特性	枚举	密封类
实例集	静态不可变	可动态定义类型结构
可继承	否	是（受控）
是否支持状态封装	支持但有限	完全支持

示例

enum Status { STARTED, STOPPED }

public sealed interface Status permits Started, Stopped {}
record Started() implements Status {}
record Stopped() implements Status {}

---

密封类既不是传统意义上的类，也不是典型的接口或枚举，而是一种混合型的继承控制机制。它结合了抽象类的结构能力、接口的行为分离能力以及枚举的穷尽表达力，是Java类型系统的重要进化。

高级特性：密封接口、嵌套密封类与记录类

在基础语法和继承控制的功能之上，密封类还支持多种高级特性，包括密封接口、嵌套密封结构及与record类的天然协作。这些特性不仅扩展了密封类的灵活性，也增强了它在现代Java开发场景中的实用性。

1. 密封接口（Sealed Interfaces）

密封接口与密封类在概念上完全一致，不同之处在于接口不包含具体实现，而是描述行为契约。

示例：密封接口定义指令集

public sealed interface Command permits StartCommand, StopCommand {
    void execute();
}

final class StartCommand implements Command {
    public void execute() {
        System.out.println("Started");
    }
}

final class StopCommand implements Command {
    public void execute() {
        System.out.println("Stopped");
    }
}

这种设计适用于领域驱动设计（DDD）中对命令、事件等语义单位进行建模。

---

2. 嵌套密封类

密封类可以被嵌套在另一个类中，适用于逻辑上高度相关的结构。例如表示图形系统中的嵌套几何元素。

示例：嵌套密封类

public class Drawing {
    public sealed class Shape permits Circle, Square {
        abstract double area();
    }

    public final class Circle extends Shape {
        private final double radius;
        public Circle(double r) { radius = r; }
        @Override double area() { return Math.PI * radius * radius; }
    }

    public final class Square extends Shape {
        private final double side;
        public Square(double s) { side = s; }
        @Override double area() { return side * side; }
    }
}

嵌套密封类使得封装和继承限制能细化到局部结构，提升了封装性与结构清晰度。

---

3. 与记录类（Record）结合使用

密封类天然适合与Java的记录类（record）结合使用，形成“类型+数据”的受限组合。

示例：状态系统的建模

public sealed interface Status permits Started, Stopped {}

public record Started(long timestamp) implements Status {}
public record Stopped(String reason) implements Status {}

在模式匹配或switch增强中，这种组合提供了清晰、安全的模型，有助于穷尽性检查：

void printStatus(Status status) {
    switch (status) {
        case Started s -> System.out.println("Started at: " + s.timestamp());
        case Stopped s -> System.out.println("Stopped because: " + s.reason());
    }
}

编译器会验证是否覆盖了所有实现类，进一步增强了类型安全性。