---

🟢 Junior Level

Дженерики (Generics, обобщения) — это механизм языка Java, позволяющий параметризовать классы, интерфейсы и методы типами данных. Они появились в Java 5 (JSR 14).

До Java 5 все коллекции хранили элементы как java.lang.Object. Это порождало две критические проблемы:

1. Необходимость явного ручного приведения типов (cast).
2. Риск получить фатальную ошибку ClassCastException в рантайме, если в коллекцию случайно положили объект другого типа.

// До Java 5 (без дженериков):
List list = new ArrayList();
list.add("Hello");
list.add(42); // Ошибки компиляции нет!

String s1 = (String) list.get(0); // Нужен явный cast
String s2 = (String) list.get(1); // 💥 ClassCastException во время исполнения!

// С дженериками (Java 5+):
List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(42); // ❌ Ошибка компиляции: несовместимый тип Integer!

String s = list.get(0); // Без приведения типов, 100% безопасно

Три главных преимущества дженериков

1. Типобезопасность на этапе компиляции (Compile-time Type Safety): ошибки несовместимости типов обнаруживаются при сборке проекта, а не в продакшене.
2. Устранение явного приведения типов (Elimination of Casts): компилятор сам знает тип элементов и вставляет проверочные инструкции за вас.
3. Переиспользование алгоритмов (Code Reusability): один и тот же алгоритм (сортировка, стек, дерево, репозиторий) работает с любыми типами данных.

---

🟡 Middle Level

1. Анатомия параметров типов (Type Parameters)

При объявлении дженерик-типов используются общепринятые конвенции именования однобуквенных плейсхолдеров:

• T — Type (тип общего назначения).
• E — Element (элемент коллекции, например List<E>).
• K, V — Key, Value (ключ и значение в Map<K, V>).
• N — Number (числовой тип).
• R — Result (возвращаемый тип функции).

// Параметризованный класс:
public class Box<T> {
    private T value;

    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// Параметризованный интерфейс:
public interface Repository<T, ID> {
    Optional<T> findById(ID id);
    T save(T entity);
}

// Обобщенный метод (Generic Method):
public static <T> List<T> fromArrayToList(T[] array) {
    return Arrays.stream(array).toList();
}

2. Ограничения типов (Bounded Type Parameters)

Вы можете ограничить диапазон допустимых типов сверху ключевым словом extends (работает и для классов, и для интерфейсов):

// Разрешены только Number и его наследники (Integer, Double, BigDecimal):
public class Stats<T extends Number> {
    private final List<T> numbers;

    public Stats(List<T> numbers) { this.numbers = numbers; }

