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

很抱歉，但不能。

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

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 foo3ArrayList

• 您无法添加，因为可能指向 .Integerfoo3List<Double>
• 您无法添加，因为可能指向 .Doublefoo3List<Integer>
• 您无法添加，因为可能指向 .Numberfoo3List<Integer>

您无法向 List 添加任何对象<？ 扩展 T> 因为您无法保证它真正指向哪种类型的 List，因此您无法保证该对象在该列表中被允许。唯一的“保证”是你只能从中读取，你会得到一个T或T的子类。

相反的逻辑适用于 ，例如 .这些是合法的：superList<? 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

您无法从List<？超级T>中读取特定类型T（例如数字），因为您无法保证它真正指向哪种列表。您拥有的唯一“保证”是，您可以在不违反所指向列表的完整性的情况下添加 T 类型值（或 T 的任何子类）。

这方面的完美例子是以下各项的签名：Collections.copy()

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

请注意列表声明如何使用它来允许我从一系列相关 List 类型中传递任何 List，并且仍然保证它将生成 T 类型或 T 的子类的值。但您无法添加到列表中。srcextendssrc

列表声明用于允许我从一系列相关列表类型中传递任何列表，并且仍然保证我可以向该列表写入特定类型 T 的值。但是，如果我从列表中读取，则无法保证读取特定类型 T 的值。destsuper

所以现在，多亏了泛型通配符，我可以使用这个方法进行任何这些调用：

// 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 的任何子类的列表，因此当您尝试将元素放入其中时，您并不知道该元素是否实际适合该列表。

例如，List 可能是 s 的列表，因此将 a 放入其中会是错误的。ByteFloat