Java 泛型 record pattern 怎么推断组件类型

在 Java 21 中，Box(var text) 并不是在运行时“猜”出 String。编译器会先看被匹配表达式的静态类型：如果选择器是 Box，就能把泛型 record Box 中的 T 推断为 String；随后 record 组件 T value 被适配成 String value，组件模式里的 var text 最终也就得到 String 类型。

官方资料：https://docs.oracle.com/en/java/javase/21/language/record-patterns.html

核心答案：推断分成两层

先看一个最小示例。方法参数已经把选择器的静态类型固定为 Box，所以 record pattern 可以省略类型实参，组件变量也可以写成 var。

record Box(T value) {}

static void printUpperCase(Box box) {
    // 第一层推断：Box(var text) 被推断为 Box(...)
    // 第二层推断：组件 T value 被适配为 String，因此 text 是 String
    if (box instanceof Box(var text)) {
        System.out.println(text.toUpperCase());
    }
}

可以把编译器的判断写成一个静态关系：选择器是 Box，record 声明是 Box，于是 T = String；组件声明中的 T 被替换后，var text 的类型自然是 String。这里没有读取对象中的运行时泛型参数，也没有突破类型擦除。

三种写法怎么选

面对同一个 Box，常见选择有类型模式、显式泛型 record pattern 和推断式 record pattern。三者不是语法长短之争，而是“要不要解构”和“上下文能否给出可靠静态类型”的选择。

static int length(Box box) {
    // 类型模式：保留整个对象，组件需要通过访问器获取
    if (box instanceof Box> whole) {
        return whole.value().toString().length();
    }
    return 0;
}

static void compare(Box box) {
    // 显式写法：边界类型一眼可见
    if (box instanceof Box(String text)) {
        System.out.println(text.length());
    }

    // 推断写法：选择器已经是 Box，省略重复信息
    if (box instanceof Box(var text)) {
        System.out.println(text.length());
    }
}

实践中，如果方法签名、局部变量声明或 switch 选择器已经清楚写出 Box，优先使用 Box(var text) 通常最简洁。如果代码位于公共 API 边界，或读者很难从上下文看出类型，显式写出 Box(String text) 会更容易审查。

var 推断的是适配后的组件类型

Java 语言规范的关键点是：嵌套在 record pattern 里的 var，其变量类型来自该 record pattern 中对应的组件字段类型。对泛型 record 而言，这个字段类型已经结合 record pattern 的类型实参完成适配。

import java.util.ArrayList;

record Bucket(ArrayList values) {}

static void inspect(Bucket bucket) {
    // T 已经是 String，因此 values 的适配类型是 ArrayList
    if (bucket instanceof Bucket(var values)) {
        String first = values.getFirst();
        System.out.println(first);
    }
}

因此，var 不是把类型退化成 Object，也不是类似动态语言的运行时变量。它仍有确定的编译期静态类型，IDE 补全、重载选择和编译检查都会使用这个类型。

嵌套泛型 record pattern 会逐层传播

record pattern 可以继续嵌套。外层选择器先确定外层 T，外层组件的适配类型再成为内层 pattern 的上下文，于是类型信息能向内传播。

record Box(T value) {}

static void printNested(Box> outer) {
    // 外层 T 是 Box，内层 T 再被确定为 String
    if (outer instanceof Box(Box(var text))) {
        System.out.println(text.toUpperCase());
    }
}

这段代码中的 text 仍然是 String。Oracle Java 21 指南把 Box(Box(var s)) 解释为由 Box> 上下文推断出的嵌套模式，说明推断依据始终是逐层传入的静态类型。

为什么原始类型不能硬匹配成 Box

泛型擦除并没有因为 record pattern 而消失。参数化 record pattern 只有在选择器能够安全转换到该 record 类型、且不需要 unchecked conversion 时才允许使用。下面的代码不能编译：

static void unsafe(Box rawBox) {
    // 编译错误：从原始 Box 到 Box 需要不安全转换
    if (rawBox instanceof Box(var text)) {
        System.out.println(text);
    }
}

原因很直接：运行时只能确认对象是 Box，无法凭擦除后的对象证明它一定是 Box。record pattern 提供的是安全解构，不是绕过泛型检查的入口。

Object、通配符和原始类型分别怎么处理

选择器是具体参数化类型：例如 Box，可以放心使用 Box(var text)，此时 text 是 String。

选择器是 Box>：上下文只承诺“某种类型”，组件变量通常保留通配符捕获后的上界能力，不能假设为 String。若业务必须区分组件类型，应在组件模式上继续做受检查的类型匹配。

static void printIfString(Box> box) {
    // 组件位置继续使用 String 类型模式，只有字符串组件才匹配
    if (box instanceof Box(String text)) {
        System.out.println(text.toUpperCase());
    }
}

选择器是 Object：只能匹配运行时可检查的 record 类型。不要期待从一个普通 Object 恢复 Box 的泛型实参；先根据可检查的结构和组件类型缩小范围。

一张表完成选型

常见问题

record pattern 的类型推断发生在运行时吗？

不是。类型实参和组件变量类型都由编译器根据静态类型确定；运行时只执行类型测试、调用组件访问器并继续匹配组件值。

组件写 var 会失去泛型信息吗？

不会。var 使用适配后的组件静态类型。选择器是 Box 时，Box(var text) 中的 text 就是 String。

什么时候应该显式写出 Box？

当上下文跨度大、代码位于 API 边界，或显式类型能显著提升可读性时可以写出；但前提仍然是该参数化类型可安全检查，不需要 unchecked conversion。