Type erasure & its consequences

What erasure is

Java generics are implemented by type erasure: the type parameters exist only at compile time. After the compiler verifies your types and inserts casts, it erases the parameters from the bytecode. List<String> and List<Integer> become the same class — plain List — at runtime:

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

An unbounded T erases to Object; a bounded <T extends Number> erases to its leftmost bound, Number. This design kept generics backward-compatible with pre-1.5 bytecode, but it means the JVM has *no idea* about your type arguments. Several things follow directly.

What you cannot do, and why

1. new T() is illegal. The runtime does not know what T is, so it cannot allocate one:

<T> T make() { return new T(); }   // COMPILE ERROR

2. instanceof T and instanceof List<String> are illegal. The runtime type carries no parameter, so the test is meaningless. Only the unbounded form is allowed:

if (x instanceof List<String>) {} // COMPILE ERROR
if (x instanceof List<?>) {}       // OK — no parameter to check

3. You cannot create a generic array. new T[10] and new List<String>[10] are forbidden, because arrays know and check their element type at runtime but generics do not — the two models clash. Use a collection (List<T>) or an Object[] with casts instead.

The Class<T> token workaround

Because new T() is impossible, the idiom is to pass the class object as a runtime token. The Greenhouse project uses exactly this to build an Event from a class — and a generic factory looks like:

static <T> T create(Class<T> type) throws Exception {
    return type.getDeclaredConstructor().newInstance();
}
String s = create(String.class);   // type token supplies the runtime type

Class<T> survives erasure (it is an ordinary object you pass in), so newInstance() has the runtime type information that new T() lacks.

One more consequence: no overloading by parameter

Because both erase to the same signature, you cannot overload a method on the type argument:

void f(List<String> s) {}
void f(List<Integer> i) {}   // COMPILE ERROR — same erasure: f(List)