【Java基础】Java 8-21新特性 ：JDK17：密封类、模式匹配、Record类（附《思维导图》+《面试高频考点清单》）

小江的记录本2026-05-21 8:23

文章目录

Java 17核心特性：密封类、模式匹配、Record类 系统性知识体系

Java 17是Oracle于2021年9月发布的长期支持(LTS)版本 ，取代Java 11成为主流企业级开发标准。它引入的密封类、模式匹配和Record类三大核心特性，彻底改变了Java的类型系统和数据建模方式，标志着Java向更安全、更简洁、更具表达力的现代编程语言迈进。

一、整体概览与设计哲学

1.1 三大特性的核心定位

特性 解决的核心问题 设计目标 引入版本 最终定稿版本
Record类 纯数据载体类的冗余代码问题 简化不可变数据建模 Java 14(预览) Java 16
密封类 类层次结构的无限制继承问题 精确控制类型继承 Java 15(预览) Java 17
模式匹配 类型检查与转换的繁琐性 简化条件逻辑与数据解构 Java 14(预览) Java 17(switch)

1.2 统一设计哲学

  • 安全性优先：编译期检查替代运行时错误
  • 简洁性：消除样板代码，让开发者专注于业务逻辑
  • 兼容性：完全向后兼容，不破坏现有代码
  • 渐进式演进：通过预览版本收集反馈，逐步完善

二、Record类：不可变数据载体的终极解决方案

2.1 背景与痛点

传统Java中，纯数据载体类(POJO/DTO/VO)需要编写大量重复代码：

  • 私有字段
  • 构造函数
  • getter/setter方法
  • equals()、hashCode()方法
  • toString()方法

这些代码不仅繁琐，还容易出错，且无法强制保证不可变性。

2.2 基本语法与使用

java 复制代码 
// 定义一个Record类
public record Point(int x, int y) {}

// 使用Record类
Point p = new Point(10, 20);
System.out.println(p.x()); // 10 (注意：是x()不是getX())
System.out.println(p); // Point[x=10, y=20]
System.out.println(p.equals(new Point(10, 20))); // true

2.3 核心特性

  1. 自动生成所有标准方法

    • 构造函数：全参构造函数
    • 访问器方法：与字段同名的无参方法(不是getXxx风格)
    • equals()和hashCode()：基于所有字段的值
    • toString()：包含类名和所有字段的键值对

  2. 强制不可变性

    • 所有字段默认是private final
    • 不允许声明非final的实例字段
    • 不允许继承其他类(隐式继承java.lang.Record)
    • 不能声明为abstract

  3. 可自定义方法

    • 可以添加自定义构造函数
    • 可以添加自定义实例方法和静态方法
    • 可以实现接口

2.4 高级用法

  1. 紧凑构造函数

    java 复制代码 
    public record Point(int x, int y) {
    // 紧凑构造函数：用于参数验证
    public Point {
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException("坐标不能为负数");
        }
    }
}

  2. 自定义构造函数

    java 复制代码 
    public record Point(int x, int y) {
    // 自定义构造函数必须调用全参构造函数
    public Point(int x) {
        this(x, 0);
    }
}

  3. 实现接口

    java 复制代码 
    public interface Shape {
    double area();
}

public record Circle(double radius) implements Shape {
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

2.5 限制与注意事项

  • 不能继承其他类
  • 不能声明为abstract
  • 所有实例字段必须在组件列表中声明
  • 不能声明实例初始化器
  • 不能声明native方法

2.6 最佳实践

  • 优先使用Record作为纯数据载体类
  • 避免在Record中添加可变字段(虽然可以通过引用类型实现，但强烈不推荐)
  • 使用紧凑构造函数进行参数验证
  • 不要滥用Record，如果类有复杂的业务逻辑，应该使用普通类

三、密封类：精确控制类层次结构

3.1 背景与痛点

传统Java中，类的继承是无限制的：

