问题
我有一个List,声明如下:
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)
#1 热门回答(245 赞)
对不起,但你不能。
通配符声明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
分配之后合法的:
- 你无法添加整数,因为foo3可能指向List <Double>。
- 你无法添加Double,因为foo3可能指向List <Integer>。
- 你无法添加数字,因为foo3可能指向List <Integer>。
你不能添加任何对象到List<? extends T>
,因为你不能保证什么样的28735522it真正指向,所以你不能保证在该530600022中允许该对象。唯一的"保证"是你只能读取它,你将获得a717393866或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
你无法从List<? super T>
读取特定类型T(例如Number
)因为你无法保证什么样的List
it真正指向。你唯一的"保证"是你可以添加typeT
(或任何子类T
)的值,而不会违反指向列表的完整性。
这方面的完美例子是Collections.copy()
的签名:
public static <T> void copy(List<? super T> dest,List<? extends T> src)
请注意src
list声明如何使用extends
允许我从一系列相关List类型传递任何List,并且仍然保证它将生成T类型或T的子类的值。但是你无法添加到src
列表。
dest
list声明使用super
允许我从一系列相关List类型传递任何List,并且仍然保证我可以将特定类型T的值写入该列表。但如果从列表中读取,则无法保证读取特定type 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>
#2 热门回答(14 赞)
你不能(没有不安全的演员阵容)。你只能从中读取。
问题是你不知道列表的确切列表是什么。它可以是Number的任何子类的列表,因此当你尝试将元素放入其中时,你不知道该元素实际上适合列表。
例如,List可能是Byte
的列表,因此将aFloat
放入其中将是错误的。
#3 热门回答(2 赞)
你可以这样做:
List<Number> foo3 = new ArrayList<Number>();
foo3.add(3);