你可以通过上面所有的答案来理解为什么.add()被限制为'<?>”、“< ?扩展>'，部分扩展到'<?超级>”。

但如果你想记住它，而不想每次都去探索答案，这里是所有问题的结论:

列表< ?extends A>表示它将接受A的任何List和A的子类。 但是你不能在这个列表中添加任何东西。甚至不是A类型的对象。

列表< ?super A>表示它将接受A的任何列表和A的超类。 您可以添加类型A的对象及其子类。

向列表中添加一个项目:

列表< ?extends X >不允许向列表中添加任何东西，除了null。 列表< ?super X >允许添加任何-a X (X或其子类型)，或null。

从列表中获取一项:

当你从List< ?扩展X >，你可以将它赋值给X类型的变量或X的任何超类型，包括Object。 当你从List< ?super X >，你只能将它分配给Object类型的变量。

一些例子:

    List<? extends Number> list1 = new ArrayList<Integer>();
    list1.add(null);  //OK
    Number n = list1.get(0);  //OK
    Serializable s = list1.get(0);  //OK
    Object o = list1.get(0);  //OK

    list1.add(2.3);  //ERROR
    list1.add(5);  //ERROR
    list1.add(new Object());  //ERROR
    Integer i = list1.get(0);  //ERROR

---

    List<? super Number> list2 = new ArrayList<Number>();
    list2.add(null);  //OK
    list2.add(2.3);  //OK
    list2.add(5);  //OK
    Object o = list2.get(0);  //OK

    list2.add(new Object());  //ERROR
    Number n = list2.get(0);  //ERROR
    Serializable s = list2.get(0);  //ERROR
    Integer i = list2.get(0);  //ERROR

根据Bert F的回答，我想解释一下我的理解。

假设我们有3个类

public class Fruit{}

public class Melon extends Fruit{}

public class WaterMelon extends Melon{}

这里我们有

List<? extends Fruit> fruitExtendedList = …

//Says that I can be a list of any object as long as this object extends Fruit.

好的，现在让我们尝试从fruitExtendedList中获取一些值

Fruit fruit = fruitExtendedList.get(position)

//This is valid as it can only return Fruit or its subclass.

让我们再试一次

Melon melon = fruitExtendedList.get(position)

//This is not valid because fruitExtendedList can be a list of Fruit only, it may not be 
//list of Melon or WaterMelon and in java we cannot assign sub class object to 
//super class object reference without explicitly casting it.

的情况也是一样

WaterMelon waterMelon = fruitExtendedList.get(position)

现在让我们尝试在fruitExtendedList中设置一些对象

添加水果对象

fruitExtendedList.add(new Fruit())

//This in not valid because as we know fruitExtendedList can be a list of any 
//object as long as this object extends Fruit. So what if it was the list of  
//WaterMelon or Melon you cannot add Fruit to the list of WaterMelon or Melon.

添加甜瓜对象

fruitExtendedList.add(new Melon())

//This would be valid if fruitExtendedList was the list of Fruit but it may 
//not be, as it can also be the list of WaterMelon object. So, we see an invalid 
//condition already.

最后让我们尝试添加西瓜对象

fruitExtendedList.add(new WaterMelon())

//Ok, we got it now we can finally write to fruitExtendedList as WaterMelon 
//can be added to the list of Fruit or Melon as any superclass reference can point 
//to its subclass object.

但是等等，如果有人决定制造一种新的柠檬，让我们说，为了争论，SaltyLemon作为

public class SaltyLemon extends Lemon{}

现在fruitExtendedList可以是Fruit, Melon, WaterMelon或SaltyLemon的列表。

因此，我们的声明

fruitExtendedList.add(new WaterMelon())

也是无效的。

基本上，我们可以说不能向fruitExtendedList中写入任何内容。

这对List<?扩展了水果>

现在让我们看看

List<? super Melon> melonSuperList= …

//Says that I can be a list of anything as long as its object has super class of Melon.

现在让我们尝试从melonSuperList中获取一些值

Fruit fruit = melonSuperList.get(position)

//This is not valid as melonSuperList can be a list of Object as in java all 
//the object extends from Object class. So, Object can be super class of Melon and 
//melonSuperList can be a list of Object type

同样地，Melon、Melon或其他任何对象都不能读取。

但请注意，我们可以读取对象类型实例

Object myObject = melonSuperList.get(position)

//This is valid because Object cannot have any super class and above statement 
//can return only Fruit, Melon, WaterMelon or Object they all can be referenced by
//Object type reference.

现在，让我们尝试从melonSuperList中设置一些值。

添加对象类型对象

melonSuperList.add(new Object())

//This is not valid as melonSuperList can be a list of Fruit or Melon.
//Note that Melon itself can be considered as super class of Melon.

添加水果类型对象

melonSuperList.add(new Fruit())

//This is also not valid as melonSuperList can be list of Melon

添加Melon类型对象

melonSuperList.add(new Melon())

//This is valid because melonSuperList can be list of Object, Fruit or Melon and in 
//this entire list we can add Melon type object.

添加西瓜类型对象

