Generics stellen je in staat om klassen en methoden geparametriseerd door type te schrijven, zodat dezelfde code met veel types werkt terwijl compile-time typeveiligheid behouden blijft. Dit is parametrische polymorfisme — "één vorm, elk type."
();
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 wist generieke types op runtime uit (type erasure) — je kunt niet new T() of instanceof List<String> doen. C++ templates en C# generics gedragen zich anders (monomorphization / reified types).
Generics geven hergebruik en veiligheid tegelijkertijd: één List<T> werkt voor elk elementtype, waarbij de compiler typfouten opvangt die anders runtime crashes zouden zijn.
Ze elimineren onveilige casts en vormen de ruggengraat van collections, waardoor code zowel beter herbruikbaar als moeilijker te misbruiken is.