Почему это неправильно для создания массива Object []?

Question

Я очень новичок в родовом программировании на Java.

Я не понимаю, почему массивы родового типа не могут быть созданы.

T[] a = new T[size]; //why does this give an error? 

Если общий тип означает, что общий заполнитель T будет заменен на имя класса во время выполнения, что мешает нам создать массив, имеющий общие ссылки?

После недолгих поисков, я нашел обходной путь

T[] a = (T[])new Object[size]; //I don't get how this works? 

Хотя я нашел решение, я до сих пор не понимаю, что мешает созданию общего массива. Предположим, что я создаю функцию, которая возвращает массив объектов.

public Object[] foo(){ 
     return new Object[12]; 
} 

А затем сделать вызов

String[] a = (String[])foo(); 

дает ClassCastException. Но почему? Не похоже ли это на первую строку кода, в которой я передал массив Object в массив T?

T[] a = (T[])new Object[size]; 

Если это прошло без сбоев, почему не сделал этого?

Answer 1

Часть вопроса - смотреть на нее наоборот. Вы не можете сделать (String[]) new Object[10]; потому что массив Object равен не a String массив. Поскольку

String[] array = new String[10]; 
array[0] = "foo"; 
String foo = array[0]; 

прекрасно, но

Object[] objectArray = new Object[10]; 
objectArray[0] = 10; 
String[] stringArray = (String[]) objectArray; 
String foo = stringArray[0]; 

... пытается присвоить Integer к String, что не должно быть разрешено в первую очередь. Таким образом, этот код выходит из строя, когда вы набрасываете Object[] на String[]. В этом коде есть, чтобы выбросить ClassCastException.

Это все равно для Java еще до того, как вначале были изобретены дженерики. Примите все это первые. Затем перейти к дженерикам.

Теперь, способ Java генерики реализованы означает, что при компиляции кода, T молча переписана Object. Таким образом, T[] array = (T[]) new Object[10] молча разрешен, потому что он фактически переписывается на Object[] array = new Object[10]. Но как только вы это вынимаете, все идет не так. Например,

private static <T> T[] newArray() { 
    return (T[]) new Object[10]; 
} 

если вы звоните String[] array = newArray(), вы получите ClassCastException на месте вызова, а не в newArray(). Вот почему Java дает вам предупреждение в (T[]) new Object[10], и это предупреждение вполне может привести к настоящему ClassCastException.

Вообще говоря, не смешивайте массивы и дженерики. Путь вокруг всего этого - правильно использовать List.

Answer 2

При работе с массивами необходимо отметить несколько вещей.

Во-первых, массивы считаются covariant; то есть типизированный массив будет поддерживать свою цепочку наследования. Таким образом, Integer[] является Object[] таким же образом, что Integer является Object.

Вот почему ваш последний пример не удается. Вы хотите, чтобы бросить Object[] к String[] через foo:

String[] a = (String[])foo(); 

Object[] никогда не будет String[] так как Object не String (а наоборот всегда будет истинным).

Во-вторых, массивы и дженерики не смешивают все это хорошо. Дженерики считаются инвариантом; то есть они не будут поддерживать свои сети наследования. A List<Integer>: не считается таким же, как List<Object>.

Что касается причины вашего конкретного примера, это связано с стиранием типа во время компиляции. Массивы должны знать свой конкретный тип во время компиляции, и без этой информации они не могут быть созданы. Поскольку generics не хранят эту информацию, вы не можете создавать экземпляр общего массива так же, как вы создавали бы не общий набор.

То есть, вы должны использовать форму произнесения:

T[] a = (T[]) new Object[size]; 

You can read a bit more about generic arrays in this answer, так как она охватывает большинство основных моментов, которые вы должны были бы знать, при общении с ними.

Answer 3

Массивы знают свой тип во время выполнения. A String[] знает, что это массив из String s.

В отличие от этого, параметры типового типа стираются во время выполнения, поэтому List<String> во время выполнения является только List.

Поскольку параметры типа T не доступны во время выполнения new T[10] (который не компилируется), невозможно создать истинный T[].

Это не правда, что

T[] a = (T[])new Object[size]; 

не может бросить исключение. Оно может. Пример Луи Вассермана показывает, что он может вызвать исключение на сайте вызова, но эта строка также может напрямую передавать исключение.Например

public static void main(String[] args) { 
    foo(); 
} 

static <T extends Number> void foo() { 
    T[] array = (T[]) new Object[42]; 
} 

Здесь, нижняя граница T является Number, поэтому во время выполнения, он пытался бросить Object[] к Number[], который бросает ClassCastException.

Вы можете создать T[], если у вас есть Class<T> объект clazz, используя, например,

Array.newInstance(clazz, length);