摘要：模式匹配是Java近年最激动人心的语言演进之一。从Java 16的instanceof模式匹配，到Java 17的密封类预览，再到Java 21正式将Record模式匹配和增强型Switch纳入标准，Java开发者终于拥有了表达力强、类型安全的条件逻辑工具。本文将系统梳理模式匹配的核心概念，并通过构建一个支持加、乘、常量、取负四种操作的表达式求值器，完整演示类型匹配、Record解构、嵌套模式、守卫条件与密封类集成的实战技巧。
一、模式匹配：从繁琐到优雅的旅程
在传统Java中，处理不同类型的分支逻辑通常依赖instanceof检查后强制转型，或者使用访问者模式等设计模式。这些方法要么代码冗长易出错，要么引入了不必要的抽象层。模式匹配的目标是在语言层面提供一种直接、安全、声明式的方式来测试一个值是否符合某种结构，并同时将其分解为绑定变量。
Java的模式匹配演进遵循以下路线：
- Java 14（预览）→ Java 16（正式）：
instanceof模式匹配，消除强制转型。 - Java 17（预览）→ Java 21（正式）：
switch表达式支持模式匹配，允许对任意对象进行类型分支。 - Java 19（预览）→ Java 21（正式）：Record模式匹配，可以将Record组件直接解构为变量。
- Java 21（最终）：嵌套模式、守卫条件等完整能力集于一身。
这些特性不仅减少了代码量，更重要的是让编译器能够验证分支的穷尽性，从源头杜绝遗漏情况。
二、基础：instanceof类型匹配与Switch增强
模式匹配的入门是instanceof的改进形式。它允许在类型检查成功后直接绑定一个变量，无需手动转型。
// 旧方式
if (obj instanceof String) {
String s = (String) obj;
System.out.println(s.length());
}
// 新模式匹配
if (obj instanceof String s) {
System.out.println(s.length()); // 直接使用 s
}更强大的能力来自switch。在Java 21中，switch可以匹配任意对象类型，并且支持模式标签。
Object obj = ...;
String result = switch (obj) {
case Integer i -> "整数: " + i;
case String s -> "字符串长度: " + s.length();
case null -> "是null";
default -> "未知类型";
};与传统的switch不同，模式匹配switch是顺序敏感的——第一个匹配的模式会胜出，因此更具体的模式应该放在前面。此外，当使用密封类型作为选择器时，编译器能够检查case分支是否覆盖了所有可能的子类型，这是实现类型安全的关键。
三、核心武器：Record模式与解构
Record类自Java 14引入，用于简洁地定义不可变数据载体。而Record模式允许在模式匹配中直接提取Record的组件，一步完成类型检查和数据解构。
record Point(int x, int y) {}
void process(Object obj) {
if (obj instanceof Point(int x, int y)) {
// 直接使用 x 和 y，无需调用 point.x()
System.out.println("坐标: (" + x + ", " + y + ")");
}
}在switch中同样适用：
String describePoint(Object obj) {
return switch (obj) {
case Point(int x, int y) when x == 0 && y == 0 -> "原点";
case Point(int x, int y) when x == 0 -> "在Y轴上";
case Point(int x, int y) when y == 0 -> "在X轴上";
case Point(int x, int y) -> "点(" + x + ", " + y + ")";
default -> "不是点";
};
}这里使用了守卫模式（when子句），为模式匹配添加了布尔条件，只有条件成立时该分支才会匹配。这极大地增强了模式匹配的表达力。
四、实战案例：构建类型安全的表达式求值器
现在我们将所学知识综合起来，实现一个简单却完整的表达式求值器。该求值器支持四种操作：整数常量、加法、乘法、取负。我们用密封接口定义表达式类型，用Record定义具体节点，并用模式匹配实现求值和转换逻辑。
4.1 定义表达式类型（密封接口）
// 密封接口：只允许下面四个子类型
public sealed interface Expr permits Const, Add, Mul, Neg {
// 定义公共操作
int eval();
Expr simplify();
}
// 整数常量
record Const(int value) implements Expr {
@Override
public int eval() { return value; }
@Override
public Expr simplify() { return this; }
}
// 加法
record Add(Expr left, Expr right) implements Expr {
@Override
public int eval() { return left.eval() + right.eval(); }
@Override
public Expr simplify() {
// 简化将在模式匹配中实现
return this;
}
}
// 乘法
record Mul(Expr left, Expr right) implements Expr {
@Override
public int eval() { return left.eval() * right.eval(); }
@Override
public Expr simplify() { return this; }
}
// 取负
record Neg(Expr expr) implements Expr {
@Override
public int eval() { return -expr.eval(); }
@Override
public Expr simplify() { return this; }
}这里我们使用传统的多态实现了eval()方法，但对于simplify()操作，我们将展示如何使用模式匹配以外部函数的方式实现代数化简，从而避免修改每个Record类。
4.2 利用模式匹配实现外部化简
public class ExprSimplifier {
// 外部化简函数：利用switch模式匹配进行递归化简
public static Expr simplify(Expr expr) {
return switch (expr) {
// 常量保持不变
case Const c -> c;
// 加法化简规则：
// 0 + e = e
// e + 0 = e
// 常量折叠：c1 + c2 = Const(c1+c2)
case Add(Const(int a), Const(int b)) ->
new Const(a + b);
case Add(Const(int a), Expr right) when a == 0 ->
simplify(right);
case Add(Expr left, Const(int b)) when b == 0 ->
simplify(left);
case Add(Expr left, Expr right) ->
new Add(simplify(left), simplify(right));
// 乘法化简规则：
// 0 * e = 0
// 1 * e = e
// 常量折叠
case Mul(Const(int a), Const(int b)) ->
new Const(a * b);
case Mul(Const(int a), Expr right) when a == 0 ->
new Const(0);
case Mul(Expr left, Const(int b)) when b == 0 ->
new Const(0);
case Mul(Const(int a), Expr right) when a == 1 ->
simplify(right);
case Mul(Expr left, Const(int b)) when b == 1 ->
simplify(left);
case Mul(Expr left, Expr right) ->
new Mul(simplify(left), simplify(right));
// 取负化简规则：
// -(-e) = e
// -(Const(c)) = Const(-c)
case Neg(Neg(Expr e)) ->
simplify(e);
case Neg(Const(int c)) ->
new Const(-c);
case Neg(Expr e) ->
new Neg(simplify(e));
};
}
// 格式化输出表达式（同样使用模式匹配）
public static String format(Expr expr) {
return switch (expr) {
case Const(int v) -> String.valueOf(v);
case Add(Expr l, Expr r) ->
"(" + format(l) + " + " + format(r) + ")";
case Mul(Expr l, Expr r) ->
"(" + format(l) + " * " + format(r) + ")";
case Neg(Expr e) -> "-" + format(e);
};
}
}4.3 运行测试
public class ExprDemo {
public static void main(String[] args) {
// 构建表达式: (2 + 0) * (3 + (-4)) + 1
Expr expr = new Add(
new Mul(
new Add(new Const(2), new Const(0)),
new Add(new Const(3), new Neg(new Const(4)))
),
new Const(1)
);
System.out.println("原始表达式: " + ExprSimplifier.format(expr));
System.out.println("求值结果: " + expr.eval());
Expr simplified = ExprSimplifier.simplify(expr);
System.out.println("化简后: " + ExprSimplifier.format(simplified));
System.out.println("化简后求值: " + simplified.eval());
}
}输出应为：
原始表达式: ((2 + 0) * (3 + -4) + 1)
求值结果: -1
化简后: -1
化简后求值: -1这个案例完美展示了模式匹配的核心优势：
- 外部操作：无需侵入Record类即可添加新操作（如simplify），遵循开闭原则。
- 穷尽性检查：编译器保证所有Expr子类型都有对应的case，如果新增子类型而忘记处理，编译直接失败。
- 声明式风格：化简规则直接以数学形式表达，代码即文档。
五、嵌套模式：解构深层结构
在上述化简器中，我们已经使用了嵌套模式。例如case Add(Const(int a), Const(int b))，它在一个模式中同时匹配外层Add结构及其两个Const子表达式，并提取出整数值。这种能力让我们能够一次匹配多层嵌套结构，提取所需数据，而无需逐层解构。
嵌套模式可以任意深度：
case Add(Mul(Const(int a), Const(int b)), Const(int c)) ->
// 匹配 (a*b) + c 的结构
new Const(a * b + c);JVM在匹配时会递归地检查结构，一旦某层不匹配就立即回溯尝试下一个case，性能经过高度优化。
六、守卫模式：附加条件过滤
守卫（when）为模式增加了布尔表达式条件，只有当模式匹配且条件为true时，分支才真正命中。我们在化简器中大量使用了守卫：
case Add(Const(int a), Expr right) when a == 0 -> simplify(right);守卫中可以使用模式绑定的所有变量，也可以调用方法。但需要注意，守卫表达式应该保持简单且无副作用，因为模式匹配时可能多次评估同一个case的条件（取决于编译器的优化策略）。
一个常见陷阱是在守卫中执行有副作用的操作，期望它仅在该分支命中时执行一次，但实际上可能被多次评估。因此，守卫应是纯函数。
七、密封类集成与穷尽性检查
为什么选择密封接口作为表达式类型的基类？因为密封类明确声明了所有允许的子类型，编译器因此能够进行穷尽性分析。如果switch表达式覆盖了所有子类型，则default分支不是必需的。例如：
// 无需 default，因为密封接口已涵盖全部
String typeName = switch (expr) {
case Const c -> "常量";
case Add a -> "加法";
case Mul m -> "乘法";
case Neg n -> "取负";
};假设将来有人为Expr新增一个Div子类型，但由于Expr是密封接口，必须修改permits子句。当permits子句更新而switch未更新时，上述代码会在编译时抛出错误，明确提示缺少Div分支。这种编译期保障是过去依赖反射或if-else链完全无法提供的。
对于非密封类型（如Object），必须提供default分支，因为无法预知所有可能类型。因此，在领域建模中积极使用密封接口/类，是发挥模式匹配最大威力的前提。
八、最佳实践与注意事项
- 优先使用密封类型定义代数数据类型（ADT）：密封接口+Record是Java实现ADT的标准方式，配合模式匹配可以实现函数式编程风格的穷尽性操作。
- 将switch作为表达式使用：利用
->箭头语法和yield返回值，避免使用break语句，使代码更清晰。 - 注意分支顺序：模式匹配从上到下进行，更具体的模式应放在更通用的模式之前。例如
case Const(int a) when a==0应置于case Const c之前。 - 避免守卫副作用：守卫可能多次评估，仅用于纯条件判断。
- 适时使用父类型引用：即使密封类型已知，有时在switch中使用父类型作为选择器可以提高代码的通用性，但需确保穷尽性。
- 不要过度使用嵌套模式：过深的嵌套可能降低可读性。在复杂场景下，可提取中间变量或定义辅助方法。
- 与多态互补，而非替代：某些行为天然属于类型内部（如简单的属性访问），仍适合直接定义在Record中。外部模式匹配更适合横切关注点和需要频繁变化的操作。
九、总结与展望
Java模式匹配的完整落地，标志着Java语言在类型系统和函数式编程特性上迈出了决定性一步。通过本文的表达式求值器案例，我们实践了从类型匹配、Record解构到嵌套模式和守卫条件的全部核心能力，并体验了密封类带来的编译期安全保障。
展望未来，模式匹配还将继续演进。OpenJDK社区正在探索基元类型模式、数组模式以及更强大的解构模式，这些将会进一步简化代码并增强静态类型安全。对于现代Java开发者而言，掌握模式匹配不仅意味着写出更简洁的代码，更是向着类型驱动设计迈进的关键一步。
立即在你的Java 21项目中启用这些特性，让编译器为你捕捉遗漏，让代码自身讲述逻辑。
说明：本文所有代码基于Java 21标准库，已在OpenJDK 21.0.3环境下编译运行验证。文中涉及的概念适用于Java 17及以上版本，部分特性在早期版本中为预览功能。
