Programmation · Prog 13 · Code réutilisable

Génériques

Écrire le code une seule fois, pour tous les types, sans laisser passer les intrus.

Déjà à l'aise ? Aller directement au quiz

Dans la vraie vie

Sur l’étagère de ta chambre, une boîte porte une étiquette : « chaussures seulement ».

chaussures seulement acceptée refusée à l’ouverture : des chaussures, à coup sûr

Celui qui la remplit sait quoi y mettre ; celui qui l’ouvre sait ce qu’il va trouver.

Un générique, c’est cette étiquette.

Une liste de prénoms, de notes ou d’élèves : le code qui range, cherche ou trie est le même, seul le type change. Un générique l’écrit une fois, avec un paramètre de type, souvent T.

À l’utilisation, T devient String, Integer ou Eleve.

Et le compilateur refuse les intrus, avant même que le programme tourne.

Un code, tous les types.

Au programme

  • 01copier le code, ou tout accepter ?
  • 02la classe générique Boite<T>
  • 03le compilateur devine T
  • 04T, mais pas n’importe lequel
  • 05ce qui reste à l’exécution
  • 06les génériques du quotidien
Question pour toi : pour le compilateur, Boite<String> et Boite<Integer> sont deux types différents. Combien de classes Boite y a-t-il dans le programme compilé ?

Deux, forcément ?

Garde ta réponse en tête. On la vérifie au chapitre 5.

Une boîte par type, ou une boîte à tout ?

Dans la vraie vie

Au déménagement, tout ce qui n’a pas de place finit dans le carton « divers ». Facile à remplir.

on y met tout divers je cherche une assiette une chaussure !

À l’arrivée, tu y cherches une assiette, et tu sors une chaussure.

Object et le transtypage

Avant les génériques, Java avait deux solutions : copier la classe pour chaque type, ou une boîte à Object qui accepte tout. Mais pour relire, il faut transtyper, et une erreur n’éclate qu’à l’exécution.

boîte à Object "Léa" Integer n = (Integer) b.prendre(); compilation : accepté exécution : ClassCastException une promesse que personne ne vérifie avant l’exécution

Ranger un objet, trois façons

Copier la classe, tout accepter avec Object, puis Boite<T>.

Ranger un objetcopier-coller

Trois classes qui ne diffèrent que par un mot : le type rangé. Un bug à corriger ? Trois fois.

Transtyper, c’est promettre au compilateur que tu sais ce qu’il y a dans la boîte.

Et si je me trompe ?

L’erreur arrive trop tard : pendant l’exécution, chez celui qui utilise le programme.

Pourquoi les génériques

Ils ont été ajoutés à Java « pour fournir des vérifications de type plus strictes à la compilation et pour permettre la programmation générique »1.

Un seul code, et le compilateur qui veille.

Un moule, des boîtes spécialisées

Dans la vraie vie

Dans un magasin de rangement, le même modèle de boîte se vend avec une étiquette vierge. Chacun y écrit ce qu’il veut : chaussures, câbles, photos.

? étiquette vierge chaussurescâblesphotos

Paramètre de type

Dans class Boite<T>, T est un paramètre de type : une place réservée pour un vrai type, comme un paramètre de méthode l’est pour une valeur. Écrire Boite<String>, c’est donner l’argument de type String.

un paramètre de méthode reçoit une valeur 4 carre(x) x = 4 un paramètre de type reçoit un type String Boite<T> T = String

Où l’image s’arrête : rien n’empêche de glisser une chaussette dans la boîte à chaussures.

Avec Boite<String>, si : le compilateur refuse tout ce qui n’est pas un String.

Le même moule, trois boîtes

T prend la place d’un vrai type : String, Integer, puis une classe à toi.

class Boite<T>le moule

Le moule Boite<T> : partout où le type rangé compte, la classe écrit T, une place réservée.

Boite<T>, en quatre langages

La même boîte en Java, TypeScript, Python et Go.

JavaBoite.java
public class Boite<T> {
    private T contenu;

    public void mettre(T valeur) {
        contenu = valeur;
    }

    public T prendre() {
        return contenu;
    }
}

// ailleurs, par exemple dans main
Boite<String> noms = new Boite<>();
noms.mettre("Léa");
String nom = noms.prendre();   // aucun transtypage
Boite<Integer> notes = new Boite<>();
notes.mettre(6);
int n = notes.prendre() + 1;   // 7
TypeScriptboite.ts
class Boite<T> {
    constructor(private contenu: T) {}

    mettre(valeur: T): void {
        this.contenu = valeur;
    }

    prendre(): T {
        return this.contenu;
    }
}

