🟢 Junior Level

Generics give three main advantages:

1. Type safety — errors are caught at compile time, not at runtime
2. No cast needed — code is cleaner and safer
3. Code reuse — one class works with different types

// ❌ Without generics (before Java 5)
List list = new ArrayList();
list.add("Hello");
list.add(42);  // compiler doesn't complain, but this is a bug!
String s = (String) list.get(1);  // ClassCastException at runtime!

// ✅ With generics
List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(42);  // compilation error — type is protected!
String s = list.get(0);  // no cast!

---

🟡 Middle Level

Detailed Advantages

1. Compile-time type safety:

// Error is discovered before running
List<User> users = new ArrayList<>();
users.add(new User());
// users.add("string");  // compilation error — problem is found immediately

2. Elimination of casts:

// Without generics
Map map = new HashMap();
map.put("key", "value");
String value = (String) map.get("key");  // cast needed

// With generics
Map<String, String> map = new HashMap<>();
map.put("key", "value");
String value = map.get("key");  // no cast

3. Generic algorithms:

// One method for any type
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. Specialization via bounds:

// Works only with Comparable types
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"

Common Mistakes

1. Ignoring warnings: ```java // ⚠️ Unchecked cast warning List list = (List) someRawList;

// Better — avoid raw types

2. **Mixing generic and raw:**
```java
List<String> typed = new ArrayList<>();
List raw = typed;  // raw type — type safety is lost
raw.add(42);       // compiler doesn't complain

---

🔴 Senior Level

Internal Implementation

Type Erasure advantages:

1. Binary compatibility — Java 5 code works with Java 1.4 libraries
2. Zero runtime overhead — no additional checks
3. No extra data in memory

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(); }
}

// After erasure the compiler creates a bridge method:
// public Object getData() { return this.getData(); } // calls String getData()
// This is a bridge method — it preserves polymorphism after type erasure.

Architectural Trade-offs

Generics vs alternatives:

Approach	Pros	Cons
Generics	Type safety, reusability	Type erasure limitations
Object	Simplicity	Cast, runtime errors
Code generation	Full typing	More code

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:

// ❌ Cannot parameterize Throwable
public class GenericException<T> extends Exception {}  // error

// ✅ Generic method can throw exceptions
public static <T extends Exception> void rethrow(Exception e) throws T {
    throw (T) e;
}

Performance

Generics:
- Runtime: Zero overhead (type erasure)
- Memory: No extra data
- Cast: Implicit casts (negligible)

With generics vs without:
- Compile time: slightly longer (type checking)
- Runtime: identical
- Safety: significantly higher

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);
    }
}

// Usage
List<User> users = new QueryBuilder<>(User.class)
    .sql("SELECT * FROM users WHERE age > :age")
    .param("age", 18)
    .execute();

Best Practices

// ✅ Generic methods for reusability
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 for flexibility (PECS)
public void process(List<? extends Number> numbers) { }

// ❌ Raw types
// ❌ Unchecked casts without necessity
// ❌ Ignoring compiler warnings

---

🎯 Interview Cheat Sheet

Must know:

• Compile-time type safety — type errors are caught before program runs
• Elimination of casts — no explicit cast needed when getting from collection
• Code reuse — one generic class works with any type
• Type erasure = zero runtime overhead, binary compatibility with Java 1.4
• Bridge methods preserve polymorphism after type erasure
• Generic algorithms: swap, max, filter work with any type

Common follow-up questions:

• What is the main advantage of generics? — Type safety at compile time + no casts
• Is there runtime overhead? — No, type erasure = zero overhead at runtime
• What are bridge methods? — Synthetic methods to preserve polymorphism after erasure
• Can you have generic exception? — No, class GenericException<T> extends Exception — error

Red flags (DO NOT say):

• ❌ “Generics slow down the program” — Zero runtime overhead
• ❌ “Raw types are fine in new code” — Raw types disable all type checking
• ❌ “Generics create additional objects” — No additional allocations
• ❌ “Generic varargs are always safe” — Heap pollution is possible, need @SafeVarargs

Related topics:

• [[11. What are Generics in Java]]
• [[13. What is type erasure]]
• [[17. What is PECS (Producer Extends Consumer Super)]]
• [[19. What are raw types and why should you avoid them]]