Qu'est-ce que les génériques et pourquoi les utiliser ?

Question

Accepted Answer

**Les génériques** vous permettent d'écrire des classes, des interfaces et des méthodes qui fonctionnent avec un **paramètre de type** spécifié par l'appelant — fournissant une **sécurité de type à la compilation** et éliminant les casts. Ils alimentent le framework Collections et les bibliothèques réutilisables. ## Le problème que les génériques résolvent ```java // ❌ before generics (or with raw types) — no type safety, requires casts List list = new ArrayList(); list.add("hello"); list.add(42); // oops — anything can go in String s = (String) list.get(1); // ClassCastException at RUNTIME! 💥 // ✅ with generics — the type is enforced at COMPILE time List list = new ArrayList<>(); list.add("hello"); list.add(42); // ❌ compile error — caught immediately String s = list.get(0); // no cast needed — known to be String ``` Les génériques déplacent les erreurs de type de l'exécution (`ClassCastException`) à la **compilation**, et éliminent le besoin de casts manuels — rendant le code plus sûr et plus propre. ## Classes et méthodes génériques ```java // a generic class — T is a type parameter filled in by the user public class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } Box b = new Box<>(); // T = String b.set("hi"); String x = b.get(); // typed, no cast // a generic method public static T firstElement(List list) { return list.get(0); } ``` ## Paramètres de type limités ```java // T must be Number (or a subclass) — lets you call Number methods public static double sum(List list) { double total = 0; for (T n : list) total += n.doubleValue(); // safe — T is a Number return total; } ``` `` contraint le paramètre de type, ce qui vous permet d'utiliser les membres de ce type en toute sécurité. ## Wildcards ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` Les wildcards ajoutent de la flexibilité pour les paramètres de méthode qui doivent accepter une plage de types. ## Type erasure (une mise en garde Java) ```java // generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility) List a = new ArrayList<>(); List b = new ArrayList<>(); a.getClass() == b.getClass(); // true — both are just ArrayList at runtime // consequence: can't do `new T()` or `instanceof List` ``` Java implémente les génériques via l'**effacement de type** — les paramètres de type existent au moment de la compilation mais sont supprimés à l'exécution, ce qui a certaines limitations. ## Pourquoi c'est important Les génériques sont essentiels au Java moderne — ils fournissent une sécurité de type à la compilation (détectant les erreurs de type précocement au lieu de `ClassCastException` à l'exécution), éliminent les casts verbeux et sujets aux erreurs, et permettent un code réutilisable et flexible en termes de type. Ils sont la base de l'ensemble du framework Collections (`List`, `Map`) et d'innombrables bibliothèques. Comprendre les classes/méthodes génériques, les paramètres limités, les wildcards (PECS) et la mise en garde sur l'effacement de type vous permet à la fois d'utiliser correctement les API génériques et de concevoir vos propres abstractions réutilisables et type-safe — une compétence essentielle pour écrire du Java robuste et maintenable.