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.
Programmation · Prog 13 · Code réutilisable
Écrire le code une seule fois, pour tous les types, sans laisser passer les intrus.
Déjà à l'aise ? Aller directement au quizDans la vraie vie
Sur l’étagère de ta chambre, une boîte porte une étiquette : « chaussures seulement ».
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.
Deux, forcément ?
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.
À 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.
Copier la classe, tout accepter avec Object, puis Boite<T>.
Trois classes qui ne diffèrent que par un mot : le type rangé. Un bug à corriger ? Trois fois.
Et si je me trompe ?
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.
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.
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.
T prend la place d’un vrai type : String, Integer, puis une classe à toi.
Le moule Boite<T> : partout où le type rangé compte, la classe écrit T, une place réservée.
La même boîte en Java, TypeScript, Python et Go.
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; // 7class 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); // 7class 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) # 7type 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.
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.
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.
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.
Le code reste à l’écran ; à chaque ligne, regarde ce que le compilateur déduit, accepte ou refuse.
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.
La même méthode générique en Java, TypeScript, Python et Go.
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)); // 4function 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é : undefineddef premier[T](liste: list[T]) -> T:
return liste[0]
print(premier(["Léa", "Tom"])) # Léa
print(premier([4, 5])) # 4func 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 = stringEt une liste vide ?
Chaque langage réagit à sa façon. En Java, Optional<T> sert justement à dire « peut-être une valeur ».
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.
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.
Quatre types se présentent devant T extends Comparable<T>.
La borne agit comme un contrôle à l'entrée : seuls les types qui implémentent Comparable passent.
La méthode max en Java, puis une borne dans chaque langage.
static <T extends Comparable<T>> T max(T a, T b) {
return a.compareTo(b) >= 0 ? a : b;
}// 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;
}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 lengthclass 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 Chattype 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 9Et 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.
somme(List.of(5.5, 4.5)) donne 10.0.
Avec <T extends Comparable<T>> T max(T a, T b), range chaque appel. Eleve est ici une classe sans compareTo.
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.
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.
Ce que tu écris, ce que garde le bytecode, ce qui tourne, puis Python et TypeScript.
Le code source : Boite<String>. Le compilateur vérifie que seuls des String y entrent.
Pourtant le compilateur les distingue ?
T n’existe plus à l’exécution : la machine ne saurait pas quelle classe créer2. javac répond error: unexpected type.
Le String a été effacé : javac répond error: Object cannot be safely cast to List<String>2.
Sans chevrons, ça compile avec un simple avertissement… puis ClassCastException si l’on relit 42 comme un String.
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.
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>>, couche par couche.
Une Map : elle associe des clés à des valeurs. Ses deux paramètres disent de quel type.
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>.
Remets les lignes dans l'ordre. Avec new Paire<>("Léa", 5.5), premier() renvoie "Léa" et second() renvoie 5.5.
La fiche en six cartes
Sans génériques : du code copié pour chaque type, ou Object et des transtypages qui peuvent échouer à l’exécution.
T est un paramètre de type ; Boite<String> lui donne un argument, une vraie classe (pas int).
Une méthode générique déclare <T> avant son type de retour ; le compilateur déduit T des arguments.
Une borne restreint T : <T extends Comparable<T>>, [T: Animal], T extends { length: number }.
À l’exécution, les types génériques s’effacent : une seule classe Boite en Java, de simples annotations en Python et en TypeScript.
List<String>, Map<K, V>, Optional<T>, Promise<T> : tu en utilises déjà.
Le dernier quiz de la série
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.
10 questions · zéro faute · chronomètre
De la machine aux génériques
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.
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).