Введение
Начиная с JSE 5.0 в арсенал языка Java были добавлены дженерики.
Что такое дженерики в Java?
Дженерики (обобщения) — это особые средства языка Java для реализации обобщённого программирования: особого подхода к описанию данных и алгоритмов, позволяющего работать с различными типами данных без изменения их описания. На сайте Oracle дженерикам посвящён отдельный tutorial: "Lesson: Generics".
import java.util.*;
public class HelloWorld{
public static void main(String []args){
List list = new ArrayList();
list.add("Hello");
String text = list.get(0) + ", world!";
System.out.print(text);
}
}
", world!". Казалось бы, что может быть безобиднее? Но на деле мы получим ошибку ПРИ КОМПИЛЯЦИИ:
error: incompatible types: Object cannot be converted to String
Всё дело в том, что в нашем случае List хранит список объектов типа Object. Так как String — наследник для Object (ибо все классы неявно наследуются в Java от Object), то требует явного приведения, чего мы не сделали. А при конкатенации для объекта будет вызван статический метод String.valueOf(obj), который в итоге вызовет метод toString для Object.
То есть List у нас содержит Object. Выходит, там где нам нужен конкретный тип, а не Object, нам придётся самим делать приведение типов:
import java.util.*;
public class HelloWorld{
public static void main(String []args){
List list = new ArrayList();
list.add("Hello!");
list.add(123);
for (Object str : list) {
System.out.println((String)str);
}
}
}
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
Согласитесь, не самое приятное.
И всё это потому, что компилятор — не искусcтвенный интеллект и он не может угадать всё, что подразумевает программист. Чтобы рассказать компилятору подробнее о своих намерениях, какие типы мы собираемся использовать, в Java SE 5 ввели дженерики.
Исправим наш вариант, подсказав компилятору, что же мы хотим:
import java.util.*;
public class HelloWorld {
public static void main(String []args){
List<String> list = new ArrayList<>();
list.add("Hello!");
list.add(123);
for (Object str : list) {
System.out.println(str);
}
}
}
Raw Types или сырые типы
Говоря о дженериках мы всегда имеем две категории: типизированные типы (Generic Types) и "сырые" типы (Raw Types). Сырые типы — это типы без указания "уточненения" в фигурных скобках (angle brackets):
<>
Также Diamond синтаксис связан с понятием "Type Inference", или же выведение типов. Ведь компилятор, видя справа <> смотрит на левую часть, где расположено объявление типа переменной, в которую присваивается значение. И по этой части понимает, каким типом типизируется значение справа.
На самом деле, если в левой части указан дженерик, а справа не указан, компилятор сможет вывести тип:
import java.util.*;
public class HelloWorld{
public static void main(String []args) {
List<String> list = new ArrayList();
list.add("Hello World");
String data = list.get(0);
System.out.println(data);
}
}
Note: HelloWorld.java uses unchecked or unsafe operations. На самом деле кажется непонятным, зачем вообще нужен тут diamond добавлять. Но вот пример:
import java.util.*;
public class HelloWorld{
public static void main(String []args) {
List<String> list = Arrays.asList("Hello", "World");
List<Integer> data = new ArrayList(list);
Integer intNumber = data.get(0);
System.out.println(data);
}
}
@SuppressWarnings("unchecked")
Suppress переводится как подавлять, то есть дословно — подавить предупреждения. Но подумайте, почему вы решили её указать? Вспомните о правиле номер один и, возможно, вам нужно добавить типизацию.
Типизированные методы (Generic Methods)
Дженерики позволяют типизировать методы. Данной возможности в tutorial от Oracle посвящен отдельный раздел: "Generic Methods". Из данного tutorial важно запомнить про синтаксис:- включает список типизированных параметров внутри угловых скобок;
- список типизированных параметров идёт до возвращаемого метода.
import java.util.*;
public class HelloWorld{
public static class Util {
public static <T> T getValue(Object obj, Class<T> clazz) {
return (T) obj;
}
public static <T> T getValue(Object obj) {
return (T) obj;
}
}
public static void main(String []args) {
List list = Arrays.asList("Author", "Book");
for (Object element : list) {
String data = Util.getValue(element, String.class);
System.out.println(data);
System.out.println(Util.<String>getValue(element));
}
}
}
Util.<Integer>getValue(element, String.class) упадёт с ошибкой incompatible types: Class<String> cannot be converted to Class<Integer>.
При использовании типизированных методов стоит всегда помнить про стирание типов. Посмотрим на пример:
import java.util.*;
public class HelloWorld {
public static class Util {
public static <T> T getValue(Object obj) {
return (T) obj;
}
}
public static void main(String []args) {
List list = Arrays.asList(2, 3);
for (Object element : list) {
System.out.println(Util.<Integer>getValue(element) + 1);
}
}
}
System.out.println(Util.getValue(element) + 1);
И мы получим ошибку: bad operand types for binary operator '+', first type: Object , second type: int
То есть произошло стирание типов. Компилятор видит, что тип никто не указал, тип указывается как Object и выполнение кода падает с ошибкой.
Типизированные классы (Generic Types)
Типизировать можно не только методы, но и сами классы. У Oracle в их гайде этому посвящён раздел "Generic Types". Рассмотрим пример:
public static class SomeType<T> {
public <E> void test(Collection<E> collection) {
for (E element : collection) {
System.out.println(element);
}
}
public void test(List<Integer> collection) {
for (Integer element : collection) {
System.out.println(element);
}
}
}
public static void main(String []args) {
SomeType<String> st = new SomeType<>();
List<String> list = Arrays.asList("test");
st.test(list);
}
SomeType st = new SomeType();
List<String> list = Arrays.asList("test");
st.test(list);
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
Опять стирание типов. Поскольку у класса больше нет дженерика, компилятор решает: раз мы передали List, метод с List<Integer> более подходящий. И мы падаем с ошибкой.
Поэтому, правило #2: Если класс типизирован, всегда указывать тип в дженерике.
Ограничения
К типам, указываемым в дженериках мы можем применить ограничение. Например, мы хотим, чтобы контейнер принимал на вход только Number. Данная возможность описана в Oracle Tutorial в разделе Bounded Type Parameters. Посмотрим на пример:
import java.util.*;
public class HelloWorld{
public static class NumberContainer<T extends Number> {
private T number;
public NumberContainer(T number) { this.number = number; }
public void print() {
System.out.println(number);
}
}
public static void main(String []args) {
NumberContainer number1 = new NumberContainer(2L);
NumberContainer number2 = new NumberContainer(1);
NumberContainer number3 = new NumberContainer("f");
}
}
public static class NumberContainer<T extends Number & Comparable> {
Ещё у дженериков есть понятие Wildcard https://docs.oracle.com/javase/tutorial/java/generics/wildcards.html
Они в свою очередь делятся на три типа:
- Upper Bounded Wildcards - <? extends Number>
- Unbounded Wildcards - <?>
- Lower Bounded Wildcards - <? super Integer>
public static class TestClass {
public static void print(List<? extends String> list) {
list.add("Hello World!");
System.out.println(list.get(0));
}
}
public static void main(String []args) {
List<String> list = new ArrayList<>();
TestClass.print(list);
}
Наследование
Есть ещё одна необычная особенность дженериков - это их наследование. Наследование дженериков описано в tutorial от Oracle в разделе "Generics, Inheritance, and Subtypes". Главное это запомнить и осознать следующее. Мы не можем сделать так:
List<CharSequence> list1 = new ArrayList<String>();
List<String> list1 = new ArrayList<>();
List<Object> list2 = list1;
Final
Вот мы и освежили в памяти дженерики. Если их редко использовать во всей их мощи, какие-то детали выпадают из памяти. Надеюсь, данный небольшой обзор поможет освежить в памяти. А для большего результата настоятельно рекомендую ознакомиться со следующими материалами:- Юрий Ткач: Сырые типы - Generics #1 - Advanced Java
- Наследование и расширители обобщений - Generics #2 - Advanced Java
- Рекурсивное расширение типа - Generics #3 - Advanced Java
- Александр Маторин — Неочевидные Дженерики
- Введение в Java. Generics. Wildcards | Технострим
- O'Reilly : Java Generics and Collections
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