泛型字段有界通配符：存储B为自身类型的Base子类列表方法

要实现只能存储Base子类中B类型等于自身的元素列表（比如List<SubA>、List<SubB>，拒绝List<SubC>），核心是通过递归泛型约束在编译期就过滤掉不符合要求的类型。下面分几种场景给出具体实现：

1. 定义泛型容器类封装列表 #

如果需要把这个列表作为独立的组件使用，可以创建一个带泛型约束的容器类：

// 泛型参数S必须满足：S是Base的子类，且第二个泛型参数就是S自身
class ValidBaseListContainer<S extends Base<?, S>> {
    private List<S> validItems;

    public ValidBaseListContainer(List<S> validItems) {
        this.validItems = validItems;
    }

    // 提供类型安全的访问方法
    public List<S> getValidItems() {
        return validItems;
    }

    public void addItem(S item) {
        validItems.add(item);
    }
}

使用示例： #

// ✅ 合法：SubA的B类型是自身，符合S extends Base<?, S>
ValidBaseListContainer<SubA> containerA = new ValidBaseListContainer<>(new ArrayList<>());
containerA.addItem(new SubA());

// ✅ 合法：SubB同理
ValidBaseListContainer<SubB> containerB = new ValidBaseListContainer<>(new ArrayList<>());

// ❌ 编译错误：SubC的B类型是SubA而非自身，不满足约束
ValidBaseListContainer<SubC> containerC = new ValidBaseListContainer<>(new ArrayList<>());

2. 在业务类中定义泛型字段 #

如果你的业务逻辑类需要持有这样的列表，可以把业务类本身定义为泛型类，通过类的泛型参数施加约束：

// 泛型参数S约束同上
class BaseService<S extends Base<?, S>> {
    private List<S> validBaseInstances;

    public BaseService() {
        this.validBaseInstances = new ArrayList<>();
    }

    public void addValidInstance(S instance) {
        validBaseInstances.add(instance);
    }

    public List<S> getValidInstances() {
        return validBaseInstances;
    }
}

使用示例： #

BaseService<SubA> subAService = new BaseService<>();
subAService.addValidInstance(new SubA()); // 正常工作

BaseService<SubC> subCService = new BaseService<>(); // 编译错误，直接被编译器拦截

3. 非泛型类中的泛型方法约束 #

如果不想把整个类变成泛型类，可以通过泛型方法来限制列表的赋值和访问：

class NonGenericService {
    // 用通配符声明底层存储，避免类型固化
    private List<? extends Base<?, ?>> internalList;

    // 泛型方法：仅接受符合约束的List<S>
    public <S extends Base<?, S>> void setValidList(List<S> inputList) {
        this.internalList = inputList;
    }

    // 类型安全的获取方法（需要抑制unchecked警告，因为我们确定类型是合法的）
    @SuppressWarnings("unchecked")
    public <S extends Base<?, S>> List<S> getValidList() {
        return (List<S>) internalList;
    }
}

使用示例： #

NonGenericService service = new NonGenericService();
service.setValidList(new ArrayList<SubA>()); // ✅ 合法
service.setValidList(new ArrayList<SubC>()); // ❌ 编译错误

// 获取时可以安全使用类型
List<SubA> subAList = service.getValidList();

为什么这个约束有效？ #

你的Base类已经定义了递归泛型约束B extends Base<?, B>，而我们额外要求S extends Base<?, S>，这就强制了S的第二个泛型参数必须是S自身——只有SubA、SubB这种extends Base<X, 自身>的子类才能满足这个条件，SubC因为extends Base<String, SubA>，第二个参数不是自身，自然通不过编译器检查。

内容的提问来源于stack exchange，提问作者Jai