const noms = new Boite("Léa");   // Boite<string>, déduit
console.log(noms.prendre().toUpperCase());   // LÉA
const notes = new Boite<number>(6);
console.log(notes.prendre() + 1);            // 7
Python 3.12+boite.py
class Boite[T]:
    def __init__(self, contenu: T) -> None:
        self.contenu = contenu

    def mettre(self, valeur: T) -> None:
        self.contenu = valeur

    def prendre(self) -> T:
        return self.contenu

noms: Boite[str] = Boite("Léa")
print(noms.prendre().upper())   # LÉA
notes = Boite[int](6)
print(notes.prendre() + 1)      # 7
Go 1.18+boite.go
type Boite[T any] struct {
    contenu T
}

func (b *Boite[T]) Mettre(v T) { b.contenu = v }
func (b *Boite[T]) Prendre() T  { return b.contenu }

func main() {
    var noms Boite[string]
    noms.Mettre("Léa")
    fmt.Println(noms.Prendre())   // Léa
}

Chevrons ou crochets

Java et TypeScript écrivent Boite<T> ; Python (depuis 3.12) et Go (depuis 1.18), Boite[T]5, 6. En Go, [T any] veut dire « n’importe quel type ». Par convention, une majuscule.

JavaBoite<T>TypeScriptBoite<T> Python 3.12Boite[T]Go 1.18Boite[T any] chevrons < > crochets [ ] T : typeE : élémentK : cléV : valeur

Piège Java : pas de types primitifs

List<int> ne compile pas : un argument de type doit être une classe2.

error: unexpected type
  required: reference
  found:    int

On écrit List<Integer> ; Java convertit tout seul 6 en Integer, et inversement.

Exercice 1

Que se passe-t-il ?

Avec la classe Boite<T> ci-dessus, en Java.

Boite<String> b = new Boite<>();
b.mettre("Léa");
String s = b.prendre();
Boite<String> b = new Boite<>();
b.mettre(42);
Boite<Integer> b = new Boite<>();
b.mettre(42);
System.out.println(b.prendre() + 1);

Pas besoin de tout dire

Dans la vraie vie

Qui est le premier de la file ? Devant la cantine, c’est un élève ; au péage, une voiture.

cantine premier : un élève péage premier : une voiture

Pas besoin de préciser : on le voit à la file.

Méthode générique

Une méthode peut avoir ses propres paramètres de type, sans que sa classe soit générique : <T> se place avant le type de retour. À l’appel, le compilateur déduit T des arguments4.

static <T> T premier(List<T> liste) les trois T : le même type, choisi à chaque appel

Ce que vérifie le compilateur

Le code reste à l’écran ; à chaque ligne, regarde ce que le compilateur déduit, accepte ou refuse.

Outils.java (extrait)Java
static <T> T premier(List<T> liste) {    return liste.get(0);}// dans main :String p = premier(List.of("Léa", "Tom"));Integer n = premier(List.of(4, 5));Boite<String> b = new Boite<>();b.mettre("Léa");b.mettre(42);

<T> avant le type de retour : la méthode a son propre paramètre de type. Ses trois T désignent le même type, choisi à chaque appel.

Avec une liste de prénoms, le compilateur déduit T = String : premier renvoie un String, rangé dans p.

Avec une liste de notes, cette fois T = Integer. Une méthode, tous les types.

Le losange <> : new Boite<>() reprend le type écrit à gauche du =, ici String.

b.mettre("Léa") : mettre attend un String et en reçoit un. Accepté.

b.mettre(42) : refusé avant même l’exécution, le programme ne compile pas. Le message dit pourquoi.

premier, en quatre langages

La même méthode générique en Java, TypeScript, Python et Go.

JavaOutils.java
static <T> T premier(List<T> liste) {
    return liste.get(0);
}

String p = premier(List.of("Léa", "Tom"));   // Léa
Integer n = premier(List.of(4, 5));          // 4
TypeScriptoutils.ts
function premier<T>(liste: T[]): T | undefined {
    return liste[0];
}

premier(["Léa", "Tom"]);   // T = string
premier([4, 5]);           // T = number
premier<boolean>([]);      // T précisé : undefined
Python 3.12+outils.py
def premier[T](liste: list[T]) -> T:
    return liste[0]

print(premier(["Léa", "Tom"]))   # Léa
print(premier([4, 5]))           # 4
Gooutils.go
func Premier[T any](s []T) (T, bool) {
    if len(s) == 0 {
        var zero T   // la valeur nulle de T
        return zero, false
    }
    return s[0], true
}

p, ok := Premier([]string{"Léa", "Tom"})   // T = string

Et une liste vide ?

Chaque langage réagit à sa façon. En Java, Optional<T> sert justement à dire « peut-être une valeur ».

