带有通配符的列表会导致通用巫毒教错误

Question

有谁知道为什么下面的代码不能编译？ add() 和 addAll() 都不能按预期工作。删除“？扩展”部分使一切正常，但是我将无法添加 Foo 的子类。

 List<? extends Foo> list1 = new ArrayList<Foo>();
 List<? extends Foo> list2 = new ArrayList<Foo>();

 /* Won't compile */
 list2.add( new Foo() ); //error 1
 list1.addAll(list2);    //error 2 

错误 1：

IntelliJ 说：

add(capture<? extends Foo>) in List cannot be applied to add(Foo)

编译器说：

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>

错误2：

IntelliJ 给了我

addAll(java.util.Collection<? extends capture<? extends Foo>>) in List cannot be applied to addAll(java.util.List<capture<? extends Foo>>)

而编译器只是说

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>
        list1.addAll(list2);

Answer 1

（我在这里假设Bar 和Baz 都是Foo 的子类型。）

List<? extends Foo> 表示某种类型的元素列表，它是 Foo 的子类型，但我们不知道是哪种类型。此类列表的示例是 ArrayList<Foo>、LinkedList<Bar> 和 ArrayList<Baz>。

由于我们不知道类型参数是哪个子类型，所以我们不能将Foo 对象放入其中，Bar 或Baz 对象也不能放入其中。但是我们仍然知道类型参数是Foo的子类型，所以列表中已经存在的每个元素（我们可以从列表中获取）必须是Foo对象，所以我们可以使用Foo f = list.get(0);和类似的东西。

这样的列表只能用于从列表中取出元素，根本不能添加元素（除了null，但我不知道编译器是否真的允许这样做）。

另一方面，List<Foo> 允许添加任何属于 Foo 对象的对象 - 由于 Bar 和 Baz 是 Foo 的子类型，所有 Bar 和 Baz 对象都是 @ 987654342@ 个对象，因此也可以添加它们。

Answer 2

记住 PECS：Producer Extends, Consumer Super。

由于您试图将项目添加到 list2，它是一个消费者，不能声明为 List<? extends Foo>。但是，当您将 list2 添加到 list1 时，您也将它用作生产者。所以list2既是生产者又是消费者，必须是List<Foo>。

list1，作为纯消费者，可以是List<? super Foo>。

Answer 3

他们是错误的。考虑到Bar 和Baz 是扩展Foo 的两种不同类型，让我们修改您的代码：

List<? extends Foo> list1 = new ArrayList<Bar>();
List<? extends Foo> list2 = new ArrayList<Baz>();

如果允许list1.add(new Foo())，您可以在包含 Bar 实例的集合中添加 Foo 实例。这解释了第一个错误。

如果允许list1.addAll(list2)，则list2 中的所有Baz 实例都将添加到仅包含Bar 实例的list1。这解释了第二个错误。

Answer 4

让我试着解释一下在什么情况下你可能需要使用<? extend Classname>。

所以，假设你有 2 个类：

class Grand {
    private String name;

    public Grand(String name) {
        this.setName(name);
    }

    public Grand() {
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Dad extends Grand {
    public Dad(String name) {
        this.setName(name);
    }

    public Dad() {
    }
}

假设您有 2 个集合，每个集合包含一些 Grands 和一些 Dads：

    List<Dad> dads = new ArrayList<>();
    dads.add(new Dad("Dad 1"));
    dads.add(new Dad("Dad 2"));
    dads.add(new Dad("Dad 3"));


    List<Dad> grands = new ArrayList<>();
    dads.add(new Dad("Grandpa 1"));
    dads.add(new Dad("Grandpa 2"));
    dads.add(new Dad("Grandpa 3"));

现在，假设我们想要一个集合，其中包含 Grand 或 Dad 对象：

        List<Grand> resultList;
        resultList = dads; // Error - Incompatable types List<Grand> List<Dad>
        resultList = grands;//Works fine

我们如何避免这种情况？只需使用通配符：

List<? extends Grand> resultList;
resultList = dads; // Works fine
resultList = grands;//Works fine

请注意，您不能在此类 (resultList) 集合中添加新项目。有关更多信息，您可以阅读 Java 中的通配符和 PECS 概念

Answer 5

对不起，也许我误解了你的问题，但假设：

public class Bar extends Foo{ }

这段代码：

List<Foo> list2 = new ArrayList<Foo>()
list2.add( new Bar() );

不要为我产生任何错误。

因此，删除通配符允许添加 Foo 的子类。