泛型

是什么，为什么存在

Java 泛型（generic） 允许声明参数化类型和泛型方法。List<String> 中的 String 是类型实参，它把列表的元素类型固定为 String；class Box<T> 中的 T 是 类型参数（type parameter） ，由使用方在具体位置提供类型。

泛型解决的重点不是「少写一次强制转换」，而是保存类型之间的关系。static <T> T first(List<T> values) 表示返回值与列表元素是同一个 T。若改成接收 List<?> 并返回 Object，代码虽然能读元素，却丢掉了调用方需要的关系。

编译器会在调用点检查这些关系。把整数加入 List<String>、把 Optional<Integer> 当成 Optional<Number>，或者用不满足边界的类型实参，都会在编译期失败。泛型不能证明业务数据正确，但能排除一整类容器内容与 API 连接错误。

你会在集合、Optional、Stream、Comparator、异步 API 和框架扩展点中持续遇到泛型。自己设计 API 时，泛型适合表达「算法不关心具体类型，但若干位置必须一致」或「输入可以来自某个类型族」。若实现只对一种类型有意义，增加 <T> 只会把真实约束藏起来。

Java 泛型只接受引用类型作为类型实参，因此要写 List<Integer>，不能写 List<int>。自动装箱让多数调用看起来自然，但空值、对象分配和数值相等规则仍然属于包装类型的契约。

工作原理

类型参数写在声明名称或方法返回类型之前。类的 T 可用于实例字段、实例方法参数和返回值；静态成员不属于任何具体实例，不能直接使用类的 T。静态方法可以声明自己的 <T>，它与同名的类类型参数也是独立声明。

编译器通常从实参、目标类型和边界推断类型实参，所以 new ArrayList<String>() 常可写成 new ArrayList<>()。显式类型实参仍可写在方法名前，例如 Warehouse.<Number>first(values)；只有在推断失败或需要说明意图时才值得这样做。

泛型类型具有不变性（invariance）。即使 Integer 是 Number 的子类型，List<Integer> 也不是 List<Number> 的子类型；否则，接收后者的方法就能加入 Double，破坏原列表的元素契约。数组采用协变且在运行时检查写入，因此不要把数组规则套到泛型上。

通配符（wildcard）表示某个受约束但未知的类型实参。它适合 API 使用点，不适合表示实现中需要反复命名的类型关系。下面的读写能力来自编译器对未知类型的保守判断：

PECS 是「Producer Extends, Consumer Super」的缩写。生产与消费描述的是某个参数相对于方法的作用，而不是容器类的永久身份。一个参数既要读出 T 又要写回 T 时，通常需要命名类型参数，而不是强行选择一个通配符。

上界限制可替换类型并开放边界成员，例如 <T extends Number> 允许实现调用 doubleValue()。多重边界中，类边界若存在必须放在最前，后面可以跟接口，例如 <T extends Number & Comparable<T>>。递归形式 <T extends Comparable<? super T>> 允许 T 与 T 的某个父类型定义自然顺序，通常比 Comparable<T> 更灵活。

类型参数与通配符解决不同问题。<T> 为未知类型命名，让多个位置保持关系；? 则明确调用方不需要知道该类型的名字。若一个类型只出现一次，额外声明 <T> 往往没有提供关系；若同一未知类型必须跨参数或返回值复用，通配符又可能过于模糊。

从签名推导能力

阅读复杂泛型签名时，不必先猜编译器的全部推断过程。先选一个调用点，把每个类型变量与通配符改写成约束，再检查方法体需要的操作是否由这些约束支持。

1. 找出声明引入的类型参数，例如方法开头的 <T>。
2. 标出同一个 T 出现的所有参数、返回值和边界位置。
3. 对每个 ? extends 参数只承诺读取上界，对每个 ? super 参数只承诺写入下界。
4. 检查调用点提供的类型是否同时满足所有约束，而不是逐个参数独立判断。
5. 最后检查返回类型是否向调用方保留了实际有用的关系。

例如 static <T> T choose(T left, T right) 不要求两个实参的运行时类相同，而是要求编译器能推断出一个同时容纳两者的 T。若结果被赋给过宽的目标类型，调用仍能编译，但调用方可能主动丢失更精确的信息。

声明位置与使用位置

Java 的类和接口在声明位置定义类型参数及其上界，例如 class Box<T extends Item>。通配符出现在使用参数化类型的位置，例如 List<? extends Item>；它不会修改 List 本身的声明，而是限制当前引用能安全执行的操作。

公开签名应以调用方真正需要的灵活性为准，而不是让每个位置都出现通配符。过窄的 List<T> 会拒绝安全调用，过宽的 List<?> 又会删除返回关系；最小但完整的约束通常最容易使用和测试。

示例

下面四个程序依次展示类型关系、PECS、边界与通配符捕获，以及擦除后的运行时视图。所有输出均由本地 OpenJDK 21.0.12 使用 javac --release 21 -Xlint:all 编译并执行得到；所用语法与 API 在目标 Java 25 中仍有效。

声明并推断类型参数

Bin<T> 把标签之外的载荷类型交给实例决定，first() 则为每次调用单独推断 T。返回值保持列表的元素类型，因此调用方无需强制转换。

菱形语法 <> 让构造器从目标位置推断 Bin<String>，var 只省略局部变量上的重复拼写，并没有使变量变成动态类型。counts 的静态类型仍由初始化表达式确定。

空列表没有可返回的元素，因此方法显式拒绝它。用 null 作为哨兵会把本来清楚的返回类型关系变成额外的空值协议；如果空值有业务含义，可由调用方选择 Optional<T> 等更明确的接口。

