WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Fluent Builder mit Selbsttyp

Ein generischer Selbsttyp hält Unterklassenmethoden nach geerbten Aufrufen verfügbar. `build()` erzeugt aus dem aktuellen Zustand des Builders ein separates Produkt.

Version: 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.

Ein veränderlicher Builder sammelt Einstellungen. tag(...) ändert den aktuellen Builder und gibt über self() dieselbe Instanz zurück, weder eine Kopie noch ein fertiges Produkt. == prüft hier die Objektidentität, nicht die Gleichheit des Inhalts.

In TaskBuilder<S extends TaskBuilder<S>> kommt S in seiner eigenen oberen Typgrenze vor. PriorityTaskBuilder setzt den eigenen Typ für S ein, sodass auf das geerbte tag(...) ein Aufruf von priority(...) folgen kann. Mit dem abstrakten self() kann die konkrete Klasse this ohne ungeprüfte Typumwandlung zurückgeben. Die Typgrenze allein erzwingt weder den eigenen Typ der Unterklasse als Argument noch die Rückgabe der aktuellen Instanz.

Die Basisdeklaration von build() liefert Task. Die Builder-Unterklasse überschreibt die Methode mit dem kovarianten Rückgabetyp PriorityTask, einem Untertyp von Task; sie überlädt die Methode nicht. Über die Referenz base hat das Ergebnis den statischen Typ Task, obwohl zur Laufzeit die Methode der Unterklasse ausgeführt wird.

Jeder Aufruf von build() erzeugt ein neues Produkt mit dem aktuellen Zustand. List.copyOf liefert eine nicht veränderbare Liste, die von späteren Änderungen an der Builder-Liste unberührt bleibt. Die Kopie ist flach: String-Elemente sind unveränderlich, bei veränderlichen Elementen wären zusätzliche defensive Kopien nötig, um ihren Zustand zu isolieren. tag(null) löst sofort eine NullPointerException aus, bevor sich die Liste ändert.

Beispiele

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

Ergebnis

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

`true` bestätigt, dass die Aufrufkette denselben Builder zurückgibt. Das Hinzufügen von `review` wirkt sich nur auf das zweite Ergebnis aus.

Zugehörige Lektionen

  • Java · Lektion 3 · Fortgeschritten · Version: 2
  • Java · Lektion 16 · Fortgeschritten · Version: 2

Quellen