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

Что такое необработанные типы в Java и почему я часто слышу, что их не следует использовать в новом коде?

Raw -типы - это древняя история языка Java. Вначале было Коллекции , и они содержали Объектов не больше и не меньше. Каждая операция над коллекциями требовала преобразования объекта в нужный тип.

List aList = new ArrayList();
String s = "Hello World!";
aList.add(s);
String c = (String)aList.get(0);

Хотя это работало большую часть времени, ошибки случались

List aNumberList = new ArrayList();
String one = "1";//Number one
aNumberList.add(one);
Integer iOne = (Integer)aNumberList.get(0);//Insert ClassCastException here

Старые коллекции без типов не могли обеспечить безопасность типов, поэтому программисту приходилось помнить, что он хранил в коллекции.
Универсальные шаблоны, которые были изобретены, чтобы обойти это ограничение, разработчик объявлял сохраненный тип один раз, а компилятор делал это вместо этого.

List<String> aNumberList = new ArrayList<String>();
aNumberList.add("one");
Integer iOne = aNumberList.get(0);//Compile time error
String sOne = aNumberList.get(0);//works fine

Для сравнения:

// Old style collections now known as raw types
List aList = new ArrayList(); //Could contain anything
// New style collections with Generics
List<String> aList = new ArrayList<String>(); //Contains only Strings

Более сложный интерфейс Compareable:

//raw, not type save can compare with Other classes
class MyCompareAble implements CompareAble
{
   int id;
   public int compareTo(Object other)
   {return this.id - ((MyCompareAble)other).id;}
}
//Generic
class MyCompareAble implements CompareAble<MyCompareAble>
{
   int id;
   public int compareTo(MyCompareAble other)
   {return this.id - other.id;}
}

Обратите внимание, что невозможно реализовать интерфейс CompareAble с compareTo (MyCompareAble) с необработанными типами. { {1}} Почему вы не должны их использовать:

• Любой объект , хранящийся в коллекции , должен быть преобразован, прежде чем его можно будет использовать
• Использование универсальных шаблонов позволяет проверять время компиляции
• Использование исходных типов аналогично сохранению каждого значения в виде объекта

Что делает компилятор: Универсальные шаблоны имеют обратную совместимость, они используют те же классы java, что и исходные типы. Магия в основном происходит во время компиляции.

List<String> someStrings = new ArrayList<String>();
someStrings.add("one");
String one = someStrings.get(0);

Будет скомпилирован как:

List someStrings = new ArrayList();
someStrings.add("one"); 
String one = (String)someStrings.get(0);

Это тот же код, который вы бы написали, если бы вы использовали необработанные типы напрямую.Думаю, я не уверен, что происходит с интерфейсом CompareAble , я предполагаю, что он создает две функции compareTo , одна принимает MyCompareAble , а другая - Объект и передача его первому после применения.

Каковы альтернативы необработанным типам: Используйте generics

"Сырой" тип в Java - это класс, который не является общим и имеет дело с "сырыми" объектами, а не с безопасными для типов параметрами общих типов.

Например, до появления в Java generics, вы бы использовали класс коллекции следующим образом:

LinkedList list = new LinkedList();
list.add(new MyObject());
MyObject myObject = (MyObject)list.get(0);

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

Используя generics, вы устраняете фактор "неизвестности", потому что вы должны явно указать, какой тип объектов может быть в списке:

LinkedList<MyObject> list = new LinkedList<MyObject>();
list.add(new MyObject());
MyObject myObject = list.get(0);

Заметьте, что с generics вам не нужно приводить объект, полученный в результате вызова get, коллекция предопределена для работы только с MyObject. Именно этот факт является основным движущим фактором дженериков. Он превращает источник ошибок во время выполнения в то, что можно проверить во время компиляции.

Что такое "сырой тип" и почему я часто слышу, что их не следует использовать в новом коде?

"Сырой тип" - это использование родового класса без указания аргумента(ов) типа для его параметризованного типа(ов), например, использование List вместо List. Когда дженерики были введены в Java, несколько классов были обновлены для использования дженериков. Использование этих классов в качестве "сырых типов" (без указания аргумента типа) позволяло компилировать устаревший код.

"Сырые типы" используются для обратной совместимости. Их использование в новом коде не рекомендуется, потому что использование класса generic с аргументом типа позволяет более сильную типизацию, что в свою очередь может улучшить понятность кода и привести к более раннему обнаружению потенциальных проблем.

Какова альтернатива, если мы не можем использовать необработанные типы, и чем она лучше?

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

Например, для метода, в котором программист хочет, чтобы переменная List под названием 'names' содержала только строки:

List<String> names = new ArrayList<String>();
names.add("John");          // OK
names.add(new Integer(1));  // compile error

Что такое необработанный тип?

Спецификация языка Java определяет необработанный тип следующим образом:

Необработанные типы JLS 4.8

A Необработанный тип определяется как один из:

• Ссылочный тип, который формируется путем взятия имени объявления универсального типа без сопутствующего списка аргументов типа.

• Тип массива, элемент которого является необработанным типом.

• Не статический тип-член необработанного типа 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 - это параметризованный тип ( JLS 4.5 ). В просторечии этот тип обычно называют просто MyType для краткости, но технически он называется MyType .

mt имеет необработанный тип (и генерирует предупреждение компиляции) первым маркером в приведенном выше определении; inn также имеет необработанный тип по третьему пункту маркера.

MyType.Nested не является параметризованным типом, хотя это тип-член параметризованного типа MyType , поскольку он статический .

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 , вы могли по-прежнему использовать необработанный тип и вручную проверять каждые добавьте самостоятельно, а затем вручную приведите к String для каждого элемента из имен . Еще лучше , хотя НЕ использовать необработанный тип и позволить компилятору делать всю работу за вас , используя всю мощь дженериков Java.

List<String> names = new ArrayList<String>();
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // compilation error!

Конечно, если вы DO хотите, чтобы имена разрешали логическое значение , то вы можете объявить его как List