Почему массивы ковариантны, а дженерики инвариантны?

От эффективной Явы Джошуа Блох,

1. Массивы отличаются от универсального типа двумя важными способами. Первые массивы ковариантны. Обобщения являются инвариантами.

2. Ковариант просто означает, что если X является подтипом Y, то X [] также будет подтипом Y []. Массивы являются ковариантными, так как string является подтипом Object So

   String[] is subtype of Object[]

   Инвариант просто означает, что независимо от того, является ли X подтипом Y или нет,

    List<X> will not be subType of List<Y>.

Мой вопрос, почему решение сделать массивы ковариантными в Java? Существуют и другие сообщения SO, такие как Почему массивы инвариантны, а списки ковариантны? , но они, кажется, сосредоточены на Скале, и я не могу следовать.

Через википедию :

Ранние версии Java и C # не включали дженерики (или параметрический полиморфизм).

В таком случае создание инвариантов массивов исключает полезные полиморфные программы. Например, рассмотрите возможность написания функции для перемешивания массива или функции, которая проверяет два массива на равенство, используя Object.equalsметод для элементов. Реализация не зависит от точного типа элемента, хранящегося в массиве, поэтому должна быть возможность написать одну функцию, которая работает со всеми типами массивов. Легко реализовать функции типа

boolean equalArrays (Object[] a1, Object[] a2);
void shuffleArray(Object[] a);

Однако если бы типы массивов рассматривались как инварианты, эти функции можно было бы вызывать только в массиве точно такого типа Object[]. Нельзя, например, перемешать массив строк.

Поэтому и Java, и C # обрабатывают типы массивов ковариантно. Например, в C # string[]это подтип object[], а в Java String[]это подтип Object[].

Это отвечает на вопрос «Почему массивы ковариантны?» Или, точнее, «Почему массивы были ковариантными в то время ?»

Когда дженерики были введены, они были преднамеренно не сделаны ковариантными по причинам, указанным в этом ответе Джоном Скитом :

Нет, это List<Dog>не так List<Animal>. Подумайте, что вы можете сделать с List<Animal>- вы можете добавить к нему любое животное ... включая кошку. Теперь, вы можете логически добавить кошку в помет щенков? Точно нет.

// Illegal code - because otherwise life would be Bad
List<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs; // Awooga awooga
animals.add(new Cat());
Dog dog = dogs.get(0); // This should be safe, right?

Внезапно у вас очень запутанная кошка.

Первоначальная мотивация создания ковариантов массивов, описанная в статье в Википедии, не применима к генерикам, потому что подстановочные знаки сделали возможным выражение ковариации (и контравариантности), например:

boolean equalLists(List<?> l1, List<?> l2);
void shuffleList(List<?> l);

Причина в том, что каждый массив знает свой тип элемента во время выполнения, в то время как универсальная коллекция не знает из-за стирания типа.

Например:

String[] strings = new String[2];
Object[] objects = strings;  // valid, String[] is Object[]
objects[0] = 12; // error, would cause java.lang.ArrayStoreException: java.lang.Integer during runtime

Если это было разрешено с общими коллекциями:

List<String> strings = new ArrayList<String>();
List<Object> objects = strings;  // let's say it is valid
objects.add(12);  // invalid, Integer should not be put into List<String> but there is no information during runtime to catch this

Но это может вызвать проблемы позже, когда кто-то попытается получить доступ к списку:

String first = strings.get(0); // would cause ClassCastException, trying to assign 12 to String

Может быть, это поможет: -

Обобщения не ковариантны

Массивы в языке Java являются ковариантными - это означает, что если Integer расширяет Number (что он и делает), то не только Integer также является Number, но Integer [] также является Number[]и вы можете передавать или назначать Integer[]где требуется Number[]. (Более формально, если Number является супертипом типа Integer, то Number[]является супертипом Integer[].) Вы можете подумать, что то же самое верно и для универсальных типов - List<Number>это супертип List<Integer>, и вы можете передать, List<Integer>где List<Number>ожидается a . К сожалению, это не работает таким образом.

Оказывается, есть веская причина, по которой это так не работает: это нарушило бы непатентованные средства обеспечения безопасности типов. Представьте, что вы можете присвоить List<Integer>a List<Number>. Затем следующий код позволит вам поместить что-то, что не является целым числом, в List<Integer>:

List<Integer> li = new ArrayList<Integer>();
List<Number> ln = li; // illegal
ln.add(new Float(3.1415));

