Generics

• List<String> rejects add(42) at compile time
• get() returns String: no cast needed
• Type arguments are reference types: List<int> is illegal
• Use List<Integer>; autoboxing converts int values

• Generic class: parameter after the name
• Generic method: own parameter before the return type
• T is usually inferred from the arguments

class Box<T> { T val; }
static <T> T first(List<T> l) {
    return l.get(0);
}

first(names) infers T = String

• <T extends Comparable<T>> lets you call compareTo on T
• Multiple bounds use &, class first, then interfaces
• <T extends Number & Comparable<T>>

• Compiler checks types, then erases the type arguments
• T becomes its bound, or Object
• Casts are inserted at call sites
• List<String> and List<Integer> share List.class, so getClass() is equal

• Bridges keep overriding working after erasure

• new T(), new T[10], T.class: T is gone at runtime
• static T field: one static shared by every Box<X>
• catch (T e) and throw of T: illegal
• instanceof List<String> won't compile; use List<?> or plain List
• Overloads differing only by type argument share one erasure

void f(List<String> a) {}
void f(List<Integer> a) {}  // error

both erase to f(List): name clash

• Pass a Class<T> token; use it to build and cast
• TypeToken: anonymous subclass keeps List<String> in its superclass

• Raw type: List with no argument, checks off
• Legacy only, never in new code
• List<String> l = new ArrayList(); unchecked warning
• Raw add(42) compiles, corrupts the list

• Arrays check type at runtime, erasure can't

• Class: class Box<T>; method: <T> goes before the return type
• Bound: <T extends A & B>, class first, then interfaces after &
• No primitives: List<int> is illegal, use the wrapper List<Integer>

class Box<T extends Number & Comparable<T>> { T val; }
static <T> T first(List<T> l) { return l.get(0); }

class bound and generic method