我有一个这样声明的列表:
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
您无法从 Number
中读取特定类型 T(例如 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 的值写入该列表。但是如果我从列表中读取,则不能保证读取到 specific 类型 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>
关于java - 如何添加到 List<?扩展 Number> 数据结构?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/2776975/