Java泛型边界与约束深度解析

泛型边界是Java类型系统中控制类型参数灵活性与安全性的重要机制。本文将深入探讨四种核心边界约束方式，帮助开发者写出更安全、更灵活的泛型代码。

1. 上界通配符（<? extends T>）

上界通配符用于放宽对参数类型的限制，表示"某种T或T的子类型"。

// 只能接收Number及其子类的List
public double sumList(List<? extends Number> list) {
    return list.stream().mapToDouble(Number::doubleValue).sum();
}

// 使用示例
List<Integer> intList = List.of(1, 2, 3);
sumList(intList); // 合法
List<Double> doubleList = List.of(1.1, 2.2);
sumList(doubleList); // 合法
List<String> strList = List.of("a", "b");
// sumList(strList); // 编译错误

内存模型表示：

实践建议：

• 适用于只读场景（PECS原则中的Producer）
• 允许读取为T类型，但不能写入（除null外）
• 常见于集合的读取操作，如Collections.max()

2. 下界通配符（<? super T>）

下界通配符表示"某种T或T的父类型"，提供了相反的灵活性。

// 能接收T及其父类型的集合
public void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i); // 可以安全添加Integer
    }
}

// 使用示例
List<Number> numList = new ArrayList<>();
addNumbers(numList); // 合法
List<Object> objList = new ArrayList<>();
addNumbers(objList); // 合法
List<Double> doubleList = new ArrayList<>();
// addNumbers(doubleList); // 编译错误

内存模型表示：

实践建议：

• 适用于写入场景（PECS原则中的Consumer）
• 允许写入T类型，但读取只能作为Object
• 常见于集合的写入操作，如Collections.copy()

3. 无界通配符（<?>）

无界通配符表示完全未知的类型，提供最大灵活性但最低的类型安全。

// 打印任意List的元素
public void printList(List<?> list) {
    for (Object elem : list) {
        System.out.println(elem);
    }
}

// 使用示例
List<String> strList = List.of("a", "b");
printList(strList);
List<Integer> intList = List.of(1, 2);
printList(intList);

实践建议：

• 当方法实现不依赖具体类型时使用
• 只能读取为Object，不能写入（除null外）
• 常用于简单遍历或调用与类型无关的方法（如size()）

4. 多重边界（T extends A & B）

多重边界允许类型参数同时满足多个约束条件。

interface Flyable { void fly(); }
interface Swimmable { void swim(); }

class Duck implements Flyable, Swimmable { /*...*/ }

// T必须同时实现Flyable和Swimmable
public <T extends Flyable & Swimmable> void playWithAnimal(T animal) {
    animal.fly();
    animal.swim();
}

// 使用示例
Duck duck = new Duck();
playWithAnimal(duck); // 合法

类型关系图：

实践建议：

• 类边界必须放在接口边界前（语法要求）
• 最多一个类边界，多个接口边界
• 常用于需要组合多个接口能力的场景
• 谨慎使用，避免过度复杂的类型约束

边界约束综合对比

实际开发中的边界选择

1. API设计原则：

   • 输入参数多用<? super T>（消费者）
   • 返回类型多用<? extends T>（生产者）
   • 内部实现可结合两者实现最大灵活性

2. 类型安全与灵活性平衡：

   // 更灵活的API设计示例
   public static <T> void copy(
       List<? super T> dest, 
       List<? extends T> src) {
       for (T item : src) {
           dest.add(item);
       }
   }

3. 避免的常见错误：

   • 混淆List<Object>和List<?>
   • 在需要类型安全的地方过度使用无界通配符
   • 忽略PECS原则导致API不够灵活

通过合理运用泛型边界，可以构建出既类型安全又灵活通用的Java API，这是高级Java开发者必备的核心技能之一。