Formations — 1 037 leçons en français

Accueil › Java › Écrire du code générique

Écrire du code générique

Les génériquesintermediaire

Avant les génériques (Java 5), une collection stockait des Object : tout y entrait, mais chaque lecture exigeait un transtypage (cast) dont le compilateur ne pouvait pas vérifier la validité. Une erreur de type ne se révélait qu'à l'exécution, en ClassCastException.

List liste = new ArrayList();       // type brut : aucune vérification
liste.add("Casque");
liste.add(42);                       // compile sans problème
String s = (String) liste.get(1);   // ClassCastException à l'exécution

Les génériques déplacent cette vérification à la compilation. Une classe générique déclare un paramètre de type entre chevrons :

public class Boite<T> {
    private T contenu;
    public void ranger(T valeur) { this.contenu = valeur; }
    public T ouvrir() { return contenu; }
}

Boite<String> boite = new Boite<>();   // <> : opérateur diamant
boite.ranger("Casque");
String s = boite.ouvrir();              // pas de cast, pas de risque

Une méthode générique déclare son propre paramètre de type avant le type de retour : static <T> T premier(List<T> liste). Convention de nommage : T (Type), E (Element), K/V (Key/Value), R (Result).

Point piégeux : List<Chien> n'est pas un List<Animal>, même si Chien hérite d'Animal — les génériques sont invariants (la leçon suivante montre comment assouplir cela avec les jokers).

Les termes à connaître

Paramètre de type

Variable représentant un type, déclarée entre chevrons (<T>) sur une classe, une interface ou une méthode. Elle est remplacée par un vrai type (String, Produit…) au moment de l'utilisation : Boite<String>, Boite<Produit>.

Classe générique

Classe déclarée avec un ou plusieurs paramètres de type (class Boite<T>), qui peut ainsi manipuler un type sans le figer à l'écriture. Le même code source sert pour Boite<Produit>, Boite<Client>, etc.

Méthode générique

Méthode qui déclare son propre paramètre de type, avant le type de retour (static <T> T premier(List<T> liste)), indépendamment du fait que sa classe soit générique ou non.

Type brut (raw type)

Utilisation d'un type générique sans indiquer son paramètre de type (List au lieu de List<String>). Compile avec un avertissement mais désactive les vérifications du compilateur : les erreurs de type ne sont détectées qu'à l'exécution, en ClassCastException. Hérité du code pré-Java 5, à éviter.

Borne (extends)

Restriction posée sur un paramètre de type avec extends (<T extends Number>) : T doit être Number ou une sous-classe. Permet d'appeler les méthodes de la borne sur des valeurs de type T, ce qu'un paramètre de type non borné n'autorise pas.

Opérateur diamant (<>)

Depuis Java 7, <> à droite du new laisse le compilateur déduire les arguments de type à partir du contexte : List<Produit> produits = new ArrayList<>(); évite de les répéter.

Invariance des génériques

En Java, List<Chien> n'est pas un sous-type de List<Animal>, même si Chien hérite d'Animal. Contrairement aux tableaux (covariants), les types génériques sont invariants : c'est une protection contre les erreurs de type à l'exécution.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.