Як я можу додати до списку <? розширює число> структури даних?

У мене є список, який оголошено так:

 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

Ви не можете прочитати конкретний тип 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щоб дозволити мені пройти будь-який список з сімейства родинних типів List і до сих пір я можу гарантувати , записати значення типу конкретних Т до цього списку. Але не можна гарантувати зчитування значень конкретного типу 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>

Ви не можете (без небезпечних ролей). З них можна лише читати.

Проблема полягає в тому, що ви не знаєте, що саме це список. Це може бути список будь-якого підкласу Числа, тому, намагаючись вставити в нього елемент, ви не знаєте, що елемент насправді вписується в список.

Наприклад, Список може бути списком Bytes, тому було б помилкою ввести Floatйого.

"Список '<'? Розширює номер> насправді є верхньою межею підстановки!

Верхня межа обмежувача говорить про те, що будь-який клас, що розширює число чи число, може використовуватися як формальний тип параметра: Проблема випливає з того, що Java не знає, що таке List List . Він повинен бути ТОЧНИМ і УНІКАЛЬНИМ типом. Я сподіваюся, що це допомагає :)

Мене це бентежить, хоча я читав відповіді тут, поки не знайшов коментар Павла Мінаєва:

Зауважте, що Список <? розширює Число> не означає "список об'єктів різних типів, усі вони розширюють Число". Це означає "список об'єктів одного типу, який розширює число"

Після цього я зміг зрозуміти дивовижне пояснення БертФ. Список <? розширює число> означає? може бути будь-якого типу, що розширює число (Integer, Double та ін.), і його не очищати в декларації (Список <? розширює номер> список), що це з них, тому коли ви хочете використовувати метод add, його невідомо, якщо вхід того ж типу чи ні; що це за тип взагалі?

Отже, елементи Список <? extens Number> може бути встановлений лише при побудові.

Також зверніть увагу на це: Коли ми використовуємо шаблони, ми повідомляємо компілятору, з яким типом ми возимось. Т, наприклад, утримує цей тип для нас, але ні ? робить те саме

Я мушу сказати .. Це одне з брудних, щоб пояснити / вивчити

Ви можете зробити це замість цього:

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

Ви можете підробити це, створивши посилання на Список іншого типу.

(Це "небезпечні ролі", згадані sepp2k.)

List<? extends Number> list = new ArrayList<Integer>();

// This will not compile
//list.add(100);

// WORKS, BUT NOT IDEAL
List untypedList = (List)list;
// It will let you add a number
untypedList.add(200);
// But it will also let you add a String!  BAD!
untypedList.add("foo");

// YOU PROBABLY WANT THIS
// This is safer, because it will (partially) check the type of anything you add
List<Number> superclassedList = (List<Number>)(List<?>)list;
// It will let you add an integer
superclassedList.add(200);
// It won't let you add a String
//superclassedList.add("foo");
// But it will let you add a Float, which isn't really correct
superclassedList.add(3.141);
// ********************
// So you are responsible for ensuring you only add/set Integers when you have
// been given an ArrayList<Integer>
// ********************

// EVEN BETTER
// If you can, if you know the type, then use List<Integer> instead of List<Number>
List<Integer> trulyclassedList = (List<Integer>)(List<?>)list;
// That will prevent you from adding a Float
//trulyclassedList.add(3.141);

System.out.println("list: " + list);

Оскільки untypedList, superclassedListі trulyclassedListце лише посилання на них list, ви все одно будете додавати елементи до оригінального ArrayList.

Насправді вам не потрібно використовувати (List<?>)в наведеному вище прикладі, але він може знадобитися у своєму коді, залежно від типу, який listви отримали.

Зауважте, що використання ?буде отримувати попередження компілятора, поки ви не поставите це вище своєї функції:

@SuppressWarnings("unchecked")

там, де розширити список з 'Object', ви можете використовувати list.add, а коли хочете використовувати list.get, потрібно лише передати об’єкт на ваш об’єкт;