我如何使用这个类的泛型类型（Java）的泛型类型？

Question

我有一个带有通用通配符 T 的抽象类 A<T>。A 有两个扩展，

public class A1 extends A<Integer> {...}

和

public class A2 extends A<String> {...}

现在我有了另一个类，我们称它为 B，它基本上是 A1 或 A2 的集合。所以我把它定义为一个泛型类型的类 T extends A:

public class B<T extends A> {...}

我希望能够在 B 中创建返回 T 的泛型类型的方法。例如，

B<A1> foo = new B<A1>;
foo.get(); // returns Integer, corresponding to A1's generic type

和

B<A2> bar = new B<A2>;
bar.get(); // returns String, corresponding to A2's generic type

在 Java 中可以做到这一点吗？在声明 B 的方法时，我无法弄清楚要放置什么返回类型（如果我想让 B 返回 T，我会输入 public T get() {...}，但我实际上想返回参数化类型 of T)。或者有没有一种模式比我解决这个问题的方式更好地解决了这个问题？

谢谢。

Answer 1

您可以为B 声明第二个类型参数，并将其作为A 的参数化

class B<K, T extends A<K>> {
    public K get() {
        // actual implementation
        return null;
    }
}

然后声明你的变量

B<String, A2> var = new B<>();
String ret = var.get();

---

What is a raw type and why shouldn't we use it?

Answer 2

我想提供一个示例，可以帮助您更好地理解为什么我们需要两个泛型类型参数。首先，A 及其直接子类的示例声明。

class A<T> {

    private T value;

    public A(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }   
}

class A1 extends A<Integer> {
    A1(Integer i) {
        super(i);
    }
}

class A2 extends A<String> {
    A2(String str) {
        super(str);
    }
}

现在，B 类声明。请注意，它是如何在其定义中引用这两种泛型类型以提供对包装的 A 子类的成员的访问。

public class B<T, X extends A<T>> {

    private X data;

    public B(X data) {
        this.data = data;
    }

    public T get() {
        return data.getValue();
    }

    public static void main(String[] args) {

        B<Integer, A1> foo = new B<Integer, A1>(new A1(10));
        System.out.println(foo.get()); // returns Integer

        B<String, A2> bar = new B<String, A2>(new A2("Ten"));
        System.out.println(bar.get()); // returns String
    }
}

如果你只切换到一个类型参数，你有两个选择。

你要么保持A子类的类型像

public class B<T extends A<?>> {

    private T data;

    public B(T data) {
        this.data = data;
    }

    public Object get() {
        return data.getValue();
    }

    ...
}

或者，getter 的实际 return 类型。

public class B<T> {

    private T value;

    @SuppressWarnings("unchecked")
    public B(A<?> data) {
        this.value = (T) data.getValue();
    }

    public T get() {
        return value;
    }

    ... 
}

注意，这两种解决方案都很脆弱。

一个返回Object 并要求使用instanceof 来正确转换它，而另一个更脆弱的是unchecked 转换。由于您没有同时提供所需的泛型类型，因此限制了类设计并冒着现在获得ClassCastException 的风险。