Что такое Generics (обобщения) в Java?

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

А зачем это, спрашивается, вообще нужно? Представьте себе, блядь, древние времена, до нашей эры Java. Коллекции тогда были как общий котёл, куда можно было сунуть что угодно: и строку, и число, и свою старую потрёпанную тапку. А потом, когда достаёшь, надо было угадать, что там лежит, и кастовать как угадал. И если ошибся — бац! — тебе в лоб ClassCastException прямо во время работы программы. Пиздец, короче. Абсолютный бардак.

Generics пришли и сказали: "Хуй вам, а не бардак!". Теперь ты компилятору прямо в глаза говоришь, что в этой коробке будут только строки, а в той — только числа. И он, такой бдительный страж, следит за этим. Попробуй сунуть не то — он тебя нахуй пошлёт ещё на этапе компиляции, даже запустить не даст. Красота!

Смотрите, как это было и стало:

// Старый, дедовский, опасный способ. Как ходить по минному полю.
List list = new ArrayList(); // Коробка для всего подряд.
list.add("hello"); // Кинул строку.
String s = (String) list.get(0); // Достал, молишься, что там строка, и кастуешь. Авось пронесёт.

// Новый, цивилизованный, безопасный способ. Как по асфальту с перилами.
List<String> strings = new ArrayList<>(); // Чётко сказал: коробка ТОЛЬКО для строк!
strings.add("hello"); // Кинул строку — ок.
String s = strings.get(0); // Достал — и никакого каста! Компилятор уже всё знает.
// strings.add(123); // Попробуй кинуть число — получишь по рукам СРАЗУ. Ошибка компиляции, идиот.

А теперь главные фишки, без которых нихуя не понять:

1. Type Erasure (Стирание типов). Вот это, блядь, самый важный и хитрый момент. Вся эта красивая типизация (List<String>, List<Integer>) существует ТОЛЬКО для компилятора, чтобы он нас ругал. А когда код компилируется, эта информация выкидывается нахуй. В байт-коде остаются просто сырые List и Object. Поэтому во время выполнения ты не можешь спросить у списка: "А ты, сука, какого типа?" — он тебе нихуя не ответит. Вся безопасность — только на этапе компиляции.

2. Ограничения (Bounds). Это когда ты говоришь: "Окей, тип может быть любой, но чтоб не абы какой, а чтоб из определённой семьи". Например, только числа.

   // Смотрите, какая хитрая жопа: T может быть чем угодно, но только если это Number или его ребёнок (Integer, Double).
   public <T extends Number> void process(T number) { ... }
   // process(new Integer(5)) — можно.
   // process(new String("abc")) — нельзя, получишь в табло ошибкой.

3. Wildcards (Вопросики, '?'). А это когда тебе похуй на конкретный тип, но ты хочешь работать с коллекцией аккуратно. "Дай мне список, я не знаю чего, но я только посмотрю".

   public void printList(List<?> list) {
       for (Object elem : list) { // Внутри всё равно Object, потому что тип неизвестен.
           System.out.println(elem);
       }
       // list.add(new Object()); // А вот добавить нихуя нельзя! Потому что компилятор не знает, что там должно лежать.
   }

Итог, ёпта: Generics — это охуенно. Это безопасность, это переиспользуемость кода (один метод на много типов), и это читаемость. Ты глянул на Map<String, List<Integer>> и сразу, блядь, понимаешь, что это не просто какая-то хрень, а конкретная структура. Главное — помнить про стирание, а то будешь как дурак тыкаться в runtime и удивляться, почему рефлексия не видит твоих <String>.