理解通配符约束 <?超级T>

Question

我可以使用基本的泛型表达式，但通配符约束让我很困惑。

信息：学生扩展人，人扩展动物

 List<? super Animal> aList= new ArrayList<>();

       // does not compile as expected, 
       // since the list is restricted to something that has Animal as superclass.
       // aList.add(new Object()); 

    aList.add(new Animal()); // I can add animal
    aList.add(new Person()); // I can add Person
    aList.add(new Student()); // I can add Student

    Animal a = new Animal();
    Animal b = new Animal();
    Person p = new Person();
    Student s = new Student();
    // test
    a = b; //I can assign an animal to another animal
    a = p; // I can assign a person to an animal
    a = s; // I can assign a student to an animal

    Animal animal = aList.get(0); // DOES NOT COMPILE, WHY ?

问题：我不明白为什么最后一个作业不起作用。上面的例子表明，该列表中的任何东西都肯定是动物，但我无法从该列表中获取动物。

更具体：当我知道我只能添加以 Animal 作为超类的类型时，为什么我不能期望从 Animal 类型中删除对象？

事实：我只能添加扩展 Animal 的对象！我只是尝试添加一个汽车对象，但它不起作用！

我开始怀疑我的理智了，希望你能帮助我。谢谢你

另外：

Object animal = aList.get(0); // works

为什么即使我知道我不能添加 Object-Type，这个语句仍然有效？

解决方案：（基于接受的答案）

我误解了<? super Animal>的意思

我认为这是什么意思：任何将 Animal 作为超类的类。

它（显然）是什么意思：任何作为动物超类的类。

因此，List 也可能包含 Object 类型的对象，这就是 Animal animal = aList.get(0); 失败的原因。

干杯

Answer 1

这里的其他答案是对的，但表述不够清楚，这就是混乱的来源。

A List<? extends Animal> 不是的意思是“所有事物都扩展 Animal 的列表”。它的意思是“某种类型的列表T，我不会告诉你它是什么，但我知道T 扩展了Animal。” （在类型理论中，这些被称为存在类型——存在一个类型T，我们的List 是List<T>，但我们不一定知道T 是什么.)

区别很重要。如果您有“所有扩展 Animal 的事物的列表”，那么将 Dog 添加到列表中是安全的——但这不是通配符所表达的。 List<? extends Animal> 的意思是“某事物的列表，该事物扩展了 Animal”。可能是List<Animal>，或者List<Dog>，或者List<Cat>——我们不知道。所以我们没有理由认为将 Dog 添加到该列表中是安全的——因为也许我的列表是List<Cat>。

在您的示例中，您有一个List<? super Animal>。这意味着，某个类型 T 的列表，其中 T 是 Animal 的超类型之一。它可能是List<Object>，或List<Animal>，或者如果Animal 有超类型HasLegs，它可能是List<HasLegs>。在这里，将 Dog 放入此列表是安全的——因为无论它是什么列表，Dog 绝对是其中之一（动物、对象等），但是当您取出某些东西时 列表中，你不知道它是狗、动物还是只是一个对象。

Answer 2

List<? super Animal> aList是引用，可以用来处理List<Animal>，也可以是Animal的任何超类，例如List<Object>。

换句话说List<? super Animal> aList
- 不是对可以存储任何动物超类型的列表的引用。
+ 它是引用一些特定类型的列表，它是Animal（包括Animal本身）的超类型，但你不知道是哪个准确输入。

可能是这样的

List<Object> someList = new ArrayList<>();
someList.add(new Car());//OK since Car is a Object
List<? super Animal> aList = someList;// OK since Object is supertype of Animal

因此，代码

Animal a = aList.get(0);//and where did that Car come from?

不安全。存储get(0) 的结果的唯一安全类型是Object，所以您需要

Object o = aList.get(0);

或者如果您想确保get 将返回Animal，请将您的aList 引用类型更改为List<Animal> 甚至List<? extends Animal>。

Answer 3

List<? super Animal> 表示Animal 的任何超类的列表。如果Animal 是LivingThing 的子类，则List<? super Animal> 可以是Animals 的列表、LivingThings 的列表或Object 的列表。在最后两种情况下，分配 Animal x = aList.get(0) 当然是非法的，因为您不能将 LivingThing 分配给 Animal 类型的引用。

考虑以下方法（它不会编译）：

void f(List<? super Animal> list) {
    Animal a = list.get(0); // line 1
    list.add(new Object()); // line 2
}

方法调用

List<Object> list = new ArrayList<>();
list.add(new Object());
f(list);

是正确的，因为Object 是Animal 的超类。但是，如果 f 方法可以编译，您将尝试在第 1 行中将 Object 分配给 Animal 引用，因此它不是类型安全的。

另一方面，考虑方法调用：

f(new List<Animal>());

如果方法f 可以编译，我们现在将添加一个Object 实例到一个应该只包含Animals 的列表中。

这就是不允许第 1 行和第 2 行的原因。如果你有课

public class A<T> {
    public put(T in) { } 
    public T get() { } 
}

那么对于A<? super Animal> 类型，get 方法将返回Object（不是Animal），而put 方法需要Animal 类型的参数。