  • 任何类都可以继承一个非final类
  • 无法限制类只能被特定的子类继承
  • 这导致API设计者无法精确控制类型层次结构
  • 当需要处理所有可能的子类时，无法在编译期保证穷尽性

3.2 基本语法与使用

java 复制代码 
// 定义一个密封类Shape，只允许Circle、Rectangle和Triangle继承
public sealed class Shape permits Circle, Rectangle, Triangle {}

// 子类必须声明为final、sealed或non-sealed
public final class Circle extends Shape {}
public sealed class Rectangle extends Shape permits Square {}
public non-sealed class Triangle extends Shape {}
public final class Square extends Rectangle {}

3.3 核心特性

  1. 精确控制继承

    • 使用sealed关键字声明密封类
    • 使用permits关键字指定允许的子类
    • 子类必须在同一个模块或同一个包中(除非是模块化项目)

  2. 子类的三种修饰符

    修饰符 含义
    final 不能再被继承
    sealed 可以继续被继承，但必须指定允许的子类
    non-sealed 恢复为普通的可继承类

  3. 接口也可以是密封的

    java 复制代码 
    public sealed interface Expr permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {}

3.4 高级用法

  1. 省略permits子句

    如果子类与密封类在同一个源文件中，可以省略permits子句：

    java 复制代码 
    public sealed class Shape {
    public final class Circle extends Shape {}
    public final class Rectangle extends Shape {}
}

  2. 密封类与Record结合

    java 复制代码 
    public sealed interface Expr permits Constant, Plus, Times, Neg {}
public record Constant(int value) implements Expr {}
public record Plus(Expr left, Expr right) implements Expr {}
public record Times(Expr left, Expr right) implements Expr {}
public record Neg(Expr expr) implements Expr {}

3.5 限制与注意事项

  • 密封类的子类必须是可访问的
  • 子类必须直接继承密封类
  • 密封类不能是匿名类或本地类
  • 密封接口的实现类必须声明为final、sealed或non-sealed

3.6 最佳实践

  • 使用密封类来表示封闭的类型层次结构
  • 优先使用final作为子类的修饰符，除非确实需要进一步继承
  • 避免使用non-sealed，除非有充分的理由
  • 密封类与模式匹配结合使用，可以实现穷尽性检查

四、模式匹配：简化类型检查与数据解构

4.1 背景与痛点

传统Java中，类型检查与转换非常繁琐：

java 复制代码 
if (obj instanceof String) {
    String s = (String) obj;
    // 使用s
}

这种写法不仅重复，还容易出错，且无法在编译期保证类型安全。

4.2 instanceof模式匹配(Java 16+)

4.2.1 基本语法
java 复制代码 
if (obj instanceof String s) {
    // 直接使用s，无需强制转换
    System.out.println(s.length());
}
4.2.2 核心特性
  • 自动进行类型转换
  • 模式变量在if块内有效
  • 支持在条件中使用模式变量
  • 支持与逻辑运算符结合
4.2.3 高级用法
java 复制代码 
// 与逻辑运算符结合
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s);
}

// 在switch中使用(Java 17+)
String format(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l -> String.format("long %d", l);
        case Double d -> String.format("double %f", d);
        case String s -> String.format("String %s", s);
        default -> obj.toString();
    };
}

4.3 switch模式匹配(Java 17+)

4.3.1 基本语法
java 复制代码 
static String formatterPatternSwitch(Object o) {
    return switch (o) {
        case Integer i -> String.format("int %d", i);
        case Long l -> String.format("long %d", l);
        case Double d -> String.format("double %f", d);
        case String s -> String.format("String %s", s);
        default -> o.toString();
    };
}
4.3.2 核心特性
  • 支持类型模式
  • 支持null处理
  • 支持守卫模式
  • 支持穷尽性检查(当与密封类结合时)
