Извините, но вы не можете.
Объявление подстановочного знака 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
Вы не можете прочитать конкретный тип 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, если я прочитаю из списка.
Так что теперь, благодаря универсальным групповым символам, я могу сделать любой из этих вызовов одним единственным методом:
// 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>