Как добавить в список <? расширяет Number> структуры данных?

Ответ 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>.
• Вы не можете добавить 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, если я прочитаю из списка.

Итак, теперь, благодаря универсальным шаблонам 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, поэтому, когда вы пытаетесь поместить в него элемент, вы не знаете, что элемент действительно вписывается в список.

Например, List может быть списком Byte s, поэтому было бы ошибкой помещать в него Float.

Ответ 3

Вместо этого вы можете сделать это:

  List<Number> foo3 = new ArrayList<Number>();      
  foo3.add(3);