深度解析 Java 泛型通配符 `＜? super T＞` 和 `＜? extends T＞`

Java 泛型中的通配符 ? 与 super、extends 关键字组合形成的 <? super T> 和 <? extends T> 是泛型系统中最重要的概念之一，也是许多开发者感到困惑的地方。本文将全面剖析它们的语义、使用场景和设计原理。

一、基础概念回顾

1. 泛型通配符 `?`

? 表示"未知类型"，是泛型系统中的通配符。它解决了泛型不变性(invariance)带来的限制，为泛型系统增加了灵活性。

2. 上下界通配符

<? extends T>: 上界通配符(Upper Bounded Wildcard)
<? super T>: 下界通配符(Lower Bounded Wildcard)

二、`<? extends T>` 深入解析

1. 语义含义

表示"某种未知类型，但它是 T 或其子类"。例如：

List<? extends Number> list = new ArrayList<Integer>();

2. 特点

读取安全：可以安全地从集合中读取元素为 T 类型
写入限制：不能向集合中添加任何元素(null 除外)

3. 类型系统原理

<? extends T> 使集合变为生产者(Producer)，遵循PECS原则(Producer-Extends)。

public static double sum(List<? extends Number> list) {
    double sum = 0;
    for (Number n : list) {
        sum += n.doubleValue();
    }
    return sum;
}

4. 使用场景

只读取不修改的集合参数
返回不可变视图
实现协变(Covariant)行为

三、`<? super T>` 深入解析

1. 语义含义

表示"某种未知类型，但它是 T 或其父类"。例如：

List<? super Integer> list = new ArrayList<Number>();

2. 特点

写入安全：可以安全地向集合添加 T 及其子类元素
读取限制：读取的元素只能作为 Object 处理

3. 类型系统原理

<? super T> 使集合变为消费者(Consumer)，遵循PECS原则(Consumer-Super)。

public static void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

4. 使用场景

只写入不读取的集合参数
实现逆变(Contravariant)行为
回调接口设计

四、对比分析

特性	`<? extends T>`	`<? super T>`
方向	上界(协变)	下界(逆变)
读取	安全(作为T类型)	不安全(只能作为Object)
写入	不安全(除null)	安全(可添加T及其子类)
PECS角色	Producer	Consumer
典型应用	数据提供源	数据消费端

五、类型系统理论基础

1. 里氏替换原则(LSP)

<? extends T> 和 <? super T> 的设计遵循了LSP原则：

子类可以替换父类而不影响程序行为
父类可以接受子类作为参数

2. 协变与逆变

协变(Covariant): 子类型关系与泛型类型关系一致(<? extends T>)
逆变(Contravariant): 子类型关系与泛型类型关系相反(<? super T>)
不变(Invariant): 无子类型关系(普通泛型<T>)

六、高级应用模式

1. PECS 原则

Producer-Extends, Consumer-Super 的缩写，指导通配符使用的黄金法则。

public static <T> void copy(
    List<? super T> dest,  // 消费者，使用super
    List<? extends T> src  // 生产者，使用extends
) {
    for (int i = 0; i < src.size(); i++) {
        dest.add(src.get(i));
    }
}

2. 类型安全的异构容器

结合通配符实现灵活的类型安全容器：

class Favorites {
    private Map<Class<?>, Object> favorites = new HashMap<>();
    
    public <T> void putFavorite(Class<T> type, T instance) {
        favorites.put(Objects.requireNonNull(type), instance);
    }
    
    public <T> T getFavorite(Class<T> type) {
        return type.cast(favorites.get(type));
    }
}

七、常见误区与陷阱

混淆通配符与类型参数：

// 错误理解
List<? extends Number> list = new ArrayList<? extends Number>();

// 正确用法
List<? extends Number> list = new ArrayList<Integer>();

忽略通配符捕获：

// 编译错误
void swap(List<?> list) {
    Object temp = list.get(0);
    list.set(0, list.get(1));  // 错误
    list.set(1, temp);         // 错误
}

// 正确方式：使用辅助方法捕获通配符
void swap(List<?> list) {
    swapHelper(list);
}

private <E> void swapHelper(List<E> list) {
    E temp = list.get(0);
    list.set(0, list.get(1));
    list.set(1, temp);
}

八、最佳实践建议

优先使用最严格的类型限制：能用<T>就不用<?>
遵循PECS原则：明确参数是生产者还是消费者
避免过度使用通配符：会增加代码复杂度
合理使用类型推断：结合var关键字简化代码
文档化类型约束：使用@param说明类型要求

九、实际案例分析

Java集合框架中的应用

// java.util.Collections
public static <T> void copy(
    List<? super T> dest, 
    List<? extends T> src
) {
    // 实现细节
}

// java.util.stream.Stream
<R> R collect(
    Supplier<R> supplier,
    BiConsumer<R, ? super T> accumulator,
    BiConsumer<R, R> combiner
);