Как я могу добавить в список<? расширяет число> структуры данных?
У меня есть список, который объявлен следующим образом :
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
Извините, но вы не можете.
Объявление подстановочного знака 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>
. - Вы не можете добавить a,
Double
потому чтоfoo3
это может указывать на aList<Integer>
. - Вы не можете добавить a,
Number
потому чтоfoo3
это может указывать на aList<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, если я прочитаю из списка.
Итак, теперь, благодаря подстановочным знакам 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>
Ответ 2
Вы не можете (без небезопасных приведений). Вы можете только читать из них.
Проблема в том, что вы не знаете, что именно представляет собой список. Это может быть список любого подкласса Number , поэтому, когда вы пытаетесь поместить в него элемент, вы не знаете, действительно ли элемент вписывается в список.
Например, список может быть списком Byte
s, поэтому было бы ошибкой помещать в него Float
.
Ответ 3
Это сбивало меня с толку, хотя я читал ответы здесь, пока я не нашел комментарий Павла Минаева:
Обратите внимание, что список < ? расширяет число > не означает "список объектов разных типов, все из которых расширяют число". Это означает "список объектов одного типа, который расширяет число"
После этого я смог понять потрясающее объяснение BertF. Что означает список <? расширяющее число>? может быть любого типа, расширяющего число (Integer, Double и т.д.), и это не указано в объявлении ( List <? extends Number > список ), что это за структура, поэтому, когда вы хотите использовать метод add, неизвестно, того же ли типа входные данные или нет; что это за тип вообще?
Таким образом, элементы List < ? extends Number > могут быть заданы только при построении.
Также обратите внимание на это: когда мы используем шаблоны, мы сообщаем компилятору, с каким типом мы имеем дело. T, например, содержит этот тип для нас, но не? делает то же самое
Я должен сказать.. Это одна из самых грязных тем для объяснения / изучения
Ответ 4
"Список '<' ? extends Number> на самом деле является шаблоном с верхней границей !
Подстановочный знак, ограниченный сверху, говорит о том, что любой класс, расширяющий Number, или само число может использоваться в качестве формального типа параметра: Проблема связана с тем фактом, что Java не знает, что такое тип List на самом деле. Это должен быть ТОЧНЫЙ и УНИКАЛЬНЫЙ тип. Надеюсь, это поможет :)