如何在List中保留C<T1, T2 extends T1>实例的泛型约束？

这个问题问到点子上了！Java泛型里的跨通配符约束确实是个容易让人困惑的点——你想让List里的每个C实例都保留自己内部T2 extends T1的类型绑定，但又不能用List<C<?,?>>这种会丢失约束的写法。咱们一步步拆解解决办法：

核心问题：为什么List<C<?,?>>不够用？ #

List<C<?,?>>里的两个?是独立的通配符，编译器无法知道第二个?是第一个?的子类，所以读取元素时无法安全复用T2 extends T1的约束。但Java的泛型系统提供了间接的方式来解决这个问题——通过泛型方法的类型捕获来保留每个实例的内部绑定。

方法一：List<C<?, ?>> + 泛型方法实现类型安全 #

这是最实用的方案：用List<C<?, ?>>作为容器，但通过泛型方法来控制元素的添加和读取，确保全程的类型安全。

1. 安全添加元素

写一个泛型方法来封装添加逻辑，编译器会自动检查传入的C实例是否满足T2 extends T1：

public static <T1, T2 extends T1> void addToCList(List<C<?, ?>> list, C<T1, T2> element) {
    list.add(element);
}

这样你就不能往List里加非法的实例（比如C<String, Integer>这种不满足约束的），编译期直接报错。

2. 安全处理元素

当需要遍历List时，同样用泛型方法来捕获每个元素的具体类型绑定，这样就能在方法里安全使用T1和T2的约束：

// 处理单个C实例的泛型方法，这里可以放心使用T2 extends T1的约束
public static <T1, T2 extends T1> void processC(C<T1, T2> element) {
    T1 parentObj = element.e1;
    T2 childObj = element.e2;
    // 比如可以安全地把childObj赋值给T1类型的变量
    T1 upcasted = childObj;
    System.out.println(childObj.getClass().getSimpleName() + " is a subclass of " + parentObj.getClass().getSimpleName());
}

// 遍历List的方法，把每个元素交给泛型方法处理
public static void processCList(List<C<?, ?>> list) {
    for (C<?, ?> c : list) {
        processC(c); // 编译器会自动捕获c的具体T1/T2类型，保证类型安全
    }
}

完整示例代码 #

下面是一个可运行的完整例子，展示不同类型的C实例如何共存于同一个List，且每个实例的类型绑定都被保留：

class C<T1, T2 extends T1> {
    T1 e1;
    T2 e2;
    public C(T1 e1, T2 e2) {
        this.e1 = e1;
        this.e2 = e2;
    }
}

public class CListDemo {
    public static <T1, T2 extends T1> void addToCList(List<C<?, ?>> list, C<T1, T2> element) {
        list.add(element);
    }

    public static <T1, T2 extends T1> void processC(C<T1, T2> element) {
        System.out.println("e1 type: " + element.e1.getClass().getSimpleName());
        System.out.println("e2 type: " + element.e2.getClass().getSimpleName());
        System.out.println("e2 is instance of e1's type: " + element.e1.getClass().isInstance(element.e2));
        System.out.println("---");
    }

    public static void processCList(List<C<?, ?>> list) {
        for (C<?, ?> c : list) {
            processC(c);
        }
    }

    public static void main(String[] args) {
        List<C<?, ?>> cList = new ArrayList<>();

        // 添加不同类型组合的合法C实例
        addToCList(cList, new C<>(Number.class, Integer.class));
        addToCList(cList, new C<>("Hello", "World")); // String extends String
        addToCList(cList, new C<>(new Animal(), new Dog()));

        // 处理List，每个元素的类型绑定都有效
        processCList(cList);
    }

    static class Animal {}
    static class Dog extends Animal {}
}

运行后你会看到每个元素的类型信息都被正确识别，且e2确实是e1类型的子类实例。

为什么没有直接的List<C<?, ? extends ...>>语法？ #

Java的泛型通配符是“无状态”的，不同的?之间无法建立依赖关系（比如让第二个?依赖第一个?作为父类）。所以你想要的那种直接声明约束的语法在Java里是不存在的，但通过泛型方法的类型捕获，我们完全可以达到同样的效果——既容纳不同类型的C实例，又保留每个实例内部的类型绑定。

内容的提问来源于stack exchange，提问作者Vito De Tullio