Java 17 新特性解析：从Record类到Sealed接口的演进

最新推荐文章于 2025-10-27 19:26:43 发布

原创最新推荐文章于 2025-10-27 19:26:43 发布 · 898 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#java #python #策略模式

Java 专栏收录该内容

76 篇文章

订阅专栏

引言

Java作为一门经典的编程语言，一直在不断发展和创新。Java 17是一个长期支持(LTS)版本，于2021年9月正式发布，带来了许多令人兴奋的新特性。本文将深入探讨Java 17中的核心新特性，特别是Record类和Sealed接口的演进，以及它们如何改变Java开发的范式。

Java 17的主要特性概览

在深入探讨Record类和Sealed接口之前，让我们先快速了解Java 17引入的其他重要特性：

JEP 406：Pattern Matching for switch (预览)
JEP 409：Sealed Classes (正式版)
JEP 382：新的macOS渲染管线
JEP 398：弃用安全管理器以便将来移除
JEP 391：macOS/AArch64端口
JEP 356：增强型伪随机数生成器
JEP 403：JDK内部强封装
JEP 407：移除RMI激活机制
JEP 410：移除实验性的AOT和JIT编译器
JEP 411：弃用安全管理器以便将来移除

现在，让我们深入了解两个最具革命性的特性：Record类和Sealed接口。

Record类：简化数据载体

什么是Record类？

Record类是Java 14中首次引入的预览特性，并在Java 16中正式发布，Java 17继续支持和优化了这一特性。Record类提供了一种简洁的方式来声明只用于存储数据的类。

传统方式与Record对比

在传统的Java编程中，创建一个数据类需要编写大量的样板代码：

// 传统方式
public class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

使用Record类，同样的功能可以简化为：

// 使用Record
public record Person(String name, int age) {}

这一行代码自动生成了：

私有的、final的字段
公共的构造函数
对应的访问方法（不是getXxx而是与字段同名的方法）
equals()、hashCode()和toString()方法

Record类的特性和限制

Record类有一些特性和限制需要注意：

不可变性：Record类的所有字段都是final的，这意味着一旦创建，就不能修改其状态。
不能继承：Record类隐式地继承自java.lang.Record，由于Java不支持多重继承，所以Record类不能继承其他类。
可以实现接口：尽管不能继承类，但Record类可以实现任意数量的接口。
可以添加静态字段和方法：Record类可以包含静态字段和方法。
可以自定义构造函数：可以提供自定义的构造函数，但必须调用规范构造函数。

实际应用示例

Record类特别适合用作DTO（数据传输对象）、值对象或不可变数据容器：

// 作为DTO
public record UserDTO(Long id, String username, String email) {}

// 作为复杂数据结构的一部分
public record Point(int x, int y) {}
public record Rectangle(Point topLeft, Point bottomRight) {
    // 自定义方法
    public int area() {
        return (bottomRight.x() - topLeft.x()) * (bottomRight.y() - topLeft.y());
    }
}

// 与Stream API结合使用
List<Person> people = List.of(
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
);

double averageAge = people.stream()
    .mapToInt(Person::age)
    .average()
    .orElse(0);

Sealed接口：控制类型层次结构

什么是Sealed接口？

Sealed接口（和类）是Java 17中正式发布的特性，它允许开发者精确控制哪些类可以实现某个接口或继承某个类。这提供了比传统访问修饰符更细粒度的控制。

为什么需要Sealed接口？

在传统的Java中，当我们创建一个接口或抽象类时，任何类都可以实现或继承它。这可能导致一些问题：

类型安全：无法确保只有特定的类实现了某个接口。
模式匹配：在进行模式匹配时，无法确保覆盖了所有可能的子类型。
API设计：难以创建一个封闭的类型层次结构。

Sealed接口解决了这些问题，允许开发者明确指定哪些类可以实现或继承它们。

Sealed接口的语法

// 声明一个sealed接口
public sealed interface Shape permits Circle, Rectangle, Triangle {}

// 实现类必须是final、sealed或non-sealed
public final class Circle implements Shape {
    private final double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double area() {
        return Math.PI * radius * radius;
    }
}

public final class Rectangle implements Shape {
    private final double width;
    private final double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    public double area() {
        return width * height;
    }
}

public final class Triangle implements Shape {
    private final double base;
    private final double height;
    
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    
    public double area() {
        return 0.5 * base * height;
    }
}

Sealed接口的规则

使用Sealed接口时需要遵循以下规则：

permits子句：sealed类或接口必须使用permits子句列出所有允许的子类或实现类。
子类修饰符：实现sealed接口或继承sealed类的类必须使用以下三种修饰符之一：
- final：表示该类不能被进一步继承
- sealed：表示该类也是sealed的，需要指定允许的子类
- non-sealed：表示该类可以被任何类继承，放弃了sealed的限制
可访问性：所有允许的子类必须与sealed类或接口位于同一个模块中，如果没有命名模块，则必须在同一个包中。

与Pattern Matching结合使用

Sealed接口的一个重要应用是与模式匹配结合使用。由于编译器知道所有可能的子类型，它可以在switch表达式中进行穷尽性检查：

// Java 17预览特性：switch的模式匹配
public double calculateArea(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分支，因为所有可能的子类型都已覆盖
    };
}

实际应用场景

Sealed接口特别适合以下场景：

领域模型：在DDD（领域驱动设计）中定义有限的实体或值对象集合。
代数数据类型：实现类似函数式编程中的代数数据类型。
API设计：创建封闭的类型层次结构，防止外部扩展。
编译时安全：结合模式匹配提供编译时的穷尽性检查。

Record类和Sealed接口的协同使用

Record类和Sealed接口可以协同使用，创建更强大、更安全的类型系统：

public sealed interface Vehicle permits Car, Truck, Motorcycle {}

public record Car(String model, int year, int doors) implements Vehicle {}
public record Truck(String model, int year, double cargoCapacity) implements Vehicle {}
public record Motorcycle(String model, int year, boolean hasSidecar) implements Vehicle {}

// 使用模式匹配处理不同类型的车辆
public String describeVehicle(Vehicle vehicle) {
    return switch (vehicle) {
        case Car c -> "Car: " + c.model() + ", " + c.year() + ", " + c.doors() + " doors";
        case Truck t -> "Truck: " + t.model() + ", " + t.year() + ", cargo capacity: " + t.cargoCapacity() + " tons";
        case Motorcycle m -> "Motorcycle: " + m.model() + ", " + m.year() + 
                            (m.hasSidecar() ? " with sidecar" : " without sidecar");
    };
}

这种组合提供了：

简洁的数据表示：通过Record类
类型安全：通过Sealed接口
穷尽性检查：通过模式匹配

与其他Java 17特性的结合

Java 17中的其他特性也可以与Record类和Sealed接口结合使用：

增强型伪随机数生成器

import java.util.random.RandomGenerator;

public record RandomPoint(double x, double y) {
    public static RandomPoint random() {
        RandomGenerator gen = RandomGenerator.getDefault();
        return new RandomPoint(gen.nextDouble(), gen.nextDouble());
    }
}

文本块（Java 15正式特性）

public record JsonExample(String name, int age) {
    public String toJson() {
        return """
               {
                   "name": "%s",
                   "age": %d
               }
               """.formatted(name, age);
    }
}