4.3.3 高级用法

  1. null处理

    java 复制代码 
    static void test(String s) {
    switch (s) {
        case null -> System.out.println("null");
        case "foo" -> System.out.println("foo");
        default -> System.out.println("other");
    }
}

  2. 守卫模式

    java 复制代码 
    static String formatterGuardedPatterns(Object o) {
    return switch (o) {
        case String s && s.length() > 5 -> "长字符串: " + s;
        case String s -> "短字符串: " + s;
        case Integer i && i > 100 -> "大整数: " + i;
        case Integer i -> "小整数: " + i;
        default -> "其他类型";
    };
}

  3. 与密封类结合的穷尽性检查

    java 复制代码 
    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 {}

static double area(Shape shape) {
    // 不需要default分支，编译器会检查所有可能的子类
    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();
    };
}

4.4 记录模式(Java 21+)

虽然记录模式在Java 21才正式定稿，但它是模式匹配的重要组成部分，与Record类和密封类密切相关：

java 复制代码 
static double area(Shape shape) {
    return switch (shape) {
        case Circle(double r) -> Math.PI * r * r;
        case Rectangle(double w, double h) -> w * h;
        case Triangle(double b, double h) -> 0.5 * b * h;
    };
}

4.5 限制与注意事项

  • 模式变量是final的，不能重新赋值
  • 模式匹配只能用于引用类型
  • switch模式匹配中，case的顺序很重要，更具体的case应该放在前面
  • 穷尽性检查只适用于密封类和枚举类型

4.6 最佳实践

  • 优先使用instanceof模式匹配替代传统的类型检查与转换
  • 使用switch模式匹配处理多个类型的情况
  • 与密封类结合使用，利用编译器的穷尽性检查
  • 避免过度复杂的模式，保持代码的可读性

五、三大特性的协同使用

5.1 代数数据类型(ADT)的实现

Java 17通过密封类+Record类+模式匹配，终于可以优雅地实现代数数据类型：

java 复制代码 
// 定义一个表达式的代数数据类型
sealed interface Expr permits Constant, Plus, Times, Neg {}
record Constant(int value) implements Expr {}
record Plus(Expr left, Expr right) implements Expr {}
record Times(Expr left, Expr right) implements Expr {}
record Neg(Expr expr) implements Expr {}

// 使用模式匹配计算表达式的值
static int eval(Expr e) {
    return switch (e) {
        case Constant(int v) -> v;
        case Plus(Expr l, Expr r) -> eval(l) + eval(r);
        case Times(Expr l, Expr r) -> eval(l) * eval(r);
        case Neg(Expr expr) -> -eval(expr);
    };
}

5.2 领域驱动设计(DDD)中的应用

  • 使用Record类表示值对象(Value Object)
  • 使用密封类表示聚合根(Aggregate Root)的状态
  • 使用模式匹配处理不同状态的业务逻辑

5.3 错误处理的改进

java 复制代码 
sealed interface Result<T> permits Success, Failure {}
record Success<T>(T value) implements Result<T> {}
record Failure<T>(String message) implements Result<T> {}

<T> Result<T> divide(int a, int b) {
    if (b == 0) {
        return new Failure<>("除数不能为零");
    }
    return new Success<>(a / b);
}

void processResult(Result<Integer> result) {
    switch (result) {
        case Success<Integer>(int value) -> System.out.println("结果: " + value);
        case Failure<Integer>(String message) -> System.err.println("错误: " + message);
    }
}

六、性能与兼容性

6.1 性能影响

  • Record类：与手写的POJO性能几乎相同，因为编译器生成的代码与手写代码非常相似
  • 密封类：没有运行时性能开销，所有检查都在编译期完成
  • 模式匹配：编译期优化，运行时性能与传统写法相当

6.2 向后兼容性

  • 所有特性都是完全向后兼容的
  • 现有代码可以继续正常运行
  • 可以逐步迁移到新特性
  • 字节码与旧版本JVM兼容(但需要使用--release选项)

七、总结与未来展望

7.1 核心价值总结

  1. Record类：彻底解决了纯数据载体类的冗余代码问题，强制不可变性，提高了代码的可靠性
  2. 密封类：精确控制类层次结构，为模式匹配的穷尽性检查提供了基础
  3. 模式匹配：简化了类型检查与转换，使代码更简洁、更易读、更安全

