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
- Java Language Specification, Java SE 21, §4.4: Type Variables
- Java Language Specification, Java SE 21, §8.4.5: Method Result
- Java Language Specification, Java SE 21, §15.21.3: Reference Equality Operators == and !=
- Java SE 21 API: List.copyOf(Collection)
- Java SE 21 API: Objects.requireNonNull(T)
- JDK 21 Tool Specifications: The javac Command