What are generics (parametric polymorphism)?

Question

Accepted Answer

**Generics** let you write classes and methods parameterized by *type*, so the same code works with many types while keeping **compile-time type safety**. This is **parametric polymorphism** — "one shape, any type." ## The problem they solve ```java // Without generics: untyped, needs casts, can break at runtime List list = new ArrayList(); list.add("hi"); String s = (String) list.get(0); // cast required; wrong type → ClassCastException ``` ```java // With generics: type is known and checked at compile time List list = new ArrayList<>(); list.add("hi"); String s = list.get(0); // no cast; list.add(42) won't compile ``` ## Writing a generic type ```java class Box { // T is a type parameter private T value; Box(T value) { this.value = value; } T get() { return value; } } Box b = new Box<>(42); // T = Integer, checked at compile time int n = b.get(); // no cast needed ``` ## Bounds and variance (briefly) ```java > // bounded: T must be comparable List // covariance: accept List, List ``` ## Pitfall Java erases generic types at runtime (*type erasure*) — you can't do `new T()` or `instanceof List`. C++ templates and C# generics behave differently (monomorphization / reified types). ## Why it matters Generics give reuse *and* safety simultaneously: one `List` serves every element type, with the compiler catching type errors that would otherwise be runtime crashes. They eliminate unsafe casts and are the backbone of collections, making code both more reusable and harder to misuse.