Java如何实现嵌套边界类型参数的泛型及继承适配

结论 #

两个需求都可以通过Java泛型实现，下面分别给出实现方案。首先先纠正你示例代码里的笔误：你写的A<B1<B11>>>多了一个多余的右尖括号，正确写法是A<B1<B11>>。 #

问题1：纯泛型实现方案 #

这个方案不需要调整你原本的类结构设计，只需要给泛型添加上界约束即可。Java 17+可以用sealed关键字做到编译期绝对的类型限制，低版本也可以用普通接口实现同等效果。
实现步骤如下：

1. 首先给B1、B2分别定义允许接收的泛型类型边界，确保B1只能接收B11、B12，B2只能接收B21、B22：

// Java 17+ 用sealed接口严格限制实现类，低版本去掉sealed和permits即可
sealed interface B1ValidType permits B11, B12 {}
sealed interface B2ValidType permits B21, B22 {}

// 末端类实现对应边界接口
class B11 implements B1ValidType {}
class B12 implements B1ValidType {}
class B21 implements B2ValidType {}
class B22 implements B2ValidType {}

// 给B1、B2的泛型加上上界
class B1<T extends B1ValidType> {
    private T t;
    public T getT() { return t; }
    public void setT(T t) { this.t = t; }
}

class B2<T extends B2ValidType> {
    private T t;
    public T getT() { return t; }
    public void setT(T t) { this.t = t; }
}

2. 再给A的泛型加上边界，只允许传入合法的参数化B1、B2类型：

// 定义B1、B2的公共边界，sealed修饰只允许B1、B2实现
sealed interface BaseBType permits B1, B2 {}
// 让B1、B2实现公共边界
class B1<T extends B1ValidType> implements BaseBType { /* 原有逻辑不变 */ }
class B2<T extends B2ValidType> implements BaseBType { /* 原有逻辑不变 */ }

// A的泛型上界设为BaseBType
class A<T extends BaseBType> {
    private T t;
    public T getT() { return t; }
    public void setT(T t) { this.t = t; }
}

写完后你预期的代码可以正常编译运行：

A<B1<B11>> a1 = new A<>();
A<B1<B12>> a2 = new A<>();
A<B2<B21>> a3 = new A<>();
A<B2<B22>> a4 = new A<>();

所有非法写法（比如给B1传B21、给A传raw类型B1/B2、给A传String等无关类型）都会直接编译失败。如果是Java 17以下版本，去掉sealed关键字即可，只要你不主动给边界接口加其他实现类，效果完全一致；编译时加上-Xlint:rawtypes -Werror参数，就可以彻底禁止raw类型传入，满足可读性要求。 #

问题2：结合继承机制的泛型实现方案 #

如果你希望贴合你最开始设计的类层级（A为基类，B1/B2继承A，B11/B12继承B1，B21/B22继承B2），可以用自限定泛型（CRTP模式）实现，不需要额外定义标记接口，类结构和继承关系完全对齐：

// 基类A，泛型参数限定为A的子类
class A<T extends A<T>> {
    private T t;
    public T getT() { return t; }
    public void setT(T t) { this.t = t; }
}

// B1继承A，泛型参数限定为B1的子类
class B1<T extends B1<T>> extends A<T> {
    // 可在这里定义B1层级的公共方法
}

// B2继承A，泛型参数限定为B2的子类
class B2<T extends B2<T>> extends A<T> {
    // 可在这里定义B2层级的公共方法
}

// 末端类继承对应的中间类，传入自身作为泛型参数
class B11 extends B1<B11> {}
class B12 extends B1<B12> {}
class B21 extends B2<B21> {}
class B22 extends B2<B22> {}

这种实现下，你可以直接按继承语义使用：

// 用A作为引用类型
A<B11> a1 = new A<>();
a1.setT(new B11());
A<B12> a2 = new A<>();
a2.setT(new B12());
A<B21> a3 = new A<>();
a3.setT(new B21());
A<B22> a4 = new A<>();
a4.setT(new B22());

// 也可以直接用中间类作为引用类型
B1<B11> b1Ref = new B1<>();
b1Ref.setT(new B11());

这种方案的优势是泛型约束和继承层级完全统一，B1、B2层的公共逻辑可以直接通过继承复用，类型安全同样有保障，非法类型传入会直接编译报错。 #

补充说明：Java泛型是通过类型擦除实现的，语言层面没有完全禁止raw类型的语法设计，但是只要在项目构建时开启raw类型、未检查转换的编译错误检查，上述两种方案都可以100%满足你的约束要求。

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