我对 Java 泛型有一个棘手的问题，或者我可能只见树木不见森林。

我有如下所示的三个类 A、B 和 C。

abstract class A<T extends A<T>> {
    abstract T sefl();
};

abstract class B<T extends B<T>> extends A<T> {
};

class C extends B<C> {
    @Override
    C sefl() {
        return this;
    }
}

后来我有不同版本的B，也有不同版本的C。此外，我有一个功能测试应该接受 B 的列表(或其表亲之一)。或者一般来说，它应该接受从 A 继承的任何元素列表。不幸的是，我需要知道函数主体中列表元素的类型，即最上面的类型 a.self 可以返回(或类型 T)。功能测试如下:

static <T extends A<T>> void test(List<T> list) {

    for (A<T> a : list) {
        @SuppressWarnings("unused")
        T t = a.sefl();
    }

}

现在，用 C 的作品列表调用测试。

List<C> cs = new LinkedList<C>();
test(cs);

但是

List<B> bs = new LinkedList<B>();
test(bs);

导致需要类型参数的警告

List<B<?>> bs = new LinkedList<B<?>>();
test(bs);

无效。我的错误在哪里，或者我如何创建功能测试接受的 B 列表？

关于这个问题背后动机的一些话。类 A、B 和 C(或 Animal、Mammal 和 Cat)实现了一个树状数据结构，其中每个类都使用一些属性扩展该结构。通常，所有父类(super class)都是抽象的，您只能从叶类创建实例，例如猫。现在，困难在于这些类实现了写时复制策略 (COW)，即修改对象会创建并返回其自身具有修改后属性的新实例。

例如，假设所有动物都有年龄属性。你可以很容易地在 Animal 中定义这个属性，你可以提供一个 getter 方法来返回年龄。

abstract class Animal<T extends Animal<T>> {
    private int age;
    public int getAge(int age) {
        return age;
    }
};

但是，如何定义setter方法呢？你可以这样写:

public abstract Animal setAge();

这要求(至少)每个非抽象元素必须实现setter函数。例如:

class Cat extends Mammal<C> {

    @Override
    public Animal setAge(int age) {
        return new Cat(/* .. */);
    }
}

请记住，在我们实现 COW 策略时，我们必须创建一个新实例。因此，在 setter 函数中(例如在 Cat 中实现)我们返回一只新年龄的新猫。在 Cat 元素上调用 cat.setAge(4) 会返回一个新的 Cat。不幸的是，由于类型签名，我们现在才得到从 setAge 返回的 Animal，即使我们直接在 Cat 上调用它也是如此。泛型的变化有助于在调用 setAge 时揭示具体类型。所以，我们可以这样构造 Animal:

abstract class Animal<T extends Animal<T>> {
    private int age;
    public int getAge(int age) {
        return age;
    }
    public abstract T setAge();
};

在 Cat 中我们可以说:

class Cat extends Mammal<C> {

    @Override
    public Cat setAge(int age) {
        return new Cat(/* .. */);
    }
}

所以，回到问题。你的权利，使用List<? extends Animal<?>>因为列表的类型有效，但不幸的是，我需要一些方法来了解元素的类型。或者更具体一点:功能测试必须用新元素替换旧元素。例如:

static void test2(List<? extends Animal<?>> list) {
    for (Animal<?> animal : list) {
        @SuppressWarnings("unused")
        Animal<?> a = animal.setAge(4711);
        list.add(a);
    }
}

不幸的是，列表扩展 list.add(a); ist 声明不适用于此签名。

最佳答案

好吧，它们是两种截然不同的实现方式:

class C ...

和

class B<T extends B<T>> ...

类(class)C不声明任何通用类型。

类名的简单字母在这里有点困惑，所以让我们这样做:

abstract class Animal<T extends Animal<T>> {
    abstract T sefl();
};

abstract class Mammal<T extends Mammal<T>> extends Animal<T> {
};

class Cat extends Mammal<Cat> {
    @Override
    Cat sefl() {
        return this;
    }
}

所以:

List<Cat> catList = new LinkedList<>();

效果很好，因为不涉及泛型类型。编译器确定

Cat extends Mammal<Cat> ( == Cat extends Animal<Cat> )

在范围内 <T extends Animal<T>>

另一方面

List<Mammal> mammalList = new LinkedList<>();
test(mammalList); // ok, but mammal list of what???

编译器无法匹配有界类型。

事实上，Mammal<T extends Mammal<T>> extends Animal<T>与<T extends Animal<T>>无关.

即使提供通配符，您也永远无法传递 List<Mammal<?>至 test .方法签名拒绝它!

可能的解决方案:

更通用的测试方法

static void test2(List<? extends Animal<?>> list) {
    for (Animal<?> animal : list) {
        Animal a = animal.sefl();
    }
}

可以与不同的 List 一起使用类型:

List<? extends Mammal<?>> bs = new LinkedList<>();
test2(bs);

List<Cat> catList = new LinkedList<>();
test2(catList);

List<Animal<Cat>> animalList = new LinkedList<>();
test2(animalList);

Java 版本:

java 9.0.4
Java(TM) SE Runtime Environment (build 9.0.4+11)
Java HotSpot(TM) 64-Bit Server VM (build 9.0.4+11, mixed mode) 

关于<T extends A<T>> 和 Inheritance 形式的 Java 泛型，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49998124/