我如何添加到列表<？ 扩展Number>数据结构？
我有一个名单是这样宣布的：
List<? extends Number> foo3 = new ArrayList<Integer>(); 我试着给foo3加3。 不过，我得到这样的错误消息：
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的通配符声明 List<? extends Number> foo3意味着variablesfoo3可以保存任何types的值（而不是特定types的值）。 这意味着任何这些都是法定的任务：
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什么types的对象，在上述任何可能的ArrayList赋值之后是合法的：
- 你不能添加一个
Integer因为foo3可能指向一个List<Double>。 - 你不能添加一个
Double因为foo3可能指向一个List<Integer>。 - 你不能添加一个
Number因为foo3可能指向一个List<Integer>。
你不能添加任何对象到List<? extends T> List<? extends T>因为你不能保证它真正指向什么样的List ，所以你不能保证对象被允许在List 。 唯一的“保证”是你只能读取它，你会得到一个T或T子类。
反向逻辑适用于super ，例如List<? super T> 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
你不能从List<? super T>读取特定typesT（例如Number ） List<? super T> List<? super T>因为你不能保证它真正指向什么样的List 。 你唯一的“保证”是你可以添加一个Ttypes的值（或T任何子类）而不违反被指向的列表的完整性。
这个完美的例子是Collections.copy()的签名：
public static <T> void copy(List<? super T> dest,List<? extends T> src)
注意src列表声明使用extends来允许我传递来自相关列表types族的任何List，并且仍然保证它将产生typesT或T的子类的值。但是不能将其添加到src列表中。
dest列表声明使用super允许我从相关列表types的家族中传递任何列表，并且仍然保证我可以将特定typesT的值写入该列表。 但是，如果从列表中读取，则不能保证读取特定typesT的值。
所以，现在，感谢generics通配符，我可以用这种单一的方法进行这些调用：
// 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列表，所以将一个Float放入它将是一个错误。
你可以这样做：
List<Number> foo3 = new ArrayList<Number>(); foo3.add(3);