用 PECS 连接不同的列表

源列表只向方法提供 T，所以它是生产者；目标列表只接收 T，所以它是消费者。同一个签名可以把 List<Integer> 追加到 List<Number>，同时保留编译期检查。

import java.util.ArrayList;
import java.util.List;

public class CopyOrders {
    static <T> void appendAll(
            List<? super T> destination,
            List<? extends T> source) {
        destination.addAll(source);
    }

    static double total(List<? extends Number> values) {
        double result = 0.0;
        for (Number value : values) {
            result += value.doubleValue();
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> dailyOrders = List.of(3, 5, 2);
        List<Number> report = new ArrayList<>();

        appendAll(report, dailyOrders);
        System.out.println(report);
        System.out.println(total(report));
    }
}

[3, 5, 2]
10.0

在 appendAll() 内，从 source 取得的值至少是 T，而 destination 保证能接收 T。反过来，从 destination 读取时只能依赖 Object，因为它的真实元素类型可能是 T、T 的父类或 Object。

total() 只读取数值，因此不需要把调用方限制为精确的 List<Number>。它不能向 values 加入 Integer 或 Double，因为实际列表可能是另一种 Number 子类型的列表。

组合边界与通配符捕获

max() 用边界保证元素可比较，swapFirstTwo() 则把未知类型交给私有辅助方法命名。这种通配符捕获让实现可以安全地取出并写回同一种未知元素。

import java.util.ArrayList;
import java.util.List;

public class BoundsAndCapture {
    static <T extends Comparable<? super T>> T max(
            List<? extends T> values) {
        if (values.isEmpty()) {
            throw new IllegalArgumentException("values must not be empty");
        }
        T result = values.getFirst();
        for (T value : values) {
            if (value.compareTo(result) > 0) {
                result = value;
            }
        }
        return result;
    }

    static void swapFirstTwo(List<?> values) {
        swap(values, 0, 1);
    }

    private static <T> void swap(List<T> values, int left, int right) {
        T saved = values.get(left);
        values.set(left, values.get(right));
        values.set(right, saved);
    }

    public static void main(String[] args) {
        var queues = new ArrayList<>(List.of("fast", "bulk", "slow"));
        swapFirstTwo(queues);
        System.out.println(queues);
        System.out.println(max(queues));
    }
}

[bulk, fast, slow]
slow

公开方法不需要向调用方暴露辅助类型参数。编译器在调用 swap() 时为 List<?> 的未知元素类型创建一个捕获类型，并在一次调用内保持一致。

边界只保证 compareTo() 可用，不保证比较顺序适合业务。排序规则、空列表策略和 null 是否允许仍需由 API 契约说明；泛型不能替代这些领域决策。

观察擦除后的信息

两个不同类型实参的 ArrayList 共享同一个运行时类，但字段声明仍可携带泛型签名供反射读取。这两件事并不矛盾：对象通常不知道列表元素的具体类型，类文件中的声明位置却可以保留签名元数据。

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class ErasureView {
    private List<String> names = List.of("Ada");

    public static void main(String[] args) throws Exception {
        List<String> strings = new ArrayList<>();
        List<Integer> integers = new ArrayList<>();
        Object candidate = strings;

        System.out.println("same runtime class: "
                + (strings.getClass() == integers.getClass()));

        Field field = ErasureView.class.getDeclaredField("names");
        System.out.println("field class: " + field.getType());
        System.out.println("field signature: " + field.getGenericType());
        System.out.println("list<?> check: " + (candidate instanceof List<?>));
    }
}

same runtime class: true
field class: interface java.util.List
field signature: java.util.List<java.lang.String>
list<?> check: true

field.getType() 返回擦除后的 List 类，getGenericType() 读取声明签名。局部变量 strings 的类型实参不会变成每个列表对象上的运行时标签，因此不能写 candidate instanceof List<String>。

List<?> 是可具体化类型，可以用于 instanceof，因为检查只需确认对象是某种 List。检查成功后仍只知道元素来自某个未知类型，不能把它当成 List<String>。

陷阱

把子类型关系传给泛型容器

修复方法： 按参数的数据流选择 List<? extends Number> 或 List<? super Integer>。实现确实需要同一元素类型同时读写时，声明命名类型参数并让所有相关位置使用它。

用原始类型绕过编译错误

修复方法： 使用 javac -Xlint:all 检查原始类型与未检查转换，并逐个证明值的来源。抑制范围应尽可能小，注释要写出保持转换安全的不变量，而不是只写「编译器误报」。

把 extends 当成可写上界

修复方法： 需要写入 Integer 时使用 List<? super Integer>。若方法既读又写同一种元素，让 <T> 命名该类型；不要用非空试写来猜测通配符代表的真实类型。

误以为类型实参始终可在运行时查询

修复方法： 运行时确实需要类型时，显式传递 Class<T>、受控的类型令牌或解析器，并写清它能表示的类型范围。不要把字段签名中的反射信息误认为任意对象都保留同样信息。

把数组规则套到泛型上

修复方法： 大多数情况下改用 List<T>。必须与数组 API 交互时，要求调用方提供数组工厂或 Class<T>，把不可避免的转换封装在一个可验证边界，并测试错误组件类型。

延伸阅读

• Java 语言规范 25：参数化类型
• Java 语言规范 25：类型擦除
• Java 语言规范 25：可具体化类型
• Java 语言规范 25：泛型方法
• Dev.java：泛型