KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

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