Les génériques vous permettent d'écrire des classes et des méthodes paramétrées par type, de sorte que le même code fonctionne avec de nombreux types tout en préservant la sécurité des types à la compilation. C'est le polymorphisme paramétrique — « une forme, n'importe quel 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 efface les types génériques à l'exécution (type erasure) — vous ne pouvez pas faire new T() ou instanceof List<String>. Les modèles C++ et les génériques C# se comportent différemment (monomorphisation / types réifiés).
Les génériques offrent la réutilisation et la sécurité simultanément : une seule List<T> sert tous les types d'éléments, le compilateur détectant les erreurs de type qui seraient autrement des plantages à l'exécution.
Ils éliminent les conversions de type non sûres et constituent la base des collections, rendant le code à la fois plus réutilisable et plus difficile à mal utiliser.