    public double average() {
        double sum = 0.0;
        for (T n : numbers) {
            sum += n.doubleValue(); // Метод doubleValue() доступен благодаря bound!
        }
        return sum / numbers.size();
    }
}

3. Инвариантность дженериков (Invariance)

[!IMPORTANT] Если String является подтипом Object, это НЕ значит, что List<String> является подтипом List<Object>. Дженерики в Java строго инвариантны.

List<String> strings = new ArrayList<>();
// List<Object> objects = strings; // ❌ Ошибка компиляции!

Почему это запрещено? Если бы такое присваивание компилировалось, вы могли бы через ссылку objects выполнить objects.add(12345);, и при чтении из strings.get(0) произошел бы сбой типов.

Для реализации гибкого полиморфизма в дженериках используются wildcards (? extends T и ? super T).

---

🔴 Senior Level

Стирание типов (Type Erasure) и почему JVM не знает о дженериках

Создатели Java (во главе с Мартином Одерски и Джеймсом Гослингом) при внедрении дженериков в Java 5 стояли перед дилеммой:

1. Реификация (Monomorphization / Reification) (как в C++ или C#): виртуальная машина знает типы в рантайме и создает отдельную структуру метаданных под каждую инстанциацию (List<String> и List<Integer> — разные типы в памяти).
2. Стирание типов (Type Erasure): компилятор проверяет типы, а затем стирает их, заменяя на их базовую границу (Object или верхний bound) и вставляя байткод-инструкцию checkcast.

Был выбран подход со стиранием типов ради обратной совместимости (Migration Compatibility): старый скомпилированный код на Java 1.4 должен был без проблем взаимодействовать с новым дженерик-кодом Java 5 в рамках одной JVM.

Байткод до и после стирания:

// Исходный код:
public class Holder<T extends Number> {
    private T value;
    public T getValue() { return value; }
}

// Что видит JVM после компиляции:
public class Holder {
    private Number value; // T стерт до Number!
    public Number getValue() { return value; }
}

Мостовые методы (Bridge Methods)

Когда класс наследуется от параметризованного предка и фиксирует конкретный тип, компилятор синтезирует специальный мостовой метод (Bridge Method), чтобы сохранить полиморфизм виртуальных вызовов в таблице методов (vtable):

public class StringNode extends Node<String> {
    public void setData(String data) { ... }
    
    // Синтетический bridge-метод, генерируемый компилятором:
    // public void setData(Object data) {
    //     setData((String) data); // checkcast + вызов целевого метода
    // }
}

Где стирание типов НЕ стирает информацию (Reified Metadata)

Распространенное заблуждение: «В рантайме о дженериках ничего не известно».

Информация о параметрах стирается из исполняемого байткода методов, но сохраняется в сигнатуре класса (атрибут Signature в constant pool) для объявлений классов, полей и методов! Именно на этом основан паттерн TypeToken (Jackson TypeReference, Spring ResolvableType, Gson TypeToken):

// Создавая анонимный подкласс, мы фиксируем генерик-тип в метаданных класса:
TypeReference<List<User>> typeRef = new TypeReference<>() {};
Type type = ((ParameterizedType) typeRef.getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
System.out.println(type); // java.util.List<User> — доступно в runtime через reflection!

---

4 Tricky Questions

1. Почему дженерики в Java реализовали через стирание типов (Type Erasure), а не через овеществление (Reification), как в C# или C++?

Ответ: Главной причиной было требование абсолютной бинарной обратной совместимости (Migration Compatibility).

В 2004 году миллионы строк корпоративного кода работали на Java 1.4 с сырыми типами (java.util.List). При реализации через Reification (как в C#) старые библиотеки перестали бы работать без полной перекомпиляции и переписывания, а смешивание старого и нового кода приводило бы к ошибкам линковки. Стирание типов позволило запускать новый дженерик-код на старых версиях библиотек и гарантировало, что List<String> и List<Integer> имеют в рантайме один и тот же List.class.

Обратная сторона этого решения — невозможность создать new T(), new T[], выполнить instanceof T и накладные расходы на автобоксинг примитивов.

2. Если типы стираются при компиляции, откуда Jackson, Spring и Gson знают, в какой тип десериализовать List<User>?

Ответ: Стирание типов удаляет информацию из локальных переменных и экземпляров объектов, но компилятор javac обязан сохранять обобщенные сигнатуры в атрибуте Signature байткода .class файла для полей, методов и определений классов.

Фреймворки используют трюк Нила Гафтера (Super Type Token): создается анонимный подкласс абстрактного класса (например, new TypeReference<List<User>>() {}). В этом случае параметризованный тип List<User> становится предком анонимного класса и навсегда записывается в метаданные его класса. В рантайме библиотека вызывает getClass().getGenericSuperclass(), кастует его к ParameterizedType и методом getActualTypeArguments() извлекает исходный класс User.

3. Почему массивы в Java ковариантны (String[] можно присвоить Object[]), а коллекции с дженериками инвариантны (List<String> нельзя присвоить List<Object>)?

Ответ: Ковариантность массивов была введена в Java 1.0 (за 8 лет до дженериков) как вынужденный компромисс: без нее было невозможно написать универсальные утилитные методы сортировки или копирования массивов (Arrays.sort(Object[])). Однако ковариантность нарушает безопасность типов: если в Object[] arr = new String[5] положить arr[0] = 10;, произойдет ошибка времени исполнения ArrayStoreException.

Для дженериков авторы языка отказались от опасных рантайм-сбоев и сделали дженерики строго инвариантными. Безопасная ковариантность и контравариантность достигается через механизм wildcards: List<? extends Object> (ковариантность / чтение) и List<? super String> (контравариантность / запись).

4. Что такое Heap Pollution (загрязнение кучи) и к каким скрытым ошибкам оно приводит?

Ответ: Heap Pollution (загрязнение кучи) — это ситуация в JVM, когда переменная параметризованного типа (List<String>) ссылается на объект в памяти, фактический тип аргументов которого не соответствует объявленному (например, там лежит Integer).

Обычно возникает при смешивании дженериков с сырыми типами (raw types), некорректных приведениях типов или при работе с Generic Varargs (List<T>...). Опасность Heap Pollution заключается в том, что оно порождает отложенные баги: присваивание проходит без ошибок, а исключение ClassCastException выбрасывается позже — в совершенно безопасном на вид месте при обычном чтении из коллекции (String s = list.get(0)), где в исходном коде даже нет операции явного каста!

---

🎯 Шпаргалка для интервью

Главное о Generics в Java

• Появились: Java 5 (JSR 14) для compile-time type safety и устранения явного приведения типов (cast).
• Модель исполнения: Type Erasure (Стирание типов). В рантайме List<String> и List<Integer> превращаются в один и тот же List.class, а тип $T$ стирается до своей границы (верхнего bound или Object).
• Инвариантность: List<String> не является подтипом List<Object>. Для вариативности используются wildcards (? extends / ? super).
• Reified vs Non-Reified: Примитивы и массивы овеществлены (хранят тип в заголовке), дженерики не овеществлены (non-reified).
• Чего нельзя:
  • new T() и new T[].
  • instanceof List<String> (разрешен только instanceof List<?>).
  • Использовать примитивы (List<int> запрещен, нужен List<Integer>).
  • Статические поля с параметром типа класса (static T field).
• Где типы сохраняются: Метаданные полей, методов и суперклассов сохраняются в атрибуте Signature байткода (Super Type Tokens / Jackson TypeReference).

Связанные темы

• В чём преимущества использования дженериков
• Что такое type erasure (стирание типов)
• Что такое bounded type parameters
• Можно ли использовать примитивные типы как параметры дженериков
• Что такое bridge methods и зачем они нужны