如何让Java方法仅接受可被具体类型B赋值的泛型参数？

问题描述 #

我有一个具体类型B，它实现了A1、A2等多个接口，现在要编写一个方法get，该方法要么返回泛型参数T的实例，要么返回B的实例。核心需求是必须保证B是T的子类型，以此避免运行时类型转换异常。

当前代码中，调用get(A3Impl::new, A3.class)会在运行时失败，因为B并非A3的子类型。我希望在编译期就阻止这类非法调用，但Java不支持<T super B>这种直接的泛型边界语法，该如何实现？

代码示例 #

class Scratch {
  interface A1 {
    default void print1() { System.out.println("A1"); }
  }

  interface A2 {
    default void print2() { System.out.println("A2"); }
  }

  interface A3 {
    default void print3() { System.out.println("A3"); }
  }

  static class A1Impl implements A1 {}

  static class A2Impl implements A2 {}

  static class A3Impl implements A3 {}

  static class B implements A1, A2 {}

  // 能否在B不是T的子类型时让编译失败？
  static <T> Optional<T> get(Supplier<T> provider, Class<T> clazz) {
    if (someCondition()) {
      return Optional.of(provider.get());
    } else {
      // 希望避免未检查转换以获得编译期安全
      return Optional.of((T) new B());
    }
  }

  public static void main(String[] args) {
    // 应成功，因为B是A1和A2的子类型
    get(A1Impl::new, A1.class).ifPresent(A1::print1);
    get(A2Impl::new, A2.class).ifPresent(A2::print2);
    // 运行时会失败，因为B不是A3的子类型
    // 能否让编译期就失败？
    get(A3Impl::new, A3.class).ifPresent(A3::print3);
  }
}

解决方案 #

方法1：添加类型约束参数（最简洁） #

通过添加一个额外的Class<? super B>类型参数，让编译器在编译期验证T是否是B的超类型（即B可以安全转换为T）。这个参数不需要实际使用，仅作为类型校验的标记：

static <T> Optional<T> get(Supplier<T> provider, Class<T> clazz, Class<? super B> dummy) {
    if (someCondition()) {
        return Optional.of(provider.get());
    } else {
        // 使用clazz.cast替代强制转换，消除未检查警告
        return Optional.of(clazz.cast(new B()));
    }
}

// 调用示例
public static void main(String[] args) {
    get(A1Impl::new, A1.class, B.class); // 编译通过：B是A1的子类型
    get(A2Impl::new, A2.class, B.class); // 编译通过：B是A2的子类型
    get(A3Impl::new, A3.class, B.class); // 编译报错：无法将Class<B>转换为Class<? super A3>
}

方法2：通过辅助接口实现约束 #

如果不想添加额外参数，可以定义一个辅助接口，利用其静态方法的泛型边界来约束T必须是B的超类型：

// 辅助接口，用于约束T必须是B的超类型
interface BCompatible<T> extends Supplier<T> {
    static <T super B> BCompatible<T> of(Supplier<T> supplier) {
        return supplier::get;
    }
}

// 修改get方法的参数类型为BCompatible<T>
static <T> Optional<T> get(BCompatible<T> provider, Class<T> clazz) {
    if (someCondition()) {
        return Optional.of(provider.get());
    } else {
        return Optional.of(clazz.cast(new B()));
    }
}

// 调用示例
public static void main(String[] args) {
    get(BCompatible.of(A1Impl::new), A1.class); // 编译通过
    get(BCompatible.of(A2Impl::new), A2.class); // 编译通过
    get(BCompatible.of(A3Impl::new), A3.class); // 编译报错：无法推断类型变量T
}

核心思路 #

两种方法的本质都是利用Java的泛型类型检查机制，在编译期确保B可以安全转换为T，从而避免运行时的类型转换异常。第一种方法更简洁直观，第二种方法则避免了额外的参数传递。

内容的提问来源于stack exchange，提问作者Andreas Berheim Brudin