Generics ermöglichen es, Klassen und Methoden zu schreiben, die über einen Typ parametrisiert sind, sodass derselbe Code mit vielen Typen funktioniert und dabei die Typsicherheit zur Compile-Zeit erhalten bleibt. Das ist parametrischer Polymorphismus – "eine Form, jeder Typ."
();
list.add();
(String) list.get();
// With generics: type is known and checked at compile time
List<String> list = new ArrayList<>();
list.add("hi");
String s = list.get(0); // no cast; list.add(42) won't compile
class Box<T> { // T is a type parameter
private T value;
Box(T value) { this.value = value; }
T get() { return value; }
}
Box<Integer> b = new Box<>(42); // T = Integer, checked at compile time
int n = b.get(); // no cast needed
<T extends Comparable<T>> // bounded: T must be comparable
List<? extends Number> // covariance: accept List<Integer>, List<Double>
Java löscht generische Typen zur Laufzeit (type erasure) – du kannst kein new T() oder instanceof List<String> verwenden. C++-Templates und C#-Generics verhalten sich anders (Monomorphisierung / reifizierte Typen).
Generics bieten Wiederverwendbarkeit und Sicherheit zugleich: ein einziges List<T> bedient jeden Elementtyp, während der Compiler Typfehler abfängt, die andernfalls zu Abstürzen zur Laufzeit führen würden.
Sie eliminieren unsichere Casts und bilden das Rückgrat der Collections, wodurch Code zugleich wiederverwendbarer und schwerer falsch zu benutzen wird.