Level 2 · 20 min

Generics in OOP

Generics provide compile-time type safety and eliminate the need for explicit casts. Java generics use type erasure — generic type information is removed at compile time — which has implications for reflection and certain patterns.

Generics and Type Safety

Without generics: List list = new ArrayList(); list.add('hello'); String s = (String) list.get(0) — cast can fail at runtime. With generics: List<String> list = new ArrayList<>() — the compiler guarantees the list only contains Strings. ClassCastException becomes a compile error. Generic methods: <T extends Comparable<T>> T max(T a, T b) — works for any Comparable type.

Type Erasure

Java generics use erasure — at runtime, List<String> and List<Integer> are both just List. The generic type T is erased to Object (or to the bound if bounded). This means: you cannot use T in instanceof checks, you cannot create new T(), and List<String>.class doesn't exist — only List.class. Erasure is the reason Java's generics are sometimes called 'fake generics' compared to C#.

Wildcards and PECS

PECS: Producer Extends, Consumer Super. List<? extends Shape> produces Shapes — you can read Shapes from it but not write (type unknown). List<? super Circle> consumes Circles — you can write Circles into it but reading gives Object. Bounded type parameters: <T extends Comparable<T>> means T must implement Comparable. Useful for algorithms that need to compare elements. Bloch's Item 31 (Effective Java) formalizes PECS with a stack example: pushAll(Iterable<? extends E> src) — the source is a producer of E, so extends applies; popAll(Collection<? super E> dst) — the destination is a consumer of E, so super applies. Bloch's rule of thumb: "For maximum flexibility, use wildcard types on input parameters that represent producers or consumers. Do not use wildcard types as return types" — doing so forces clients to use wildcards in their own code. Collections.sort(List<T>, Comparator<? super T>) is the canonical example from the JDK: a Comparator<Object> can sort a List<String> because Object is a supertype of String.

Key Takeaways

Generics provide compile-time type safety — prefer them over Object + cast.
Type erasure: List<String> and List<Integer> are the same class at runtime — cannot use instanceof with generics.
PECS: extends for reading (producer), super for writing (consumer).

Code example

// Generic stack with type safety
class Stack<T> {
  private final Deque<T> storage = new ArrayDeque<>();
  void push(T item) { storage.push(item); }
  T pop() { return storage.pop(); }
  T peek() { return storage.peek(); }
}

// Generic method: works for any Comparable
<T extends Comparable<T>> T max(List<T> list) {
  return list.stream().max(Comparator.naturalOrder()).orElseThrow();
}

// PECS: copy from producer to consumer
<T> void copy(List<? extends T> source, List<? super T> destination) {
  for (T item : source) destination.add(item);
}
// copy(List<Integer>, List<Number>) — Number is super of Integer