premier(liste vide) JavaIndexOutOfBoundsException TypeScriptundefined Govaleur nulle de T, et false

T, mais pas n’importe lequel

Dans la vraie vie

À l’agence de location, n’importe quel client peut louer une voiture, à condition d’avoir un permis de conduire.

location de voitures avec permis : acceptés sans permis : refusé

Le permis, c’est la condition d’entrée.

La borne

Pour trouver le plus grand de deux objets, il faut pouvoir les comparer. <T extends Comparable<T>> n’accepte que les types qui savent se comparer. Ici, extends vaut aussi pour une interface3.

static <T extends Comparable<T>> T max(T a, T b) la borne : T doit savoir se comparer (compareTo)

Qui passe la borne ?

Quatre types se présentent devant T extends Comparable<T>.

La borneextends Comparable

La borne agit comme un contrôle à l'entrée : seuls les types qui implémentent Comparable passent.

Borner, en quatre langages

La méthode max en Java, puis une borne dans chaque langage.

JavaOutils.java
static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}
JavaEleve.java
// Eleve passe la borne dès qu'il sait se comparer
class Eleve implements Comparable<Eleve> {
    String nom;
    Eleve(String nom) { this.nom = nom; }
    public int compareTo(Eleve autre) {
        return nom.compareTo(autre.nom);
    }
}

// somme de n'importe quelle liste de nombres
static double somme(List<? extends Number> l) {
    double s = 0;
    for (Number x : l) s += x.doubleValue();
    return s;
}
TypeScriptlongueur.ts
function longueur<T extends { length: number }>(x: T): number {
    return x.length;
}

longueur("Léa");       // 3
longueur([1, 2, 3]);   // 3
longueur(42);          // erreur : number n'a pas de length
Python 3.12+animaux.py
class Animal:
    def manger(self) -> str:
        return "miam"

class Chat(Animal):
    pass

def nourrir[T: Animal](a: T) -> T:   # T : Animal ou une sous-classe
    print(a.manger())
    return a

c = nourrir(Chat())   # miam ; c reste un Chat
Gosomme.go
type Nombre interface {
    ~int | ~float64   // ~ : aussi les types bâtis sur int ou float64
}

func Somme[T Nombre](valeurs []T) T {
    var s T
    for _, v := range valeurs {
        s += v
    }
    return s
}
// Somme([]int{4, 5}) vaut 9

Et le point d’interrogation ?

List<? extends Number> accepte une List<Integer> comme une List<Double> : un joker borné, utile pour lire une liste sans connaître son type exact.

List<Integer> List<Double> List<String> List<? extends Number> somme(List.of(1, 2, 3)) donne 6.0

somme(List.of(5.5, 4.5)) donne 10.0.

Exercice 2

Accepté ou refusé ?

Avec <T extends Comparable<T>> T max(T a, T b), range chaque appel. Eleve est ici une classe sans compareTo.

CompileT sait se comparer
Refuséerreur de compilation

Ce qu’il reste de T

Dans la vraie vie

Pendant un déménagement, chaque carton porte une étiquette, pour que personne ne se trompe de pièce. Une fois tout rangé, on décolle les étiquettes.

pendant le déménagement : une étiquette par carton cuisinechambresalon une fois rangé : tous pareils

L’effacement de type

Le compilateur Java vérifie tout, puis applique l’effacement de type : T devient sa borne, ou Object, et il ajoute lui-même les transtypages nécessaires1.

void mettre(T valeur) String nom = b.prendre(); void mettre(Object valeur) String nom = (String) b.prendre(); ce que tu écris après javac : T devient Object, et le transtypage est ajouté

Du code source à l’exécution

Ce que tu écris, ce que garde le bytecode, ce qui tourne, puis Python et TypeScript.

Que reste-t-il de T ?code source

Le code source : Boite<String>. Le compilateur vérifie que seuls des String y entrent.

Réponse à ma question du début : une seule classe Boite.

Pourtant le compilateur les distingue ?

Oui : Boite<String> et Boite<Integer> n’existent que pour lui. À l’exécution, il ne reste que la classe Boite.

Interdit : new T()

T n’existe plus à l’exécution : la machine ne saurait pas quelle classe créer2. javac répond error: unexpected type.

Interdit : instanceof List<String>

Le String a été effacé : javac répond error: Object cannot be safely cast to List<String>2.

Risqué : la List brute

Sans chevrons, ça compile avec un simple avertissement… puis ClassCastException si l’on relit 42 comme un String.

Exercice 3

Compilation ou exécution ?

Touche la bonne réponse.

Boite<String> a = new Boite<>();
Boite<Integer> b = new Boite<>();
System.out.println(a.getClass() == b.getClass());
faux: Boite[int] = Boite("pas un nombre")
print(faux.prendre())

