泛型

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：泛型