🟢 Junior Level

Дженерики дают три главных преимущества:

1. Безопасность типов — ошибки ловятся на этапе компиляции, а не в runtime
2. Не нужен cast — код чище и безопаснее
3. Переиспользование кода — один класс работает с разными типами

// ❌ Без дженериков (до Java 5)
List list = new ArrayList();
list.add("Hello");
list.add(42);  // компилятор не ругается, но это баг!
String s = (String) list.get(1);  // ClassCastException в runtime!

// ✅ С дженериками
List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(42);  // ошибка компиляции — тип защищён!
String s = list.get(0);  // без cast!

---

🟡 Middle Level

Детальные преимущества

1. Compile-time type safety:

// Ошибка обнаруживается до запуска
List<User> users = new ArrayList<>();
users.add(new User());
// users.add("string");  // compilation error — сразу видно проблему

2. Elimination of casts:

// Без дженериков
Map map = new HashMap();
map.put("key", "value");
String value = (String) map.get("key");  // cast нужен

// С дженериками
Map<String, String> map = new HashMap<>();
map.put("key", "value");
String value = map.get("key");  // без cast

3. Generic алгоритмы:

// Один метод для любого типа
public static <T> void swap(List<T> list, int i, int j) {
    T temp = list.get(i);
    list.set(i, list.get(j));
    list.set(j, temp);
}

swap(users, 0, 1);       // T = User
swap(strings, 0, 1);     // T = String
swap(integers, 0, 1);    // T = Integer

4. Специализация через bounds:

// Работаем только с Comparable типами
public static <T extends Comparable<T>> T max(List<T> list) {
    return list.stream().max(Comparable::compareTo).orElse(null);
}

max(List.of(3, 1, 4, 1, 5));  // 5
max(List.of("c", "a", "b"));  // "c"

Типичные ошибки

1. Игнорирование warning: ```java // ⚠️ Unchecked cast warning List list = (List) someRawList;

// Лучше — избегать raw types

2. **Смешивание generic и raw:**
```java
List<String> typed = new ArrayList<>();
List raw = typed;  // raw type — теряется безопасность
raw.add(42);       // компилятор не ругается

---

🔴 Senior Level

Internal Implementation

Type Erasure преимущества:

1. Бинарная совместимость — Java 5 код работает с Java 1.4 библиотеками
2. Zero runtime overhead — никаких дополнительных проверок
3. Нет дополнительных данных в памяти

Bridge methods:

public class Node<T extends Comparable<T>> {
    private T data;
    public T getData() { return data; }
}

public class StringNode extends Node<String> {
    @Override
    public String getData() { return super.getData(); }
}

// После erasure компилятор создаёт bridge method:
// public Object getData() { return this.getData(); } // вызывает String getData()
// Это bridge method — сохраняет полиморфизм после type erasure.

Архитектурные Trade-offs

Дженерики vs альтернативы:

Подход	Плюсы	Минусы
Дженерики	Type safety, переиспользование	Type erasure ограничения
Object	Простота	Cast, runtime ошибки
Кодогенерация	Полная типизация	Больше кода

Edge Cases

1. Generic varargs:

// ⚠️ Heap pollution warning
@SafeVarargs
public static <T> void printAll(List<T>... lists) {
    for (List<T> list : lists) {
        System.out.println(list);
    }
}

2. Generic exception:

// ❌ Нельзя параметризовать Throwable
public class GenericException<T> extends Exception {}  // error

// ✅ Generic метод может бросать исключения
public static <T extends Exception> void rethrow(Exception e) throws T {
    throw (T) e;
}

Производительность

Дженерики:
- Runtime: Zero overhead (type erasure)
- Memory: Нет дополнительных данных
- Cast: Неявные cast (negligible)

С дженериками vs без:
- Compile time: чуть дольше (проверка типов)
- Runtime: одинаково
- Безопасность: значительно выше

Production Experience

Type-safe Builder:

public class QueryBuilder<T> {
    private final Class<T> resultType;
    private String sql;
    private final Map<String, Object> params = new HashMap<>();
    
    public QueryBuilder(Class<T> resultType) {
        this.resultType = resultType;
    }
    
    public QueryBuilder<T> sql(String sql) {
        this.sql = sql;
        return this;
    }
    
    public QueryBuilder<T> param(String name, Object value) {
        params.put(name, value);
        return this;
    }
    
    public List<T> execute() {
        // type-safe execution
        return jdbcTemplate.query(sql, params, resultType);
    }
}

// Использование
List<User> users = new QueryBuilder<>(User.class)
    .sql("SELECT * FROM users WHERE age > :age")
    .param("age", 18)
    .execute();

Best Practices

// ✅ Generic методы для переиспользования
public static <T> Optional<T> first(List<T> list, Predicate<T> predicate) {
    return list.stream().filter(predicate).findFirst();
}

// ✅ Bounded types
public static <T extends Comparable<T>> void sort(List<T> list) { }

// ✅ Wildcards для flexibility (PECS)
public void process(List<? extends Number> numbers) { }

// ❌ Raw types
// ❌ Unchecked casts без необходимости
// ❌ Игнорирование compiler warnings

---

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

Обязательно знать:

• Compile-time type safety — ошибки типов ловятся до запуска программы
• Elimination of casts — не нужен явный cast при получении из коллекции
• Code reuse — один generic класс работает с любым типом
• Type erasure = zero runtime overhead, бинарная совместимость с Java 1.4
• Bridge methods сохраняют полиморфизм после type erasure
• Generic алгоритмы: swap, max, filter работают с любым типом

Частые уточняющие вопросы:

• Какое главное преимущество дженериков? — Type safety на компиляции + отсутствие cast
• Есть ли runtime overhead? — Нет, type erasure = zero overhead в runtime
• Что такое bridge methods? — Синтетические методы для сохранения полиморфизма после erasure
• Можно ли generic exception? — Нет, class GenericException<T> extends Exception — ошибка

Красные флаги (НЕ говорить):

• ❌ “Дженерики замедляют программу” — Zero runtime overhead
• ❌ “Raw types — это нормально в новом коде” — Raw types отключают все проверки типов
• ❌ “Дженерики создают дополнительные объекты” — Никаких дополнительных аллокаций
• ❌ “Generic varargs всегда безопасны” — Heap pollution возможен, нужна @SafeVarargs

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

• [[11. Что такое дженерики (Generics) в Java]]
• [[13. Что такое type erasure (стирание типов)]]
• [[17. Что такое PECS (Producer Extends Consumer Super)]]
• [[19. Что такое raw types и почему их следует избегать]]