melonSuperList.add(new WaterMelon())

//This is also valid because of same reason as adding Melon

综上所述，我们可以在melonSuperList中添加Melon或其子类，并且只读取Object类型的对象。

扩展

List<?数字> foo3意味着这些都是合法的赋值:

List<? extends Number> foo3 = new ArrayList<Number>();  // Number "extends" Number (in this context)
List<? extends Number> foo3 = new ArrayList<Integer>(); // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>();  // Double extends Number

Reading - Given the above possible assignments, what type of object are you guaranteed to read from List foo3: You can read a Number because any of the lists that could be assigned to foo3 contain a Number or a subclass of Number. You can't read an Integer because foo3 could be pointing at a List<Double>. You can't read a Double because foo3 could be pointing at a List<Integer>. Writing - Given the above possible assignments, what type of object could you add to List foo3 that would be legal for all the above possible ArrayList assignments: You can't add an Integer because foo3 could be pointing at a List<Double>. You can't add a Double because foo3 could be pointing at a List<Integer>. You can't add a Number because foo3 could be pointing at a List<Integer>.

你不能向List<?extends t>因为你不能保证它真正指向的是什么样的List，所以你不能保证对象被允许在那个List中。唯一的“保证”是你只能读取它，你会得到一个T或T的子类。

超级

现在考虑List <?超级T >。

List<?super Integer> foo3表示这些都是合法的赋值:

List<? super Integer> foo3 = new ArrayList<Integer>();  // Integer is a "superclass" of Integer (in this context)
List<? super Integer> foo3 = new ArrayList<Number>();   // Number is a superclass of Integer
List<? super Integer> foo3 = new ArrayList<Object>();   // Object is a superclass of Integer

Reading - Given the above possible assignments, what type of object are you guaranteed to receive when you read from List foo3: You aren't guaranteed an Integer because foo3 could be pointing at a List<Number> or List<Object>. You aren't guaranteed a Number because foo3 could be pointing at a List<Object>. The only guarantee is that you will get an instance of an Object or subclass of Object (but you don't know what subclass). Writing - Given the above possible assignments, what type of object could you add to List foo3 that would be legal for all the above possible ArrayList assignments: You can add an Integer because an Integer is allowed in any of above lists. You can add an instance of a subclass of Integer because an instance of a subclass of Integer is allowed in any of the above lists. You can't add a Double because foo3 could be pointing at an ArrayList<Integer>. You can't add a Number because foo3 could be pointing at an ArrayList<Integer>. You can't add an Object because foo3 could be pointing at an ArrayList<Integer>.

PECS

记住PECS:“生产者延伸，消费者至上”。

"Producer Extends" - If you need a List to produce T values (you want to read Ts from the list), you need to declare it with ? extends T, e.g. List<? extends Integer>. But you cannot add to this list. "Consumer Super" - If you need a List to consume T values (you want to write Ts into the list), you need to declare it with ? super T, e.g. List<? super Integer>. But there are no guarantees what type of object you may read from this list. If you need to both read from and write to a list, you need to declare it exactly with no wildcards, e.g. List<Integer>.

例子

请注意这个来自Java泛型常见问题解答的例子。注意源列表src(生产列表)如何使用extends，而目标列表dest(消费列表)如何使用super:

public class Collections { 
  public static <T> void copy(List<? super T> dest, List<? extends T> src) {
      for (int i = 0; i < src.size(); i++) 
        dest.set(i, src.get(i)); 
  } 
}

也看到 如何添加到List<?extends数字>数据结构?

向上投票的答案涵盖了很多方面的细节。然而，我会尝试用不同的方式来回答这个问题。

我们需要考虑两件事，

1. 对列表变量赋值

列表< ?扩展X> listvar;

在这里，X的任何列表或X的子类列表都可以赋值给listvar。

列表<？ 扩展 数字> 列表变量; listvar = new ArrayList<Number>（）; listvar = new ArrayList<Integer>（）;

---

列表< ?super X> listvar;

在这里，X的任何列表或X的超类列表都可以赋值给listvar。

列表<？ 超级数字>列表变量; listvar = new ArrayList<Number>（）; listvar = new ArrayList<Object>（）;

2. 对列表变量执行读或写操作

`List<? extends X> listvar;`

您可以使用此特性在方法参数中接受一个列表，并对类型X执行任何操作(注意:您只能从列表中读取类型X的对象)。

`List<? super Number> listvar;

您可以使用此特性在方法参数中接受列表，并对Object类型执行任何操作，因为您只能从列表中读取Object类型的对象。是的，这里还有一点，你可以把X类型的对象添加到列表中。

你可以通过上面所有的答案来理解为什么.add()被限制为'<?>”、“< ?扩展>'，部分扩展到'<?超级>”。

但如果你想记住它，而不想每次都去探索答案，这里是所有问题的结论:

列表< ?extends A>表示它将接受A的任何List和A的子类。 但是你不能在这个列表中添加任何东西。甚至不是A类型的对象。

列表< ?super A>表示它将接受A的任何列表和A的超类。 您可以添加类型A的对象及其子类。