如何添加到列表<？扩展Number>数据结构？

我有一个这样声明的清单：

 List<? extends Number> foo3 = new ArrayList<Integer>();

我试图将3添加到foo3中。但是我收到这样的错误消息：

The method add(capture#1-of ? extends Number) in the type List<capture#1-of ?
extends Number> is not applicable for the arguments (ExtendsNumber)

抱歉，您不能。

通配符声明List<? extends Number> foo3意味着变量foo3可以保存一系列类型中的任何值（而不是特定类型的任何值）。这意味着这些都是合法的转让：

List<? extends Number> foo3 = new ArrayList<Number>;  // Number "extends" Number
List<? extends Number> foo3 = new ArrayList<Integer>; // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>;  // Double extends Number

因此，鉴于此，List foo3在上述任何可能的ArrayList分配之后，您可以添加什么类型的对象都是合法的：

• 您不能添加，Integer因为它foo3可能指向List<Double>。
• 您不能添加，Double因为它foo3可能指向List<Integer>。
• 您不能添加，Number因为它foo3可能指向List<Integer>。

您不能向其中添加任何对象，List<? extends T>因为您不能保证List它真正指向的是哪种对象，因此您不能保证在该对象中允许该对象List。唯一的“保证”是，您只能从中读取内容，并且会获得的T或子类T。

相反的逻辑适用于super例如List<? super T>。这些是合法的：

List<? super Number> foo3 = new ArrayList<Number>; // Number is a "super" of Number
List<? super Number> foo3 = new ArrayList<Object>; // Object is a "super" of Number

您无法从中读取特定的类型T（例如Number），List<? super T>因为您无法保证List它真正指向的是哪种类型。您拥有的唯一“保证”是，您可以添加类型的值T（或的任何子类T），而不会破坏所指向列表的完整性。

完美的例子是Collections.copy()：

public static <T> void copy(List<? super T> dest,List<? extends T> src)

请注意，src列表声明如何extends用于允许我传递一组相关列表类型中的任何列表，并且仍然保证它会生成T类型的值或T的子类。但是您不能将其添加到src列表中。

该dest列表声明的用途super，让我从一个家庭相关的列表类型的通过任何名单，仍然保证我可以写一个特定类型T到该列表中的一个值。但是，如果我从列表中读取数据，则不能保证读取特定类型T 的值。

因此，现在有了通用通配符，我可以使用单个方法进行任何这些调用：

// copy(dest, src)
Collections.copy(new ArrayList<Number>(), new ArrayList<Number());
Collections.copy(new ArrayList<Number>(), new ArrayList<Integer());
Collections.copy(new ArrayList<Object>(), new ArrayList<Number>());
Collections.copy(new ArrayList<Object>(), new ArrayList<Double());

考虑一下这个令人困惑且范围很广的代码，以锻炼您的大脑。注释掉的行是非法的，其原因在该行的最右边指出（需要滚动查看其中的一些内容）：

  List<Number> listNumber_ListNumber  = new ArrayList<Number>();
//List<Number> listNumber_ListInteger = new ArrayList<Integer>();                    // error - can assign only exactly <Number>
//List<Number> listNumber_ListDouble  = new ArrayList<Double>();                     // error - can assign only exactly <Number>

  List<? extends Number> listExtendsNumber_ListNumber  = new ArrayList<Number>();
  List<? extends Number> listExtendsNumber_ListInteger = new ArrayList<Integer>();
  List<? extends Number> listExtendsNumber_ListDouble  = new ArrayList<Double>();

  List<? super Number> listSuperNumber_ListNumber  = new ArrayList<Number>();
//List<? super Number> listSuperNumber_ListInteger = new ArrayList<Integer>();      // error - Integer is not superclass of Number
//List<? super Number> listSuperNumber_ListDouble  = new ArrayList<Double>();       // error - Double is not superclass of Number


//List<Integer> listInteger_ListNumber  = new ArrayList<Number>();                  // error - can assign only exactly <Integer>
  List<Integer> listInteger_ListInteger = new ArrayList<Integer>();
//List<Integer> listInteger_ListDouble  = new ArrayList<Double>();                  // error - can assign only exactly <Integer>

//List<? extends Integer> listExtendsInteger_ListNumber  = new ArrayList<Number>(); // error - Number is not a subclass of Integer
  List<? extends Integer> listExtendsInteger_ListInteger = new ArrayList<Integer>();
//List<? extends Integer> listExtendsInteger_ListDouble  = new ArrayList<Double>(); // error - Double is not a subclass of Integer

  List<? super Integer> listSuperInteger_ListNumber  = new ArrayList<Number>();
  List<? super Integer> listSuperInteger_ListInteger = new ArrayList<Integer>();
//List<? super Integer> listSuperInteger_ListDouble  = new ArrayList<Double>();     // error - Double is not a superclass of Integer


  listNumber_ListNumber.add(3);             // ok - allowed to add Integer to exactly List<Number>

  // These next 3 are compile errors for the same reason:
  // You don't know what kind of List<T> is really
  // being referenced - it may not be able to hold an Integer.
  // You can't add anything (not Object, Number, Integer,
  // nor Double) to List<? extends Number>      
//listExtendsNumber_ListNumber.add(3);     // error - can't add Integer to *possible* List<Double>, even though it is really List<Number>
//listExtendsNumber_ListInteger.add(3);    // error - can't add Integer to *possible* List<Double>, even though it is really List<Integer>
//listExtendsNumber_ListDouble.add(3);     // error - can't add Integer to *possible* List<Double>, especially since it is really List<Double>

  listSuperNumber_ListNumber.add(3);       // ok - allowed to add Integer to List<Number> or List<Object>

  listInteger_ListInteger.add(3);          // ok - allowed to add Integer to exactly List<Integer> (duh)

  // This fails for same reason above - you can't
  // guarantee what kind of List the var is really
  // pointing to
//listExtendsInteger_ListInteger.add(3);   // error - can't add Integer to *possible* List<X> that is only allowed to hold X's

  listSuperInteger_ListNumber.add(3);      // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>
  listSuperInteger_ListInteger.add(3);     // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>

您不能（没有不安全的转换）。您只能从他们那里阅读。

问题是您不知道列表的确切含义。它可能是Number的任何子类的列表，因此当您尝试将元素放入其中时，您不知道该元素实际上是否适合列表。

例如，列表可能是的列表Byte，因此将a Float放入列表将是错误的。

“列表'<'？扩展Number>实际上是一个上限通配符！

上限通配符说，扩展Number或Number本身的任何类都可以用作形式参数类型：问题源于Java不知道List到底是什么类型的事实。它必须是EXACT和UNIQUE类型。希望对您有所帮助:)

您可以改为：

  List<Number> foo3 = new ArrayList<Number>();      
  foo3.add(3);

即使我在这里阅读了答案，也一直让我感到困惑，直到我找到了帕维尔·米纳耶夫（Pavel Minaev）的评论：

请注意，列表<？扩展Number>并不表示“不同类型的对象列表，所有这些都扩展Number”。它的意思是“扩展Number的单一类型的对象列表”

之后，我能够理解BertF的出色解释。列表<？扩展Number>是什么意思？可以是扩展Number（Integer，Double等）的任何类型，并且在声明（List <？extended Number> list）中没有明确说明它们是哪一个，因此当您想使用add方法时，如果输入是是否属于同一类型；到底是什么类型？

那么List <的元素？扩展Number>只能在构造时设置。

还要注意以下几点：当我们使用模板时，我们正在告诉编译器我们弄乱了什么类型。例如T对我们来说就是这种类型，但不是吗？一样

我得说..这是要解释/学习的脏话之一

从'Object'扩展列表的位置，您可以使用list.add；当要使用list.get时，只需要将Object转换为您的Object即可；