No instanceof with Parameterized Types

## The terms first **Generics** let you parameterize a type by another type — `List<String>` is "a list whose elements are Strings". The thing in angle brackets (`String`) is the **type argument**; the placeholder (`E` in `List<E>`) is the **type parameter**. **`instanceof`** is a runtime operator: `x instanceof Foo` asks the JVM, *at the moment the program runs*, "is the object referenced by `x` actually a Foo (or a subtype)?" It returns a boolean and is used before a cast. **Type erasure** is the key mechanism. Java added generics in Java 5 *without* changing the bytecode/JVM, to stay backward compatible with pre-generics code. The compiler uses the type arguments to check your code, then **erases** them: `List<String>`, `List<Integer>`, and `List<?>` all compile down to the same runtime type — the raw `List`. The `<String>` part exists only in the source and (partly) in metadata; it is **not** stored in each object instance. **Reifiable type** = a type whose full information *survives* to runtime so it can be checked or constructed. `String`, `int[]`, `List` (raw), and `List<?>` are reifiable. `List<String>` is **not reifiable** — its type argument is gone after erasure. ## Why `instanceof List<String>` is illegal Because the `<String>` was erased, *every* `List` object at runtime looks identical regardless of its element type. There is no field, header bit, or class tag that records "this list holds Strings." So a runtime `instanceof List<String>` check is **unanswerable** — the JVM could only ever check the erased `List`, which would make the `<String>` a lie. Rather than silently degrade the check (and give you a false sense of safety), the Java language **rejects it at compile time**: *"illegal generic type for instanceof"*. ```java List<String> a = new ArrayList<>(); List<Integer> b = new ArrayList<>(); // a.getClass() == b.getClass() is TRUE at runtime — both are ArrayList ``` ## What IS allowed 1. **Unbounded wildcard:** `obj instanceof List<?>`. The `<?>` means "a list of *some* unknown type" — it carries **no** type argument to verify, so the check reduces exactly to the reifiable raw `List`. This is the idiomatic, warning-free form. 2. **Raw type:** `obj instanceof List`. Legal but produces an unchecked/rawtypes warning; prefer `List<?>`. 3. **Bounded wildcards are NOT allowed:** `instanceof List<? extends Number>` is rejected — the bound is non-reifiable info too. 4. **Type parameter is NOT allowed:** inside `class Box<T>`, you cannot write `x instanceof T` — `T` is erased to its bound (often `Object`), so the check is meaningless. (Same reason `new T()` and `new T[]` are illegal.) ## How to actually test the element type Since you can't ask the list, you must inspect an **element**, which is a real reified object: ```java if (obj instanceof List<?> list && !list.isEmpty() && list.get(0) instanceof String) { ... } ``` Or pass a `Class<T>` **type token** and use `Class.isInstance` / `Class.cast` to do reflective, reifiable checks. This pattern (a `Class<T>` parameter standing in for the erased `T`) is how libraries recover the type they need. ## Mental model Generics are a **compile-time** contract; `instanceof` is a **runtime** question. The two only meet where the type information is reifiable — which, for a parameterized type, is just its unbounded-wildcard / raw form.