Отсутствие необходимости в приведении типов - одно из самых больших преимуществ дженериков Java , поскольку оно выполняет проверку типов во время компиляции. Это уменьшит вероятность того, что ClassCastExceptions может быть брошено во время выполнения, и может привести к более надежному коду.
Но я подозреваю, что вы это прекрасно знаете.
Каждый раз, когда я смотрю на Generics, у меня болит голова. Я считаю, что лучшая часть Java - это простота и минимальный синтаксис, а обобщения не просты и добавляют значительное количество нового синтаксиса.
Поначалу я тоже не видел пользы от дженериков. Я начал изучать Java с синтаксиса 1.4 (хотя Java 5 в то время не существовала), и когда я столкнулся с дженериками, я почувствовал, что это нужно писать больше кода, и я действительно не понимал преимуществ.
Современные IDE упрощают написание кода с использованием универсальных шаблонов.
Большинство современных достойных IDE достаточно умны, чтобы помочь с написанием кода с помощью обобщений, особенно с автозавершением кода.
Вот пример создания файла Map<String, Integer>с расширением HashMap. Мне нужно было ввести следующий код:
Map<String, Integer> m = new HashMap<String, Integer>();
И действительно, это много для того, чтобы просто создать новый HashMap. Однако на самом деле мне нужно было набрать столько, прежде чем Eclipse узнал, что мне нужно:
Map<String, Integer> m = new Ha Ctrl+Space
Да, мне действительно нужно было выбрать HashMapиз списка кандидатов, но в основном среда IDE знала, что добавить, включая общие типы. С правильными инструментами использование дженериков не так уж и плохо.
Кроме того, поскольку типы известны, при извлечении элементов из общей коллекции среда IDE будет действовать так, как будто этот объект уже является объектом своего объявленного типа - нет необходимости выполнять приведение для среды IDE, чтобы узнать, какой тип объекта является.
Ключевое преимущество дженериков заключается в том, как они хорошо сочетаются с новыми функциями Java 5. Вот пример подбрасывания целых чисел в a Setи вычисления его суммы:
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);
int total = 0;
for (int i : set) {
total += i;
}
В этом фрагменте кода присутствуют три новые функции Java 5:
Во-первых, дженерики и автобокс примитивов позволяют использовать следующие строки:
set.add(10);
set.add(42);
Целое число 10автоматически упаковывается в объект Integerсо значением 10. (И то же самое для 42). Затем это Integerбросается в то, Setчто, как известно, содержит Integers. Попытка вставить Stringвызовет ошибку компиляции.
Далее, for-each цикл принимает все три из них:
for (int i : set) {
total += i;
}
Во-первых, Setсодержащие Integers используются в цикле for-each. Каждый элемент объявлен как объект, intи это разрешено, поскольку Integerон распаковывается обратно в примитив int. И тот факт, что происходит распаковка, известен, потому что для указания того, что они были Integerсохранены в Set.
Обобщения могут быть связующим звеном, которое объединяет новые функции, представленные в Java 5, и просто делает кодирование более простым и безопасным. И в большинстве случаев IDE достаточно умны, чтобы помочь вам с хорошими предложениями, так что, как правило, вам не нужно больше печатать.
И, честно говоря, как видно из Setпримера, я считаю, что использование функций Java 5 может сделать код более лаконичным и надежным.
Изменить - пример без дженериков
Ниже приводится иллюстрация приведенного выше Setпримера без использования дженериков. Возможно, но не совсем приятно:
Set set = new HashSet();
set.add(10);
set.add(42);
int total = 0;
for (Object o : set) {
total += (Integer)o;
}
(Примечание: приведенный выше код будет генерировать предупреждение о непроверенном преобразовании во время компиляции.)
При использовании неуниверсальных коллекций типы, которые вводятся в коллекцию, являются объектами типа Object. Следовательно, в этом примере a Object- это то, что addдобавляется в набор.
set.add(10);
set.add(42);
В приведенных выше строках задействован автобоксинг - примитивное intзначение 10и 42автоматически упаковываются в Integerобъекты, которые добавляются в Set. Однако имейте в виду, что Integerобъекты обрабатываются как Objects, так как нет информации о типе, которая помогала бы компилятору узнать, какой тип Setследует ожидать.
for (Object o : set) {
Это самая важная часть. Причина, по которой цикл for-each работает, заключается в том, что он Setреализует Iterableинтерфейс, который возвращает информацию о Iteratorтипе, если таковая имеется. ( Iterator<T>, то есть.)
Однако, поскольку информации о типе нет, Setбудет возвращен, Iteratorкоторый вернет значения в Setas Objects, и именно поэтому элемент, извлекаемый в цикле for-each, должен иметь тип Object.
Теперь, когда объект получен Objectиз Set, его необходимо Integerвручную преобразовать в объект, чтобы выполнить добавление:
total += (Integer)o;
Здесь выполняется приведение типа от an Objectк Integer. В этом случае мы знаем, что это всегда будет работать, но ручное приведение типов всегда заставляет меня думать, что это хрупкий код, который может быть поврежден, если незначительное изменение будет сделано в другом месте. (Я чувствую, что каждое приведение типов - это ClassCastExceptionожидание, но я отвлекаюсь ...)
IntegerТеперь Unboxed в intи разрешено выполнять добавление в intпеременной total.
Я надеюсь, что смогу проиллюстрировать, что новые функции Java 5 можно использовать с неуниверсальным кодом, но это не так чисто и прямо, как написание кода с помощью дженериков. И, на мой взгляд, чтобы в полной мере воспользоваться новыми функциями Java 5, следует обратить внимание на дженерики, если, по крайней мере, они допускают проверки во время компиляции, чтобы предотвратить недопустимые приведения типов для создания исключений во время выполнения.