WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

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