Dans le JavaScript que produit tsc à partir de class Boite<T>, il reste…

Tu en utilises déjà

Dans la vraie vie

Dans un classeur à intercalaires, chaque intercalaire porte un prénom, et derrière, les notes de l’élève.

Léa Tom Mia notes de Léa 5 6 1re2e l’intercalaire Léa, puis la 2e note : 6

Des génériques qui s’emboîtent

Les collections de la fiche 10 sont génériques : List<String>, Set<Integer>, Map<K, V> avec deux paramètres. Et ils s’emboîtent : des clés String, des valeurs List<Integer>.

Map<String, List<Integer>> clé : String"Léa" valeur : List<Integer> 5 6 on lit de l’extérieur vers l’intérieur

On ouvre les boîtes

Map<String, List<Integer>>, couche par couche.

Map<String, List<Integer>>la Map

Une Map : elle associe des clés à des valeurs. Ses deux paramètres disent de quel type.

Des génériques partout

Map<String, List<Integer>>

Les notes de chaque élève : {Léa=[5, 6]}. Deux paramètres, dont l’un est lui-même générique.

Optional<T>

En Java, une valeur de type T, ou rien : Optional.empty().orElse("aucun") donne aucun.

Promise<T>

En TypeScript, une valeur de type T qui arrivera plus tard.

Partial<T>

En TypeScript, le type T avec toutes ses propriétés facultatives : Partial<Eleve> accepte { nom: "Léa" }.

Record<K, V>

En TypeScript, un objet aux clés K et aux valeurs V : { Léa: 5.5, Tom: 4.5 } est un Record<string, number>.

Exercice 4

Écris une paire générique

Remets les lignes dans l'ordre. Avec new Paire<>("Léa", 5.5), premier() renvoie "Léa" et second() renvoie 5.5.

  1. public class Paire<A, B> {
  2. private final A premier;
  3. private final B second;
  4. public Paire(A premier, B second) {
  5. this.premier = premier;
  6. this.second = second;
  7. }
  8. public A premier() { return premier; }
  9. public B second() { return second; }
  10. }

La fiche en six cartes

Le problème

Sans génériques : du code copié pour chaque type, ou Object et des transtypages qui peuvent échouer à l’exécution.

Boite<T>

T est un paramètre de type ; Boite<String> lui donne un argument, une vraie classe (pas int).

L’inférence

Une méthode générique déclare <T> avant son type de retour ; le compilateur déduit T des arguments.

Les bornes

Une borne restreint T : <T extends Comparable<T>>, [T: Animal], T extends { length: number }.

L’effacement

À l’exécution, les types génériques s’effacent : une seule classe Boite en Java, de simples annotations en Python et en TypeScript.

Au quotidien

List<String>, Map<K, V>, Optional<T>, Promise<T> : tu en utilises déjà.

Le dernier quiz de la série

Mode survie

Dix questions tirées au hasard, de plus en plus difficiles. À la première erreur, la partie s’arrête : lis l’explication, puis relance.

Mon conseil : pour chaque question, demande-toi si c’est vérifié à la compilation ou à l’exécution. Avec les génériques, tout se joue là.

10 questions · zéro faute · chronomètre

De la machine aux génériques

Fin de la série

Tu as parcouru toute la programmation : de la machine et des variables jusqu’aux classes, aux exceptions et aux génériques. Quatorze fiches, les mêmes idées dans plusieurs langages. Le meilleur moyen de les garder, c’est d’écrire de petits programmes à toi.

Sources

  1. Oracle, The Java Tutorials : Type Erasure (pourquoi les génériques, effacement des paramètres de type, transtypages ajoutés), consulté en 2026. docs.oracle.com
  2. Oracle, The Java Tutorials : Restrictions on Generics (types primitifs, new T(), instanceof), consulté en 2026. docs.oracle.com
  3. Oracle, The Java Tutorials : Bounded Type Parameters (extends pour une classe comme pour une interface), consulté en 2026. docs.oracle.com
  4. Microsoft, TypeScript Handbook : Generics (inférence des arguments de type, contraintes, classes génériques), consulté en 2026. typescriptlang.org
  5. Eric Traut, PEP 695 : Type Parameter Syntax (Python 3.12 : class Boite[T], def f[T], bornes), consultée en 2026. peps.python.org
  6. Robert Griesemer et Ian Lance Taylor, An Introduction To Generics, The Go Blog, 22 mars 2022, consulté en 2026. go.dev

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Extraits exécutés : Java 21 (messages d'erreur du compilateur et bytecode lus avec javap), Python 3.14, TypeScript 5.9 en mode strict. Extraits Go relus (compilateur non disponible).

Retour vers le hub Mukbang
Gymnase 3