Generic Types
A generic type is a generic class or interface that is parameterized over types. The following Box class will be modified to demonstrate the concept.
A Simple Box Class
Begin by examining a non-generic Box class that operates on objects of any type. It needs only to provide two methods: set, which adds an object to the box, and get, which retrieves it:
public class Box < private Object object; public void set(Object object) < this.object = object; >public Object get() < return object; >>
Since its methods accept or return an Object, you are free to pass in whatever you want, provided that it is not one of the primitive types. There is no way to verify, at compile time, how the class is used. One part of the code may place an Integer in the box and expect to get Integers out of it, while another part of the code may mistakenly pass in a String, resulting in a runtime error.
A Generic Version of the Box Class
A generic class is defined with the following format:
The type parameter section, delimited by angle brackets (<>), follows the class name. It specifies the type parameters (also called type variables) T1, T2, . and Tn.
To update the Box class to use generics, you create a generic type declaration by changing the code «public class Box» to «public class Box ". This introduces the type variable, T, that can be used anywhere inside the class.
With this change, the Box class becomes:
/** * Generic version of the Box class. * @param the type of the value being boxed */ public class Box < // T stands for "Type" private T t; public void set(T t) < this.t = t; >public T get() < return t; >>
As you can see, all occurrences of Object are replaced by T. A type variable can be any non-primitive type you specify: any class type, any interface type, any array type, or even another type variable.
This same technique can be applied to create generic interfaces.
Type Parameter Naming Conventions
By convention, type parameter names are single, uppercase letters. This stands in sharp contrast to the variable naming conventions that you already know about, and with good reason: Without this convention, it would be difficult to tell the difference between a type variable and an ordinary class or interface name.
The most commonly used type parameter names are:
- E - Element (used extensively by the Java Collections Framework)
- K - Key
- N - Number
- T - Type
- V - Value
- S,U,V etc. - 2nd, 3rd, 4th types
You'll see these names used throughout the Java SE API and the rest of this lesson.
Invoking and Instantiating a Generic Type
To reference the generic Box class from within your code, you must perform a generic type invocation, which replaces T with some concrete value, such as Integer:
You can think of a generic type invocation as being similar to an ordinary method invocation, but instead of passing an argument to a method, you are passing a type argument — Integer in this case — to the Box class itself.
Type Parameter and Type Argument Terminology: Many developers use the terms "type parameter" and "type argument" interchangeably, but these terms are not the same. When coding, one provides type arguments in order to create a parameterized type. Therefore, the T in Foo is a type parameter and the String in Foo f is a type argument. This lesson observes this definition when using these terms.
Like any other variable declaration, this code does not actually create a new Box object. It simply declares that integerBox will hold a reference to a "Box of Integer", which is how Box is read.
An invocation of a generic type is generally known as a parameterized type.
To instantiate this class, use the new keyword, as usual, but place between the class name and the parenthesis:
The Diamond
In Java SE 7 and later, you can replace the type arguments required to invoke the constructor of a generic class with an empty set of type arguments (<>) as long as the compiler can determine, or infer, the type arguments from the context. This pair of angle brackets, <>, is informally called the diamond. For example, you can create an instance of Box with the following statement:
For more information on diamond notation and type inference, see Type Inference.
Multiple Type Parameters
As mentioned previously, a generic class can have multiple type parameters. For example, the generic OrderedPair class, which implements the generic Pair interface:
public interface Pair < public K getKey(); public V getValue(); >public class OrderedPair implements Pair < private K key; private V value; public OrderedPair(K key, V value) < this.key = key; this.value = value; >public K getKey() < return key; >public V getValue() < return value; >>
The following statements create two instantiations of the OrderedPair class:
Pair p1 = new OrderedPair("Even", 8); Pair p2 = new OrderedPair("hello", "world"); The code, new OrderedPair , instantiates K as a String and V as an Integer. Therefore, the parameter types of OrderedPair's constructor are String and Integer, respectively. Due to autoboxing, it is valid to pass a String and an int to the class.
As mentioned in The Diamond, because a Java compiler can infer the K and V types from the declaration OrderedPair , these statements can be shortened using diamond notation:
OrderedPair p1 = new OrderedPair<>("Even", 8); OrderedPair p2 = new OrderedPair<>("hello", "world"); To create a generic interface, follow the same conventions as for creating a generic class.
Parameterized Types
You can also substitute a type parameter (that is, K or V) with a parameterized type (that is, List ). For example, using the OrderedPair example:
OrderedPairBox > p = new OrderedPair<>("primes", new Box(. )); Что такое дженерики в Java
Привет! Сегодня мы поговорим о дженериках. Надо сказать, что ты выучишь много нового! Дженерикам будет посвящена не только эта, но еще и несколько следующих лекций. Поэтому, если эта тема тебе интересна — тебе повезло: сегодня ты узнаешь многое об особенностях дженериков. Ну а если нет — смирись и расслабься! 🙂 Это очень важная тема, и знать ее нужно. Давай начнем с простого: «что» и «зачем». Что такое дженерики? Дженерики — это типы с параметром. При создании дженерика ты указываешь не только его тип, но и тип данных, с которыми он должен работать. Думаю, самый очевидный пример уже пришел тебе в голову — это ArrayList! Вот как мы обычно создаем его в программе:
import java.util.ArrayList; import java.util.List; public class Main < public static void main(String[] args) < ListmyList1 = new ArrayList<>(); myList1.add("Test String 1"); myList1.add("Test String 2"); > > Как нетрудно догадаться, особенность списка заключается в том, что в него нельзя будет «запихивать» все подряд: он работает исключительно с объектами String . Теперь давай сделаем небольшой экскурс в историю Java и попробуем ответить на вопрос: «зачем?». Для этого мы сами напишем упрощенную версию класса ArrayList. Наш список умеет только добавлять данные во внутренний массив и получать эти данные:
public class MyListClass < private Object[] data; private int count; public MyListClass() < this.data = new Object[10]; this.count = 0; >public void add(Object o) < this.data[count] = o; count++; >public Object[] getData() < return data; >> Допустим, мы хотим, чтобы наш список хранил только числа Integer . Дженериков у нас нет. Мы не можем явно указать проверку o instance of Integer в методе add() . Тогда весь наш класс будет пригоден только для Integer , и нам придется писать такой же класс для всех существующих в мире типов данных! Мы решаем положиться на наших программистов, и просто оставим в коде комментарий, чтобы они не добавляли туда ничего лишнего:
//use it ONLY with Integer data type public void add(Object o)
Один из программистов прозевал этот комментарий и попытался по невнимательности положить в список числа вперемешку со строками, а потом посчитать их сумму:
Вывод в консоль: 300 Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer at Main.main(Main.java:14) Что худшее в этой ситуации? Далеко не невнимательность программиста. Худшее то, что неправильный код попал в важное место нашей программы и успешно скомпилировался. Теперь мы увидим ошибку не на этапе написания кода, а только на этапе тестирования (и это в лучшем случае!). Исправление ошибок на более поздних этапах разработки стоит намного больше — и денег, и времени. Именно в этом заключается преимущество дженериков: класс-дженерик позволит незадачливому программисту обнаружить ошибку сразу же. Код просто не скомпилируется!
import java.util.ArrayList; import java.util.List; public class Main < public static void main(String[] args) < ListmyList1 = new ArrayList<>(); myList1.add(100); myList1.add(100); myList1.add("Lolkek");//ошибка! myList1.add("Shalala");//ошибка! > > Программист сразу «очухается» и моментально исправится. Кстати, нам не обязательно было создавать свой собственный класс- List , чтобы увидеть ошибку такого рода. Достаточно просто убрать скобки с указанием типа (
import java.util.ArrayList; import java.util.List; public class Main < public static void main(String[] args) < List list = new ArrayList(); list.add(100); list.add(200); list.add("Lolkek"); list.add("Shalala"); System.out.println((Integer) list.get(0) + (Integer) list.get(1)); System.out.println((Integer) list.get(2) + (Integer) list.get(3)); >> 
Вывод в консоль: 300 Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer at Main.main(Main.java:16) То есть даже используя «родные» средства Java, можно допустить такую ошибку и создать небезопасную коллекцию. Однако, если вставить этот код в IDEa, мы увидим предупреждение: “Unchecked call to add(E) as a member of raw type of java.util.List” Нам подсказывают, что при добавлении элемента в коллекцию без дженериков что-то может пойти не так. Но что значит фраза «raw type»? Дословный перевод будет вполне точным — «сырой тип» или «грязный тип». Raw type — это класс-дженерик, из которого удалили его тип. Иными словами, List myList1 — это Raw type . Противоположностью raw type является generic type — класс-дженерик (также известный как parameterized type ), созданный правильно, с указанием типа. Например, List myList1 . У тебя мог возникнуть вопрос: а почему в языке вообще позволено использовать raw types ? Причина проста. Создатели Java оставили в языке поддержку raw types чтобы не создавать проблем с совместимостью. К моменту выхода Java 5.0 (в этой версии впервые появились дженерики) было написано уже очень много кода с использованием raw types . Поэтому такая возможность сохраняется и сейчас. Мы уже не раз упоминали классическую книгу Джошуа Блоха «Effective Java» в лекциях. Как один из создателей языка, он не обошел в книге и тему использования raw types и generic types . Глава 23 этой книги носит весьма красноречивое название: «Не используйте raw types в новом коде» Это то, что нужно запомнить. При использовании классов-дженериков ни в коем случае не превращай generic type в raw type .
Типизированные методы
Java позволяет тебе типизировать отдельные методы, создавая так называемые generic methods. Чем такие методы удобны? Прежде всего тем, что позволяют работать с разными типами параметров. Если к разным типам можно безопасно применять одну и ту же логику, дженерик-метод будет отличным решением. Рассмотрим пример. Допустим, у нас есть какой-то список myList1 . Мы хотим удалить из него все значения, и заполнить все освободившиеся места новым значением. Вот так будет выглядеть наш класс с дженерик-методом:
public class TestClass < public static void fill(List list, T val) < for (int i = 0; i < list.size(); i++) list.set(i, val); >public static void main(String[] args) < Liststrings = new ArrayList<>(); strings.add("Старая строка 1"); strings.add("Старая строка 2"); strings.add("Старая строка 3"); fill(strings, "Новая строка"); System.out.println(strings); List numbers = new ArrayList<>(); numbers.add(1); numbers.add(2); numbers.add(3); fill(numbers, 888); System.out.println(numbers); > > public static void fill(List list, T val) Перед типом возвращаемого значения написано
Типизированные классы
Ты можешь не только пользоваться представленными в Java дженерик-классами, но и создавать собственные! Вот простой пример:
public class Box < private T t; public void set(T t) < this.t = t; >public T get() < return t; >public static void main(String[] args) < BoxstringBox = new Box<>(); stringBox.set("Старая строка"); System.out.println(stringBox.get()); stringBox.set("Новая строка"); System.out.println(stringBox.get()); stringBox.set(12345);//ошибка компиляции! > > Наш класс Box
И когда в последней строке кода мы пытаемся положить внутрь коробки число 12345, получаем ошибку компиляции! Вот так просто мы создали свой собственный дженерик-класс! 🙂 На этом наша сегодняшняя лекция подходит к концу. Но мы не прощаемся с дженериками! В следующий лекциях поговорим о более продвинутых возможностях, поэтому не прощаемся! ) Успехов в обучении! 🙂