Что такое сырой тип?
Спецификация языка Java определяет необработанный тип следующим образом:
Необработанный тип определяется как один из:
Тип ссылки, который формируется путем взятия имени объявления универсального типа без сопровождающего списка аргументов типа.
Тип массива, тип элемента которого является необработанным типом.
Не- staticтипа члена исходного типа R, не унаследованный от суперкласса или суперинтерфейса R.
Вот пример для иллюстрации:
public class MyType<E> {
class Inner { }
static class Nested { }
public static void main(String[] args) {
MyType mt; // warning: MyType is a raw type
MyType.Inner inn; // warning: MyType.Inner is a raw type
MyType.Nested nest; // no warning: not parameterized type
MyType<Object> mt1; // no warning: type parameter given
MyType<?> mt2; // no warning: type parameter given (wildcard OK!)
}
}
Здесь MyType<E>- параметризованный тип ( JLS 4.5 ). Обычно в разговорной речи называют этот тип просто MyTypeдля краткости, но формально это имя MyType<E>.
mtимеет необработанный тип (и генерирует предупреждение о компиляции) по первому пункту в приведенном выше определении; innтакже имеет необработанный тип по третьему пункту.
MyType.Nestedне параметризованный тип, хотя это тип члена параметризованного типа MyType<E>, потому что это static.
mt1и mt2оба объявлены с фактическими параметрами типа, поэтому они не являются необработанными типами.
Что такого особенного в необработанных типах?
По сути, необработанные типы ведут себя так же, как и до появления дженериков. То есть, следующее является полностью законным во время компиляции.
List names = new ArrayList(); // warning: raw type!
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // not a compilation error!
Приведенный выше код работает просто отлично, но предположим, что у вас также есть следующее:
for (Object o : names) {
String name = (String) o;
System.out.println(name);
} // throws ClassCastException!
// java.lang.Boolean cannot be cast to java.lang.String
Теперь мы сталкиваемся с проблемами во время выполнения, потому что namesсодержит что-то, что не является instanceof String.
Предположительно, если вы хотите namesсодержать только String, возможно , вы все еще могли бы использовать необработанный тип и вручную проверять каждый add сам, а затем вручную приводить к Stringкаждому элементу из names. Еще лучше , хотя НЕ использовать необработанный тип и позволить компилятору сделать всю работу за вас , используя всю мощь Java-дженериков.
List<String> names = new ArrayList<String>();
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // compilation error!
Конечно, если вы НЕ хотите , namesчтобы позволить Boolean, то вы можете объявить его как List<Object> namesи приведенный выше код будет компилироваться.
Смотрите также
Чем необработанный тип отличается от использования в <Object>качестве параметров типа?
Ниже приводится цитата из Effective Java 2nd Edition, пункт 23. Не используйте необработанные типы в новом коде :
В чем разница между необработанным типом Listи параметризованным типом List<Object>? Грубо говоря, первый отказался от проверки универсального типа, в то время как последний явно сказал компилятору, что он способен содержать объекты любого типа. Хотя вы можете передавать List<String>параметр типа List, вы не можете передать его параметру типа List<Object>. Существуют правила подтипов для обобщений, и List<String>это подтип необработанного типа List, но не параметризованного типа List<Object>. Как следствие, вы теряете безопасность типов, если вы используете сырой тип как List, но не если вы используете параметризованный тип какList<Object> .
Чтобы проиллюстрировать это, рассмотрим следующий метод, который принимает List<Object>и добавляет a new Object().
void appendNewObject(List<Object> list) {
list.add(new Object());
}
Обобщения в Java инвариантны. A List<String>не является a List<Object>, поэтому следующее генерирует предупреждение компилятора:
List<String> names = new ArrayList<String>();
appendNewObject(names); // compilation error!
Если бы вы объявили, appendNewObjectчто в Listкачестве параметра принимается необработанный тип , он скомпилируется, и поэтому вы потеряете безопасность типов, которую вы получаете от обобщений.
Смотрите также
Чем необработанный тип отличается от использования <?>в качестве параметра типа?
List<Object>и List<String>т. д. все List<?>, так что может быть заманчиво просто сказать, что они просто Listвместо. Тем не менее, есть существенное отличие: поскольку a List<E>определяет только add(E), вы не можете добавить любой произвольный объект в a List<?>. С другой стороны, поскольку необработанный тип Listне имеет безопасности типов, вы можете получить addчто угодно List.
Рассмотрим следующий вариант предыдущего фрагмента:
static void appendNewObject(List<?> list) {
list.add(new Object()); // compilation error!
}
//...
List<String> names = new ArrayList<String>();
appendNewObject(names); // this part is fine!
Компилятор прекрасно защитил вас от возможного нарушения неизменности типов List<?>! Если бы вы объявили параметр как необработанный тип List list, то код скомпилировался бы, и вы нарушили бы инвариант типа List<String> names.
Необработанный тип - это стирание этого типа.
Вернуться к JLS 4.8:
В качестве типа можно использовать стирание параметризованного типа или стирание типа массива, тип элемента которого является параметризованным типом. Такой тип называется необработанным типом .
[...]
Суперклассы (соответственно, суперинтерфейсы) необработанного типа являются стиранием суперклассов (суперинтерфейсов) любой из параметризаций универсального типа.
Тип конструктора, метода экземпляра или неполя staticполя необработанного типа, Cкоторый не унаследован от его суперклассов или суперинтерфейсов, является необработанным типом, который соответствует удалению его типа в общем объявлении, соответствующем C.
Проще говоря, когда используются сырой типа, конструкторы, методы экземпляра и не- staticполей также удаляется .
Возьмите следующий пример:
class MyType<E> {
List<String> getNames() {
return Arrays.asList("John", "Mary");
}
public static void main(String[] args) {
MyType rawType = new MyType();
// unchecked warning!
// required: List<String> found: List
List<String> names = rawType.getNames();
// compilation error!
// incompatible types: Object cannot be converted to String
for (String str : rawType.getNames())
System.out.print(str);
}
}
Когда мы используем сырье MyType, оно также getNamesстирается, так что оно возвращает сырье List!
JLS 4.6 продолжает объяснять следующее:
Стирание типа также отображает сигнатуру конструктора или метода в сигнатуру, которая не имеет параметризованных типов или переменных типа. Стирание сигнатуры конструктора или метода s- это сигнатура, состоящая из того же имени, что sи стирание всех типов формальных параметров, приведенных в s.
Возвращаемый тип метода и параметры типа универсального метода или конструктора также стираются, если сигнатура метода или конструктора удалена.
Удаление подписи универсального метода не имеет параметров типа.
В следующем сообщении об ошибке содержатся некоторые мысли Маурицио Симадамора, разработчика компилятора, и Алекса Бакли, одного из авторов JLS, о причинах такого поведения: https://bugs.openjdk.java.net/browse / JDK-6400189 . (Короче говоря, это упрощает спецификацию.)
Если это небезопасно, почему разрешено использовать необработанный тип?
Вот еще одна цитата из JLS 4.8:
Использование необработанных типов допускается только в качестве уступки совместимости устаревшего кода. Использование необработанных типов в коде, написанном после введения универсальности в язык программирования Java, настоятельно не рекомендуется. Вполне возможно, что будущие версии языка программирования Java будут запрещать использование необработанных типов.
Effective Java 2nd Edition также имеет следующее:
Учитывая, что вы не должны использовать необработанные типы, почему разработчики языка разрешили это? Для обеспечения совместимости.
Платформа Java собиралась вступить во второе десятилетие, когда были представлены дженерики, и существовало огромное количество Java-кода, который не использовал дженерики. Было сочтено критически важным, чтобы весь этот код оставался законным и мог взаимодействовать с новым кодом, который использует дженерики. Должно быть допустимо передавать экземпляры параметризованных типов в методы, которые были разработаны для использования с обычными типами, и наоборот. Это требование, известное как совместимость миграции , привело к принятию решения о поддержке необработанных типов.
Таким образом, необработанные типы никогда не должны использоваться в новом коде. Вы должны всегда использовать параметризованные типы .
Есть ли исключения?
К сожалению, из-за непатентованного универсального кода Java есть два исключения, где необработанные типы должны использоваться в новом коде:
- Литералы класса, например
List.class, неList<String>.class
instanceofоперанд, например o instanceof Set, неo instanceof Set<String>
Смотрите также