CKTIS / Java
Schranken für generische Typparameter
Schranken legen fest, welche Typen als generische Argumente zulässig sind. So lässt sich der konkrete Builder-Typ erhalten, über einen Obertyp vergleichen und mehr als eine Schranke verlangen.
Version: 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 deklariert <T extends ...> eine obere Schranke für einen Typparameter. extends gilt für Klassen und Schnittstellen. Der Compiler prüft, ob das Typargument die Schranke erfüllt, und erlaubt den Zugriff auf die dadurch verfügbaren, zugänglichen Mitglieder.
T extends Builder<T> ist eine rekursive Schranke: T steht als Typargument in seiner eigenen Schranke. Wenn TaskBuilder von Builder<TaskBuilder> erbt, liefert die geerbte Methode named einen TaskBuilder, sodass direkt build folgen kann. Die Schranke allein beweist nicht, dass this den Typ T hat; mit einer abstrakten Methode self() kann die Unterklasse this ohne Typumwandlung zurückgeben.
T extends Comparable<? super T> erlaubt es, einen Wert vom Typ T an compareTo zu übergeben, weil der Vergleich T oder einen Obertyp akzeptiert. Comparable ist invariant: Über ChronoLocalDate implementiert LocalDate den Typ Comparable<ChronoLocalDate>, nicht Comparable<LocalDate>. Deshalb erfüllt LocalDate die Schranke mit der nach unten beschränkten Wildcard ? super T, nicht aber Comparable<T> für T = LocalDate.
T extends Comparable<T> & Serializable verlangt sowohl Comparable<T> als auch die Markerschnittstelle Serializable. Die Schranke führt keine Serialisierung durch und garantiert nicht, dass der gesamte Objektgraph serialisierbar ist; LocalDate ist trotz Serializable nicht zulässig. T extends Entity & Prioritized verlangt dagegen Entity oder eine Unterklasse, die Prioritized implementiert. In beiden Deklarationen bezeichnet & einen Schnitttyp, kein bitweises UND. Steht in einer Mehrfachschranke eine Klasse, muss sie an erster Stelle stehen; danach dürfen nur Schnittstellen folgen. Die erste Schranke bestimmt die Typlöschung von T.
Beispiele
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"));
}
}Ergebnis
Backup (priority 3) 2026-01-15 < 2026-02-01: true alpha
`named` erhält den Typ `TaskBuilder`, und `describe` nutzt beide Schranken. `min`, `max` und `isBefore` akzeptieren `LocalDate`-Werte; `minSerializable` vergleicht Zeichenketten, ohne zu serialisieren.
Zugehörige Lektionen
- Java · Lektion 11 · Fortgeschritten · Version: 2
- Java · Lektion 15 · Fortgeschritten · Version: 2
- Java · Lektion 16 · Fortgeschritten · Version: 2
- Java · Lektion 32 · Mittlere Stufe · Version: 2
Quellen
- 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)