CKTIS / Java
Grenzen voor generieke typeparameters
Typegrenzen bepalen welke typen je als generieke argumenten kunt gebruiken. Zo behoud je het concrete buildertype, vergelijk je via een supertype en stel je meerdere eisen tegelijk.
Versie: Java SE 21
Syntax
<T extends Builder<T>>
<T extends Comparable<? super T>>
<T extends Comparable<T> & Serializable>
<T extends Entity & Prioritized>In Java SE 21 declareer je met <T extends ...> een bovengrens voor een typeparameter. Je gebruikt extends voor zowel klassen als interfaces. De compiler controleert of het typeargument aan de grens voldoet en laat je de toegankelijke leden gebruiken die deze grens biedt.
T extends Builder<T> is een recursieve grens: T komt als typeargument voor in zijn eigen grens. Als TaskBuilder Builder<TaskBuilder> uitbreidt, retourneert de geërfde methode named een TaskBuilder, zodat je meteen build kunt aanroepen. De grens alleen bewijst niet dat this het type T heeft; met een abstracte methode self() kan de subklasse this zonder cast teruggeven.
Met T extends Comparable<? super T> kun je een waarde van type T doorgeven aan compareTo, omdat de vergelijking T of een supertype van T accepteert. Comparable is invariant: via ChronoLocalDate implementeert LocalDate Comparable<ChronoLocalDate>, niet Comparable<LocalDate>. Daardoor voldoet LocalDate aan de grens met de wildcard met ondergrens ? super T, maar niet aan Comparable<T> voor T = LocalDate.
T extends Comparable<T> & Serializable vereist zowel Comparable<T> als de markerinterface Serializable. De grens voert geen serialisatie uit en garandeert niet dat de hele objectgraaf serialiseerbaar is; LocalDate valt af ondanks Serializable. T extends Entity & Prioritized vereist daarentegen dat T Entity of een subklasse daarvan is en Prioritized implementeert. In beide declaraties staat & voor een doorsnede van typen, niet voor een bitsgewijze AND. Als een klasse deel uitmaakt van een meervoudige grens, staat die vooraan; daarna mogen alleen interfaces volgen. De meest linkse grens bepaalt de type-erasure van T.
Voorbeelden
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"));
}
}Resultaat
Backup (priority 3) 2026-01-15 < 2026-02-01: true alpha
`named` behoudt het type `TaskBuilder` en `describe` gebruikt beide grenzen. `min`, `max` en `isBefore` accepteren `LocalDate`-waarden; `minSerializable` vergelijkt tekenreeksen zonder ze te serialiseren.
Gerelateerde lessen
- Java · Les 11 · Gevorderd · Versie: 2
- Java · Les 15 · Gevorderd · Versie: 2
- Java · Les 16 · Gevorderd · Versie: 2
- Java · Les 32 · Gemiddeld · Versie: 2
Bronnen
- 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)