KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Fluent builder met een zelftype

Met een generiek zelftype blijven methoden van de subklasse beschikbaar na een geërfde aanroep. `build()` maakt een afzonderlijk product op basis van de huidige toestand.

Versie: Java SE 21

Syntax

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.

Een wijzigbare builder verzamelt instellingen. tag(...) wijzigt de huidige builder en geeft via self() diezelfde instantie terug, niet een kopie of het eindproduct. == controleert hier of beide referenties naar hetzelfde object wijzen, niet of de inhoud gelijk is.

In TaskBuilder<S extends TaskBuilder<S>> komt S voor in zijn eigen bovengrens. PriorityTaskBuilder vult zijn eigen type in voor S, zodat je na de geërfde methode tag(...) direct priority(...) kunt aanroepen. Met de abstracte methode self() kan de concrete klasse this teruggeven zonder ongecontroleerde cast. De bovengrens dwingt niet af dat de subklasse haar eigen type opgeeft of dat self() de huidige instantie teruggeeft.

De basisdeclaratie van build() retourneert Task. De subklasse van de builder overschrijft de methode met het covariante retourtype PriorityTask, een subtype van Task. Dat is overriding, geen overloading. Via de base-referentie is het statische type van het resultaat Task, ook al wordt de methode van de subklasse uitgevoerd.

Elke aanroep van build() maakt een nieuw product dat de huidige toestand vastlegt. List.copyOf levert een niet-wijzigbare lijst die niet verandert bij latere wijzigingen aan de lijst van de builder. De kopie is oppervlakkig: String-elementen zijn onveranderlijk, maar bij veranderlijke elementen zijn extra defensieve kopieën nodig om hun toestand te isoleren. tag(null) gooit direct een NullPointerException, voordat de lijst verandert.

Voorbeelden

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

Resultaat

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

`true` bevestigt dat de keten dezelfde builder teruggeeft. Het toevoegen van `review` beïnvloedt alleen het tweede resultaat.

Gerelateerde lessen

  • Java · Les 3 · Gevorderd · Versie: 2
  • Java · Les 16 · Gevorderd · Versie: 2

Bronnen