Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Límites de los parámetros de tipo genéricos

Los límites restringen los tipos que se pueden usar como argumentos genéricos. Aprende a conservar el tipo concreto de un builder, comparar mediante un supertipo y exigir varios límites a la vez.

Versión: Java SE 21

Sintaxis

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

En Java SE 21, <T extends ...> declara un límite superior para un parámetro de tipo. extends se usa tanto con clases como con interfaces. El compilador comprueba que el argumento de tipo satisface el límite y permite usar los miembros accesibles que este proporciona.

T extends Builder<T> es un límite recursivo: T aparece como argumento de tipo en su propio límite. Cuando TaskBuilder extiende Builder<TaskBuilder>, el método heredado named devuelve un TaskBuilder, así que se puede encadenar la llamada a build. El límite no demuestra por sí solo que this sea de tipo T; un método abstracto self() permite que la subclase devuelva this sin conversión explícita de tipo.

T extends Comparable<? super T> permite pasar un valor de tipo T a compareTo, porque la comparación acepta T o un supertipo suyo. Comparable es invariante: a través de ChronoLocalDate, LocalDate implementa Comparable<ChronoLocalDate>, no Comparable<LocalDate>. Por eso LocalDate satisface el límite con el comodín de límite inferior ? super T, pero no Comparable<T> para T = LocalDate.

T extends Comparable<T> & Serializable exige tanto Comparable<T> como la interfaz marcadora Serializable. El límite no realiza la serialización ni garantiza que se pueda serializar todo el grafo de objetos; LocalDate no se admite aunque implemente Serializable. En cambio, T extends Entity & Prioritized exige que T sea Entity o una subclase y que implemente Prioritized. En ambas declaraciones, & indica una intersección de tipos, no un AND bit a bit. Si hay una clase en un límite múltiple, debe ir primero; después solo pueden aparecer interfaces. El primer límite determina el borrado de tipo de T.

Ejemplos

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

Resultado

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

`named` conserva el tipo `TaskBuilder`, y `describe` aprovecha ambos límites. `min`, `max` e `isBefore` aceptan valores `LocalDate`; `minSerializable` compara cadenas sin serializarlas.

Lecciones relacionadas

  • Java · Lección 11 · Avanzado · Versión: 2
  • Java · Lección 15 · Avanzado · Versión: 2
  • Java · Lección 16 · Avanzado · Versión: 2
  • Java · Lección 32 · Intermedio · Versión: 2

Fuentes