这三个特性相互配合，使Java终于具备了现代编程语言的核心能力，为函数式编程和领域驱动设计提供了更好的支持。

7.2 未来发展方向

  • 记录模式：Java 21已正式引入，进一步简化数据解构
  • 模式匹配的扩展：支持更多类型的模式，如数组模式、泛型模式等
  • 值类型：Project Valhalla将引入值类型，与Record类结合，进一步提高性能
  • 模式匹配与异常处理：可能会引入模式匹配的异常处理机制

Java 17三大特性：面试考点清单+高频面试题标准答案

一、核心考点速记（可直接背诵）

考点1：Record类（不可变数据载体）

  1. 核心定位：专门用于纯数据载体的类，彻底消除POJO/DTO/VO的样板代码
  2. 自动生成内容：全参构造函数、与字段同名的访问器（非getXxx风格）、equals()/hashCode()（基于所有字段）、toString()（类名+所有字段键值对）
  3. 强制不可变性 ：所有字段默认private final，不能声明非final实例字段
  4. 关键限制 ：
    • 隐式继承java.lang.Record，不能再继承其他类
    • 不能声明为abstract
    • 不能有实例初始化器
    • 所有实例字段必须在组件列表中声明
  5. 高级特性 ：
    • 紧凑构造函数：用于参数验证，无参数列表，自动关联组件
    • 可自定义构造函数（必须调用全参构造）
    • 可实现接口，可添加静态/实例方法

考点2：密封类（精确控制继承）

  1. 核心定位：限制类/接口只能被指定的子类继承/实现，解决传统Java继承无限制的问题
  2. 核心语法 ：sealed 类/接口名 permits 子类1, 子类2, ...
  3. 子类必须声明的三种修饰符 ：
    • final：不能再被继承（最常用）
    • sealed：可以继续被继承，但必须再次指定允许的子类
    • non-sealed：恢复为普通可继承类（尽量避免使用）
  4. 关键特性 ：
    • 接口也可以声明为密封接口
    • 子类与密封类同文件时可省略permits子句
    • 所有检查都在编译期完成，无运行时开销
  5. 核心价值 ：为模式匹配的穷尽性检查提供基础

考点3：模式匹配（简化类型操作）

3.1 instanceof模式匹配（Java 16+）
  1. 语法 ：if (obj instanceof 类型 变量名)
  2. 优势：自动完成类型检查+强制转换，避免重复代码和类型转换错误
  3. 特性 ：模式变量在if块内有效，可与逻辑运算符&&结合使用
3.2 switch模式匹配（Java 17+）
  1. 核心能力：支持类型模式、null处理、守卫模式、穷尽性检查
  2. 关键特性 ：
    • 直接在case中进行类型匹配和变量绑定
    • 原生支持null（单独case null处理）
    • 守卫模式：case 类型 变量 && 条件
    • 与密封类结合时，编译器自动检查所有可能的子类，无需default分支
  3. 限制：模式变量是final的，不能重新赋值；case顺序必须从具体到通用

考点4：三大特性协同

  1. 代数数据类型(ADT)实现：密封类定义封闭类型层次 + Record类定义不可变数据节点 + 模式匹配实现数据解构与处理
  2. 典型应用场景：表达式求值、状态机、错误处理（Result类型）、领域驱动设计的值对象

二、高频面试题及标准答案

基础概念类

Q1：为什么Java要引入Record类？它和普通类有什么区别？

标准答案 ：

引入Record类是为了解决传统Java中纯数据载体类（POJO/DTO）需要编写大量重复样板代码的问题，同时强制保证数据的不可变性。

与普通类的核心区别：

  1. Record类隐式继承java.lang.Record，不能再继承其他类；普通类可以继承任意非final类
  2. Record类所有字段默认private final，强制不可变；普通类字段可自由定义
  3. Record类自动生成构造函数、访问器、equals()、hashCode()、toString()；普通类需要手动编写
  4. Record类不能声明为abstract，不能有实例初始化器；普通类没有这些限制

