Является ли List‹Double› подтипом List‹? расширяет номер› и почему?

Есть несколько моментов, которые также следует добавить

1. Во время выполнения List<Double>, List<? extends Number>, List<?> и List<Object> все идентичны. Общий параметр вообще не компилируется. Вся магия с дженериками — это развлечение во время компиляции. Это также означает, что если у вас есть пустой List, вы понятия не имеете, что такое универсальный параметр!

2. Старайтесь не думать об универсальном параметре как о «подтипе», общий параметр на самом деле означает, что «класс использует общий параметр», поэтому в данном случае « список использует Число". Хорошим примером этого является HashMap. source, если вы посмотрите на его внутреннюю работу, он на самом деле хранит массив Entry, и все записи содержат ключи и значения, хранящиеся в них. Когда вы смотрите на более сложное использование дженериков, вы иногда видите такое использование.

   В ситуации с List общий параметр означает, что список хранит этот тип объекта, может случиться так, что объект вообще никогда не хранит объект типа универсального параметра! Как это:

   public class DummyIterator<O> implements Iterator<O>{
       public boolean hasNext() {
           return false;
       }
   
       public O next() {
           return null;
       }
   }
   

3. Что на самом деле означает List<? extends Number>? Ну, это почти то же самое, что и List<Number> для большинства применений. Имейте в виду, однако, что, говоря ?, вы в значительной степени говорите: «Меня не волнует тип», который проявляется в этой ситуации:

   List<Double> doubles = new ArrayList<Double>();
   List<? extends Number> numbers = doubles;
   numbers.add(new Double(1));  //COMPILE ERROR
   Number num = numbers.get(0);
   

   Таким образом, мы не можем добавить Double к <? extends Number>. Но для этого примера:

   List<Double> doubles = new ArrayList<Double>();
   List<Number> numbers = doubles; //COMPILE ERROR
   numbers.add(new Integer(1));
   Number num = numbers.get(0);
   

   Вы не можете назначить List<Double> List<Number>, что имеет смысл, поскольку вы специально говорите, что списки используют только числовые типы.

4. Итак, где вы должны использовать ?? ну действительно везде, где вы могли бы сказать: «Меня не волнует общий параметр», например:

   boolean equalListSizes(List<?> list1, List<?> list2) {
     return list1.size() == list2.size();
   }
   

   Вы должны использовать формат типа ? extends Number только в том случае, если вы не изменяете объект с помощью универсального параметра. так например:

     Number firstItem(List<? extends Number> list1) {
       return list1.get(0);
     }
   

5. Вместо использования форматов ? и ? extends Number попробуйте использовать дженерики для класса/метода, в большинстве случаев это также сделает ваш код более читабельным!:

   <T extends Number> T firstItem(List<T> list1) {
     return list1.get(0);
   }
   

   Класс:

   class Animal{}
   class Dog extends Animal{}
   class AnimalHouse<A extends Animal> {
       List<A> animalsInside = new ArrayList<A>(); 
       void enterHouse(A animal){
           animalsInside.add(A);
       }
   
       A leaveHouse() {
           return animalsInside.remove(0);
       }
   }
   AnimalHouse<Dog> ah = new AnimalHouse<Dog>();
   ah.enterHouse(new Dog());
   Dog rufus = ah.leaveHouse();
   

6. В качестве бонуса в отношении дженериков вы также можете параметризовать методы для возврата определенного класса. Хорошим примером этого является метод any() в junit и коллекция пустых списков:

   Dog rufus = Matchers.<Dog>any();
   List<Dog> dogs = Collections.<Dog>emptyList();
   

   Этот синтаксис позволяет указать возвращаемый тип объекта. Иногда весьма полезно знать (делает некоторые приведения излишними)!

Все ваши пункты верны.

1. Double является подтипом Number, а List<Double> не является подтипом List<Number>.

2. List<Dog> не является подтипом List<Animal>, потому что вы можете добавить Cat к List<Animal>, но вы не можете сделать это с List<Dog>.

Это правильно. Дженерики не ковариантны (но массивы!). Вот некоторые дополнительные материалы: Почему массивы ковариантны, а дженерики инвариантны?< /а>

List<Double> doubles = new ArrayList<>();
List<? extends Number> numbers = doubles;

Во время выполнения List<T> и List<U> идентичны List (1).

Однако это изменится с введением типов значений (ожидается, что это произойдет в выпуске JDK 9 или JDK 10 не ранее середины 2016 года). List<T> больше не будет совпадать с List<U> из-за многочисленных ограничений, описанных здесь Брайаном Гетцем: http://cr.openjdk.java.net/~briangoetz/valhalla/specialization.html

(1) - типы T и U различаются в предыдущих утверждениях

Это помогло мне увидеть дженерики как ограничения или контракты, а не как типы с подтипами. Таким образом, переменная List<? extends Number> var говорит: var — это список некоторого неизвестного типа ?, который должен быть подтипом Number.

List<Number> listN;
List<Double> listD;
List<? extends Number> listX;
...
Number n1 = ...;
Double d1 = ...;
...
listN.add(n1); // OK n1 is a Number
listN.add(d1); // OK d1 is a Double, which is a Number
listD.add(n1); // compile error, n1 is not a Double
listD.add(d1); // OK
listX.add(n1); // compile error, because the exact type of list is not known! (prevents putting a Dog in a Cat list)
listX.add(d1); // compile error, same cause

Итак, если вы даже не можете поместить число в List<? extends Number>, в чем смысл такого списка? Он позволяет работать со списками, точный тип которых не имеет значения для поставленной задачи:

// instead of several exactly typed methods...
int count(List<Number> numberList) {...}
int count(List<Object> objectList) {...}
// ...etc. you can have one with a degree of freedom:
int count(List<?> anyList) {...} // don't need to know the exact type of list

// instead of this...
Number sum(List<Number> numberList) {...}
Number sum(List<Double> doubleList) {...}
Number sum(List<Integer> integerList){...}
// you can do this, with a little less freedom in the ?
Number sum(List<? extends Number> list) {
  // the only thing we need to know about the list's type is that it is some number type
  ...
  Number ni = list.get(i);
  ...
}

Использование подстановочных знаков ? extends X позволяет смягчить жесткие контракты до более слабых условий.

Используя параметр именованного типа, вы можете установить ограничения на разрешенные типы между несколькими переменными:

// works for any type T of list, whatever T is
// T is the same in the argument and in the return
<T> T pickObject(List<T> list, int index) {
  return list.get(index);
}

// works for any type T of list, if T is a Number type
// T is the same in the argument and in the return
<T extends Number> T pickNumber(List<T> list, int index) {
  return list.get(index);
}
...
List<Number> list;
Number n = pickNumber(list);