Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Vincoli sui parametri di tipo generici

I vincoli limitano i tipi utilizzabili come argomenti generici. Scopri come conservare il tipo concreto di un builder, confrontare tramite un supertipo e imporre più vincoli insieme.

Versione: Java SE 21

Sintassi

<T extends Builder<T>>
<T extends Comparable<? super T>>
<T extends Comparable<T> & Serializable>
<T extends Entity & Prioritized>

In Java SE 21, <T extends ...> dichiara un limite superiore per un parametro di tipo. extends si usa sia per le classi sia per le interfacce. Il compilatore verifica che l’argomento di tipo soddisfi il vincolo e consente di usare i membri accessibili che il vincolo mette a disposizione.

T extends Builder<T> è un vincolo ricorsivo: T compare come argomento di tipo nel proprio vincolo. Se TaskBuilder estende Builder<TaskBuilder>, il metodo ereditato named restituisce un TaskBuilder, perciò si può chiamare subito build. Il vincolo da solo non dimostra che this sia di tipo T; un metodo astratto self() permette alla sottoclasse di restituire this senza cast.

T extends Comparable<? super T> permette di passare un valore di tipo T a compareTo, perché il confronto accetta T o un suo supertipo. Comparable è invariante: tramite ChronoLocalDate, LocalDate implementa Comparable<ChronoLocalDate>, non Comparable<LocalDate>. Quindi LocalDate soddisfa il vincolo con il wildcard a limite inferiore ? super T, ma non Comparable<T> per T = LocalDate.

T extends Comparable<T> & Serializable richiede sia Comparable<T> sia l’interfaccia marcatrice Serializable. Il vincolo non esegue alcuna serializzazione e non garantisce che si possa serializzare l’intero grafo di oggetti; LocalDate non è ammesso, pur implementando Serializable. Invece T extends Entity & Prioritized richiede che T sia Entity o una sua sottoclasse e che implementi Prioritized. In entrambe le dichiarazioni, & indica un’intersezione di tipi, non un AND bit a bit. Se c’è una classe in un vincolo multiplo, deve venire per prima; dopo possono comparire solo interfacce. Il primo limite determina la cancellazione del tipo (type erasure) di T.

Esempi

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"));
    }
}

Risultato

Backup (priority 3)
2026-01-15 < 2026-02-01: true
alpha

`named` conserva il tipo `TaskBuilder` e `describe` usa entrambi i vincoli. `min`, `max` e `isBefore` accettano valori `LocalDate`; `minSerializable` confronta stringhe senza serializzarle.

Lezioni correlate

  • Java · Lezione 11 · Avanzato · Versione: 2
  • Java · Lezione 15 · Avanzato · Versione: 2
  • Java · Lezione 16 · Avanzato · Versione: 2
  • Java · Lezione 32 · Intermedio · Versione: 2

Fonti