Q2：Record类和Lombok的@Data注解有什么区别？

标准答案：

  1. 本质不同：Record是Java语言层面的特性，由编译器原生支持；Lombok是第三方库，通过注解处理器在编译期生成代码
  2. 不可变性：Record强制所有字段不可变；@Data默认生成setter方法，字段是可变的
  3. 继承限制：Record不能继承其他类；@Data注解的类可以正常继承
  4. 访问器命名 ：Record的访问器与字段同名（如name()）；@Data生成的是JavaBean风格的getName()
  5. 可靠性：Record是标准特性，兼容性好；Lombok依赖第三方库，可能存在版本兼容问题

Q3：密封类解决了什么问题？为什么之前的final和abstract不够用？

标准答案 ：

密封类解决了传统Java中类继承无限制的问题，允许API设计者精确控制类型层次结构。

之前的修饰符存在明显不足：

  • final：完全禁止继承，过于极端，无法实现有限制的继承
  • abstract：允许任意子类继承，无法限制只能被特定子类继承

密封类填补了这一空白，它既允许继承，又将继承限制在指定的子类范围内，为模式匹配的穷尽性检查提供了基础。

Q4：密封类的子类为什么只能声明为final、sealed或non-sealed？

标准答案 ：

这是为了保证密封类的继承限制能够传递下去，确保整个类型层次结构是封闭的：

  • final：终止继承链，确保该子类不会再有其他子类
  • sealed：继续传递密封限制，允许该子类有自己的指定子类
  • non-sealed：显式打破密封限制，恢复为普通可继承类

如果没有这一强制要求，子类可以被任意其他类继承，密封类的限制就会失效。

Q5：模式匹配相比传统的类型检查和转换有什么优势？

标准答案：

  1. 代码更简洁：将类型检查和强制转换合并为一步，消除重复代码
  2. 更安全 ：编译器自动保证类型安全，避免手动转换可能出现的ClassCastException
  3. 可读性更好：意图更清晰，直接表达"如果是某个类型，就做某事"的逻辑
  4. 功能更强大：支持守卫模式、null处理、穷尽性检查等传统写法无法实现的特性

进阶应用类

Q6：什么是穷尽性检查？它在什么情况下生效？

标准答案 ：

穷尽性检查是指编译器能够检查switch语句是否覆盖了所有可能的输入类型，从而不需要default分支。

它只在以下两种情况下生效：

  1. switch的表达式类型是枚举类型
  2. switch的表达式类型是密封类/密封接口

当添加新的子类时，编译器会报错，提醒开发者处理新的情况，避免运行时遗漏。

Q7：如何使用Java 17的三大特性实现代数数据类型(ADT)？请举例说明。

标准答案 ：

代数数据类型是一种由"和类型"与"积类型"组成的数据类型，Java 17通过以下方式实现：

  • 密封类/接口：实现"和类型"（表示"是A或B或C"）
  • Record类：实现"积类型"（表示"由A和B和C组成"）
  • 模式匹配：实现对ADT的解构与处理

示例（表达式求值）：

java 复制代码 
// 和类型：表达式可以是常量、加法、乘法或负数
sealed interface Expr permits Constant, Plus, Times, Neg {}
// 积类型：每个具体表达式由相应的组件组成
record Constant(int value) implements Expr {}
record Plus(Expr left, Expr right) implements Expr {}
record Times(Expr left, Expr right) implements Expr {}
record Neg(Expr expr) implements Expr {}

// 模式匹配处理所有可能的表达式类型
static int eval(Expr e) {
    return switch (e) {
        case Constant(int v) -> v;
        case Plus(Expr l, Expr r) -> eval(l) + eval(r);
        case Times(Expr l, Expr r) -> eval(l) * eval(r);
        case Neg(Expr expr) -> -eval(expr);
    };
}

Q8：使用密封类和模式匹配实现错误处理有什么优势？

