Builder-Pattern mit Fluent API
Erstellen Sie komplexe Objekte Schritt für Schritt mit einem Fluent Builder, um überladene Konstruktoren zu vermeiden.
Builder-Pattern mit Fluent API ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Das Problem überladener Konstruktoren
Wenn eine Klasse viele optionale Parameter besitzt, vervielfachen sich die Konstruktoren: mit 2, 3, 4 Parametern und so weiter. Das Builder-Muster löst dieses Problem mit einer flüssigen API zur schrittweisen Konfiguration.
// Without builder — hard to read:
Pizza p = new Pizza("large", "thin", true, false, true, false, "mozzarella");Grundstruktur des Builders
Erstellen Sie eine statisch verschachtelte Klasse Builder. Die äußere Klasse besitzt einen privaten Konstruktor, der den Builder entgegennimmt. Jeder Setter im Builder gibt für eine flüssige Verkettung this zurück.
public final class Pizza {
private final String size, crustType, cheese;
private final boolean extraSauce, pepperoni;
private Pizza(Builder b) {
this.size = b.size; this.crustType = b.crustType;
this.cheese = b.cheese; this.extraSauce = b.extraSauce;
this.pepperoni = b.pepperoni;
}
public static class Builder {
private final String size;
private String crustType = "regular", cheese = "mozzarella";
private boolean extraSauce, pepperoni;
public Builder(String size) { this.size = size; }
public Builder crustType(String c) { this.crustType = c; return this; }
public Builder cheese(String c) { this.cheese = c; return this; }
public Builder extraSauce() { this.extraSauce = true; return this; }
public Builder pepperoni() { this.pepperoni = true; return this; }
public Pizza build() { return new Pizza(this); }
}
}Verwendung der Fluent API
Der Builder liest sich wie ein Satz. Erforderliche Parameter werden im Konstruktor übergeben, optionale über Methodenaufrufe. Der abschließende Aufruf von build() erzeugt das unveränderliche Objekt.
Pizza p = new Pizza.Builder("large")
.crustType("thin")
.extraSauce()
.pepperoni()
.build();
System.out.println(p);Validierung in build()
Fügen Sie die Validierungslogik in build() ein, bevor Sie das Objekt erzeugen. Lösen Sie bei ungültigen Kombinationen IllegalStateException oder IllegalArgumentException aus.
public Pizza build() {
if (size == null || size.isBlank())
throw new IllegalArgumentException("Size required");
if (extraSauce && crustType.equals("stuffed"))
throw new IllegalStateException("No extra sauce on stuffed crust");
return new Pizza(this);
}Builder für unveränderliche Objekte
Da die äußere Klasse in einem einzigen Schritt aus dem Builder erzeugt wird, können alle Felder final sein. Dadurch ist das resultierende Objekt vollständig unveränderlich und threadsicher.
public final class Address {
private final String street, city, country;
private final String postalCode;
private Address(Builder b) { ... } // all finals
// no setters — immutable!
}Generischer Builder mit Self-Type
Verwenden Sie für Vererbungshierarchien einen rekursiven generischen Typparameter (SELF extends Builder<SELF>), damit Builder von Unterklassen aus verketteten Methoden den Typ der Unterklasse zurückgeben.
public abstract static class Builder<SELF extends Builder<SELF>> {
String name;
@SuppressWarnings("unchecked")
public SELF name(String n) { this.name = n; return (SELF) this; }
public abstract Vehicle build();
}Lombok @Builder
@Builder von Lombok erzeugt die gesamte Builder-Infrastruktur zur Kompilierzeit. Verwenden Sie @Builder.Default für Standardwerte von Feldern und @Singular für Collections.
@Builder
public class Report {
private final String title;
@Builder.Default private final int pageCount = 1;
@Singular private final List<String> authors;
}
// Usage:
Report r = Report.builder().title("Q4").author("Alice").author("Bob").build();Builder im JDK
Viele JDK-Klassen verwenden APIs im Builder-Stil: StringBuilder, HttpRequest.newBuilder(), ProcessBuilder, Stream.Builder. Lernen Sie, das Muster zu erkennen.
HttpRequest req = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/users"))
.header("Accept", "application/json")
.GET()
.build();Builder im Vergleich zur Factory
Verwenden Sie den Builder, wenn ein Objekt viele Parameter und eine schrittweise Konfiguration benötigt. Verwenden Sie eine Factory, wenn alle Varianten einfach sind und die Erzeugung mit einem einzigen Aufruf erfolgen kann.
Builder für Testdaten
Builder sind besonders bei Tests nützlich: Erstellen Sie in einer Hilfsmethode einen Basis-Builder und überschreiben Sie anschließend nur die für den jeweiligen Testfall relevanten Felder. So bleiben Tests DRY und gut lesbar.
User defaultUser() { return new User.Builder("test@example.com").name("Test User").build(); }
User adminUser() { return new User.Builder("admin@example.com").name("Admin").role(ADMIN).build(); }Threadsicherheit
Der Builder selbst ist nicht threadsicher – teilen Sie einen Builder nicht zwischen Threads. Das daraus erzeugte Produkt kann unveränderlich und threadsicher sein, wenn alle Felder final sind und keine veränderlichen Objekte gemeinsam verwendet werden.
Kurze Überprüfung
Was macht eine Builder-Methode „fluent“?
Zusammenfassung
Der Builder löst das Problem überladener Konstruktoren. Verwenden Sie eine statisch verschachtelte Builder-Klasse, geben Sie aus jedem Setter this zurück, validieren Sie in build() und erzeugen Sie ein unveränderliches Objekt. Lombok @Builder automatisiert den Boilerplate-Code.
Häufig gestellte Fragen
Ist die Lektion „Builder-Pattern mit Fluent API“ kostenlos?
Ja — der vollständige Text von „Builder-Pattern mit Fluent API“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Builder-Pattern mit Fluent API“?
Erstellen Sie komplexe Objekte Schritt für Schritt mit einem Fluent Builder, um überladene Konstruktoren zu vermeiden. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Builder-Pattern mit Fluent API“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Singleton: Threadsichere Implementierungen
- Factory-Method-Pattern
- Abstract Factory für Produktfamilien
- Builder-Pattern mit Fluent API