CKTIS / Java
Bornes des paramètres de type génériques
Les bornes limitent les types utilisables comme arguments génériques. Elles permettent de conserver le type concret d’un builder, de comparer via un supertype et d’imposer plusieurs contraintes à la fois.
Version : Java SE 21
Syntaxe
<T extends Builder<T>>
<T extends Comparable<? super T>>
<T extends Comparable<T> & Serializable>
<T extends Entity & Prioritized>En Java SE 21, <T extends ...> déclare une borne supérieure pour un paramètre de type. extends s’emploie pour les classes comme pour les interfaces. Le compilateur vérifie que l’argument de type respecte la borne et autorise l’utilisation des membres accessibles qu’elle fournit.
T extends Builder<T> est une borne récursive : T figure comme argument de type dans sa propre borne. Quand TaskBuilder étend Builder<TaskBuilder>, la méthode héritée named renvoie un TaskBuilder, ce qui permet d’enchaîner avec build. La borne seule ne prouve pas que this est de type T ; une méthode abstraite self() permet à la sous-classe de renvoyer this sans conversion de type explicite.
T extends Comparable<? super T> permet de passer une valeur de type T à compareTo, car la comparaison accepte T ou un de ses supertypes. Comparable est invariant : via ChronoLocalDate, LocalDate implémente Comparable<ChronoLocalDate>, et non Comparable<LocalDate>. LocalDate respecte donc la borne avec le joker à borne inférieure ? super T, mais pas Comparable<T> pour T = LocalDate.
T extends Comparable<T> & Serializable exige à la fois Comparable<T> et l’interface marqueur Serializable. Cette borne ne déclenche aucune sérialisation et ne garantit pas que tout le graphe d’objets puisse être sérialisé ; LocalDate est refusé bien qu’il implémente Serializable. En revanche, T extends Entity & Prioritized exige que T soit Entity ou une sous-classe et qu’il implémente Prioritized. Dans les deux déclarations, & désigne une intersection de types, pas un ET bit à bit. Si une classe figure dans une borne multiple, elle doit être en tête ; seules des interfaces peuvent suivre. La première borne détermine l’effacement de type de T.
Exemples
import java.io.Serializable;
import java.time.LocalDate;
public class GenericBoundsDemo {
abstract static class Builder<T extends Builder<T>> {
protected String name;
final T named(String name) {
this.name = name;
return self();
}
protected abstract T self();
}
static final class TaskBuilder extends Builder<TaskBuilder> {
@Override
protected TaskBuilder self() { return this; }
Task build(int priority) { return new Task(name, priority); }
}
static class Entity {
private final String name;
Entity(String name) { this.name = name; }
final String name() { return name; }
}
interface Prioritized {
int priority();
}
static final class Task extends Entity implements Prioritized {
private final int priority;
Task(String name, int priority) {
super(name);
this.priority = priority;
}
@Override
public int priority() { return priority; }
}
static <T extends Entity & Prioritized> String describe(T value) {
return value.name() + " (priority " + value.priority() + ")";
}
static <T extends Comparable<? super T>> T min(T a, T b) {
return a.compareTo(b) <= 0 ? a : b;
}
static <T extends Comparable<? super T>> T max(T a, T b) {
return a.compareTo(b) >= 0 ? a : b;
}
static <T extends Comparable<? super T>> boolean isBefore(T a, T b) {
return a.compareTo(b) < 0;
}
static <T extends Comparable<T> & Serializable> T minSerializable(T a, T b) {
return min(a, b);
}
public static void main(String[] args) {
Task task = new TaskBuilder().named("Backup").build(3);
System.out.println(describe(task));
LocalDate a = LocalDate.of(2026, 2, 1);
LocalDate b = LocalDate.of(2026, 1, 15);
LocalDate earlier = min(a, b);
LocalDate later = max(a, b);
System.out.println(earlier + " < " + later + ": " + isBefore(earlier, later));
System.out.println(minSerializable("beta", "alpha"));
}
}Résultat
Backup (priority 3) 2026-01-15 < 2026-02-01: true alpha
`named` conserve le type `TaskBuilder`, et `describe` utilise les deux bornes. `min`, `max` et `isBefore` acceptent des valeurs `LocalDate` ; `minSerializable` compare des chaînes sans sérialiser.
Leçons associées
- Java · Leçon 11 · Avancé · Version : 2
- Java · Leçon 15 · Avancé · Version : 2
- Java · Leçon 16 · Avancé · Version : 2
- Java · Leçon 32 · Intermédiaire · Version : 2
Sources
- Java Language Specification, Java SE 21 — §4.4 Type Variables
- Java Language Specification, Java SE 21 — §4.5.1 Type Arguments of Parameterized Types
- Java Language Specification, Java SE 21 — §4.6 Type Erasure
- Comparable (Java SE 21 & JDK 21)
- LocalDate (Java SE 21 & JDK 21)
- ChronoLocalDate (Java SE 21 & JDK 21)
- Serializable (Java SE 21 & JDK 21)
- The java Command (JDK 21)