标准答案 ：

相比传统的异常处理，使用密封类+Record+模式匹配实现的Result类型具有以下优势：

  1. 显式错误处理：方法返回值明确表示可能成功或失败，强制调用者处理错误
  2. 类型安全：编译器检查所有可能的结果类型，避免遗漏错误处理
  3. 可携带更多信息：错误类型可以携带详细的错误信息，而不仅仅是异常消息
  4. 函数式友好：可以方便地进行链式调用和组合，适合函数式编程风格

示例：

java 复制代码 
sealed interface Result<T> permits Success, Failure {}
record Success<T>(T value) implements Result<T> {}
record Failure<T>(String message, int code) implements Result<T> {}

易错点与陷阱类

Q9：Record类的访问器方法为什么不是getXxx风格？

标准答案 ：

这是Java设计者的有意选择，主要原因有：

  1. 简洁性：直接使用字段名作为方法名更简洁，符合Record作为纯数据载体的定位
  2. 避免冲突：如果字段名本身以"get"开头，传统的getter命名会产生冲突
  3. 一致性：与Java 8引入的函数式接口方法命名风格保持一致

注意：如果需要JavaBean风格的getter方法，可以手动添加，但不推荐这样做。

Q10：switch模式匹配中case的顺序有什么要求？为什么？

标准答案 ：

case的顺序必须从具体到通用，更具体的case应该放在更通用的case前面。

例如，String s && s.length() > 5应该放在String s前面，Integer i应该放在Object o前面。

这是因为switch模式匹配是按顺序匹配的，一旦匹配到某个case就会执行对应的分支。如果通用的case放在前面，会覆盖后面更具体的case，导致后面的case永远不会被执行，编译器会报错。

三、易错点与陷阱总结（必背）

  1. ❌ Record类的访问器是fieldName()，不是getFieldName()
  2. ❌ 密封类的子类必须在同一个模块或同一个包中（模块化项目除外）
  3. ❌ 模式变量是final的，不能在匹配块中重新赋值
  4. ❌ switch模式匹配中，null不会匹配default分支，必须单独用case null处理
  5. ❌ 穷尽性检查只适用于密封类和枚举类型，普通类仍然需要default分支
  6. ❌ Record类不能继承其他类，但可以实现接口
  7. ❌ 密封类不能是匿名类或本地类
  8. ❌ 不要在Record中使用可变引用类型，否则会破坏不可变性
相关推荐
invicinble5 小时前
java数组相关的信息量
java·开发语言·python
Purple Coder5 小时前
面试题目总结
面试·职场和发展
敲上瘾5 小时前
LangChain 消息机制与提示词模板指南
大数据·python·langchain
小江的记录本5 小时前
【Java基础】集合框架： ArrayList vs LinkedList 核心区别、扩容机制（附《思维导图》+《面试高频考点清单》）
java·数据库·python·mysql·spring·面试·maven
夕除5 小时前
spring boot 10
java·python·spring
牧瀬クリスだ5 小时前
Java线程——从创建第一个线程到休眠线程
java·开发语言
石小千5 小时前
mysql8全文检索
mysql·全文检索
清水白石0085 小时前
从“点一下导出”到生产级任务队列：Python 异步导出系统设计全景解析
java·数据库·python
Mahir085 小时前
Spring 核心原理：IoC/DI 与 Bean 生命周期全景解析
java·后端·spring·面试·bean生命周期·控制反转ioc·依赖注入di
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03CC-Switch & Claude 基于 Linux 服务器安装使用指南04几个好用的ip纯净度检测网站05裂开！ChatGPT 居然开始要手机号验证，附详细解决方法06用了半年 OpenRouter，我换到了 Ofox.ai — 两个 AI API 聚合平台的真实对比07【AI】2026 年具身智能模型和世界模型总结08【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法09装上就回不去了：CodeGraph 让 AI 编程效率飙升 92%，它到底做了什么？10codex app每次打开重连5次Reconnecting问题解决