Generics

Why generics exist

Before generics, collections held Object and you cast on every read. A wrong cast only failed at runtime.

With List<String> the compiler checks every add and get, and inserts the casts for you. Type arguments must be reference types, so use Integer, not int.

Example

Why generics exist

List<String> names = new ArrayList<>();
names.add("Asha");
// names.add(42);        // compile error
String first = names.get(0); // no cast

Generic classes and methods

A class declares type parameters in angle brackets: class Box<T>. A method can declare its own, placed before the return type.

Use bounds to require capabilities. <T extends Comparable<T>> means T can be compared with itself. Multiple bounds use &, with a class first.

Example

Generic classes and methods

static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}
int m = max(3, 7);   // T inferred as Integer

Invariance and wildcards

List<String> is not a List<Object>, even though String is an Object. If it were, you could add an Integer through the Object view.

Wildcards add flexibility. ? extends T is for reading (producer), ? super T is for writing (consumer). This is PECS. With List<?> you can read Objects but only add null.

Example

Invariance and wildcards

static double sum(List<? extends Number> xs) {
    double t = 0;
    for (Number n : xs) t += n.doubleValue();
    return t;
}
static void fill(List<? super Integer> out) {
    out.add(1);
}

Type erasure

The compiler checks generics, then erases them. A type parameter becomes its leftmost bound, or Object, and casts are inserted where needed. At runtime List<String> and List<Integer> are both just ArrayList.

Bridge methods keep overriding working after erasure, for example when you implement Comparable<Person>.

Example

Type erasure

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass() == b.getClass()); // true

What erasure forbids

Since T does not exist at runtime, you cannot write new T(), new T[n], or x instanceof T. You also cannot overload two methods that differ only by type argument, or declare a generic subclass of Throwable.

Workarounds: pass a Class<T> or Supplier<T>, use ArrayList<T> instead of T[], and use List<?> in instanceof checks.

Raw types and heap pollution

A raw type such as List switches generic checks off. Mixing raw and generic code can put the wrong object behind List<String> (heap pollution).

The failure then appears later as a ClassCastException at an inserted cast, far from the real bug. Treat unchecked warnings as bugs, and use @SafeVarargs only on methods that cannot be overridden.