Поскольку ln - это List<Number>, добавление Float к нему кажется совершенно законным. Но если у ln есть псевдоним li, то это нарушит обещание безопасности типов, неявное в определении li, - это список целых чисел, поэтому универсальные типы не могут быть ковариантными.

Массивы ковариантны по крайней мере по двум причинам:

• Это полезно для коллекций, которые содержат информацию, которая никогда не изменится на ковариантную. Чтобы коллекция T была ковариантной, ее резервное хранилище также должно быть ковариантным. В то время как можно создать неизменную Tколлекцию, которая не использовала бы в T[]качестве своего резервного хранилища (например, используя дерево или связанный список), такая коллекция вряд ли будет работать так же, как и коллекция, поддерживаемая массивом. Кто-то может утверждать, что лучшим способом обеспечить ковариантные неизменяемые коллекции было бы определение типа «ковариантный неизменяемый массив», в котором они могли бы использовать резервное хранилище, но простое использование ковариации массива, вероятно, было проще.

• Массивы будут часто видоизменяться кодом, который не знает, какой тип объектов будет в них, но не будет помещать в массив то, что не было считано из этого же массива. Ярким примером этого является сортировка кода. Концептуально для типов массива могло бы быть возможным включить методы для обмена или перестановки элементов (такие методы могут быть в равной степени применимы к любому типу массива) или определить объект «манипулятор массива», который содержит ссылку на массив и одну или несколько вещей. он был прочитан из него и может включать методы для хранения ранее прочитанных элементов в массиве, из которого они получены. Если бы массивы не были ковариантными, пользовательский код не смог бы определить такой тип, но среда выполнения могла бы включать некоторые специализированные методы.

Тот факт, что массивы являются ковариантными, может рассматриваться как уродливый хак, но в большинстве случаев это облегчает создание рабочего кода.

Важной особенностью параметрических типов является способность писать полиморфные алгоритмы, то есть алгоритмы, которые работают с структурой данных независимо от значения ее параметра, например Arrays.sort().

С обобщениями это делается с подстановочными типами:

<E extends Comparable<E>> void sort(E[]);

Чтобы быть действительно полезными, подстановочные типы требуют подстановочного знака, а для этого требуется понятие параметра типа. Ничего из этого не было доступно в то время, когда массивы были добавлены в Java, а создание массивов ссылочного типа ковариантно позволило намного проще разрешить полиморфные алгоритмы:

void sort(Comparable[]);

Однако эта простота открыла лазейку в системе статического типа:

String[] strings = {"hello"};
Object[] objects = strings;
objects[0] = 1; // throws ArrayStoreException

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

Короче говоря, новый подход, воплощенный в дженериках, делает систему типов более сложной, но также более статически безопасной, в то время как более старый подход был проще и менее статически безопасен. Разработчики языка выбрали более простой подход, имея более важные дела, чем закрытие небольшой лазейки в системе типов, которая редко вызывает проблемы. Позже, когда была создана Java и были решены насущные потребности, у них были ресурсы, чтобы сделать это правильно для обобщений (но изменение его для массивов могло бы сломать существующие программы Java).

Обобщения являются инвариантами : из JSL 4.10 :

... Подтипирование не распространяется на универсальные типы: T <: U не означает, что C<T><: C<U>...

и несколько строк далее, JLS также объясняет, что
массивы ковариантны (первая буква):

4.10.3 Субтипирование среди типов массивов

Я думаю, что они приняли неправильное решение в первую очередь, что сделало массив ковариантным. Это нарушает безопасность типов, как описано здесь, и они застряли с этим из-за обратной совместимости, и после этого они попытались не сделать ту же ошибку для универсального. И это одна из причин, по которой Джошуа Блох предпочитает списки массивам в пункте 25 книги «Эффективная Java (второе издание)»

Мое предположение: когда код ожидает массив A [] и вы даете ему B [], где B является подклассом A, есть только две вещи, о которых нужно беспокоиться: что происходит, когда вы читаете элемент массива, и что происходит, если вы пишете Это. Поэтому нетрудно написать языковые правила, чтобы гарантировать, что безопасность типов сохраняется во всех случаях (главное правило состоит в том, что ArrayStoreExceptionможет быть выброшено, если вы попытаетесь вставить A в B []). Тем не менее, для универсального, когда вы объявляете класс SomeClass<T>, Tв теле класса может использоваться любое количество способов , и я предполагаю, что слишком сложно разработать все возможные комбинации, чтобы написать правила о том, когда вещи разрешены, а когда нет.