Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Builder fluente con tipo proprio

Un tipo proprio generico mantiene accessibili i metodi della sottoclasse dopo una chiamata ereditata. `build()` crea un prodotto separato a partire dallo stato corrente.

Versione: Java SE 21

Sintassi

Declaration sketch (method bodies omitted):
abstract class TaskBuilder<S extends TaskBuilder<S>> {
    protected abstract S self();
    public final S tag(String value) { /* mutate this builder, then return self() */ }
    public abstract Task build();
}
final class PriorityTaskBuilder extends TaskBuilder<PriorityTaskBuilder> {
    @Override protected PriorityTaskBuilder self() { return this; }
    @Override public PriorityTask build() { /* return a new product */ }
}
// PriorityTask extends Task.

Un builder mutabile accumula le impostazioni. tag(...) modifica il builder corrente e, tramite self(), restituisce la stessa istanza, non una copia né il prodotto finito. Qui == verifica l’identità dell’oggetto, non l’uguaglianza del contenuto.

In TaskBuilder<S extends TaskBuilder<S>>, S compare nel proprio limite superiore. PriorityTaskBuilder usa il proprio tipo come S, quindi dopo il metodo ereditato tag(...) si può chiamare priority(...). Il metodo astratto self() consente alla classe concreta di restituire this senza un cast non verificato. Il limite da solo non impone né che la sottoclasse usi il proprio tipo né che self() restituisca l’istanza corrente.

La dichiarazione di base di build() restituisce Task. La sottoclasse del builder ridefinisce il metodo con il tipo di ritorno covariante PriorityTask, sottotipo di Task: si tratta di override, non di overload. Attraverso il riferimento base, il risultato ha tipo statico Task, anche se viene eseguito il metodo della sottoclasse.

Ogni chiamata a build() crea un nuovo prodotto che cattura lo stato corrente. List.copyOf restituisce una lista non modificabile che non risente delle modifiche successive alla lista del builder. La copia è superficiale: gli elementi String sono immutabili, ma con elementi mutabili servirebbero ulteriori copie difensive per isolarne lo stato. tag(null) lancia subito NullPointerException, prima di modificare la lista.

Esempi

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class FluentBuilderDemo {
    static class Task {
        private final List<String> tags;

        private Task(TaskBuilder<?> builder) {
            tags = List.copyOf(builder.tags);
        }

        public final List<String> tags() {
            return tags;
        }
    }

    static final class PriorityTask extends Task {
        private final int priority;

        private PriorityTask(PriorityTaskBuilder builder) {
            super(builder);
            priority = builder.priority;
        }

        public int priority() {
            return priority;
        }
    }

    static abstract class TaskBuilder<S extends TaskBuilder<S>> {
        private final List<String> tags = new ArrayList<>();

        protected abstract S self();

        public final S tag(String value) {
            tags.add(Objects.requireNonNull(value, "tag"));
            return self();
        }

        public abstract Task build();
    }

    static final class PriorityTaskBuilder extends TaskBuilder<PriorityTaskBuilder> {
        private int priority;

        @Override
        protected PriorityTaskBuilder self() {
            return this;
        }

        public PriorityTaskBuilder priority(int value) {
            priority = value;
            return self();
        }

        @Override
        public PriorityTask build() {
            return new PriorityTask(this);
        }
    }

    public static void main(String[] args) {
        PriorityTaskBuilder builder = new PriorityTaskBuilder();
        System.out.println(builder.tag("draft").priority(5) == builder);

        TaskBuilder<PriorityTaskBuilder> base = builder;
        Task first = base.build();
        PriorityTask second = builder.tag("review").build();

        System.out.println("first: " + String.join(", ", first.tags()));
        System.out.println("second: " + String.join(", ", second.tags()));
        System.out.println("priority: " + second.priority());
    }
}

Risultato

true
first: draft
second: draft, review
priority: 5

`true` conferma che la catena restituisce lo stesso builder. L’aggiunta di `review` influisce sul secondo risultato, ma non sul primo.

Lezioni correlate

  • Java · Lezione 3 · Avanzato · Versione: 2
  • Java · Lezione 16 · Avanzato · Versione: 2

Fonti