Builder-Muster

Das Builder-Muster ist ein Erzeugungsmuster, das es ermöglicht, die Schritte zur Erstellung eines komplexen Objekts von seiner Darstellung zu trennen.

Das Builder-Muster ist ein Erzeugungsmuster, dessen Hauptzweck darin besteht, den Konstruktionsprozess eines komplexen Objekts von seiner Darstellung zu trennen, sodass Objekte mit unterschiedlichen Darstellungen erstellt werden können.

summary

Absicht

Trennen Sie einen komplexen Konstruktionsprozess von seiner Darstellung, sodass derselbe Konstruktionsprozess unterschiedliche Darstellungen erzeugen kann.

Hauptsächlich gelöstes Problem

In Softwaresystemen besteht die Erstellung eines komplexen Objekts normalerweise aus mehreren Teilen; die Kombinationen dieser Teile ändern sich oft, aber der Kombinationsalgorithmus ist relativ stabil.

Wann verwenden

Wenn einige grundlegende Komponenten unverändert bleiben, sich ihre Kombinationen jedoch häufig ändern.

Lösung

Trenne die sich ändernden und die unveränderlichen Teile.

Schlüsselcode

  • BuilderErzeuge und stelle eine Instanz bereit.
  • director: Verwalte die Abhängigkeiten erzeugter Instanzen und steuere den Konstruktionsprozess.

Anwendungsbeispiel

  • Bei KFC sind Hamburger, Cola, Pommes, frittierte Hähnchenflügel usw. unverändert, aber ihre Kombinationen ändern sich häufig, wodurch verschiedene "Combos" entstehen.
  • In JavaStringBuilder。

Vorteile

  • Die Trennung des Konstruktionsprozesses von der Repräsentation macht den Konstruktionsprozess flexibler und ermöglicht den Aufbau unterschiedlicher Repräsentationen.
  • Es kann den Konstruktionsprozess besser steuern und spezifische Konstruktionsdetails verbergen.
  • Hohe Wiederverwendbarkeit des Codes; derselbe Builder kann in verschiedenen Konstruktionsprozessen wiederverwendet werden.

Nachteile

  • Wenn das Produkt nur wenige Attribute hat, kann das Builder-Muster zu Code-Redundanz führen.
  • Erhöht die Anzahl der Klassen und Objekte im System.

Anwendungsfall

  • Das zu erzeugende Objekt hat eine komplexe interne Struktur.
  • Die internen Attribute des zu erzeugenden Objekts sind voneinander abhängig.

Hinweise

Der Unterschied zum Factory-Muster besteht darin, dass das Builder-Muster sich stärker auf die Reihenfolge der Teilemontage konzentriert.

Struktur

Das Builder-Muster umfasst die folgenden Hauptrollen:

  • Produkt: Das komplexe Objekt, das erstellt werden soll. Die Produktklasse enthält normalerweise mehrere Teile oder Attribute.

  • Abstrakter Builder: Definiert die abstrakte Schnittstelle zum Erstellen des Produkts, einschließlich Methoden zum Erstellen der verschiedenen Teile des Produkts.

  • Konkreter Builder: Implementiert die abstrakte Builder-Schnittstelle, legt konkret fest, wie die verschiedenen Teile des Produkts erstellt werden, und ist dafür verantwortlich, das fertig erstellte Produkt zurückzugeben.

  • Direktor: Verantwortlich für den Aufruf der Methoden des Builders zum Konstruieren des Produkts. Der Direktor versteht den spezifischen Konstruktionsprozess nicht, sondern kümmert sich nur um die Reihenfolge und Art der Produktkonstruktion.

Implementierung

Nehmen wir einen Geschäftsfall für ein Fast-Food-Restaurant an, bei dem ein typisches Menü aus einem Burger und einem Kaltgetränk bestehen kann. Der Burger kann ein Veg Burger oder ein Chicken Burger sein, und sie werden in einem Karton verpackt. Das Kaltgetränk kann Coca-Cola (coke) oder Pepsi (pepsi) sein, und sie sind in Flaschen.

Wir werden eine Entitätsklasse erstellen, die Lebensmittelartikel (wie Burger und Kaltgetränke) repräsentiert.ItemSchnittstelle und ImplementierungItemDie Entitätsklasse der Schnittstelle und eine Entitätsklasse, die Lebensmittelverpackungen repräsentiert.PackingSchnittstelle und ImplementierungPackingDie Entitätsklasse der Schnittstelle; Burger werden in Kartons verpackt und Kaltgetränke sind in Flaschen.

Dann erstellen wir eineMeal-Klasse, mit einerItem-ArrayListund einen, indem manItemkombiniert, um verschiedene Typen vonMealObjekt-MealBuilder zu erstellen。BuilderPatternDemoKlassenverwendungMealBuilderzum Erstellen einesMeal。

建造者模式的 UML 图

Schritt 1

Erstellen Sie eine Schnittstelle, die Lebensmittelartikel und Lebensmittelverpackung repräsentiert.

Item.java

public interface Item { public String name(); public Packing packing(); public float price(); }

Packing.java

public interface Packing { public String pack(); }

Schritt 2

Erstellen Sie Entitätsklassen, die die Packing-Schnittstelle implementieren.

Wrapper.java

public class Wrapper implements Packing { @Override public String pack() { return "Wrapper"; } }

Bottle.java

public class Bottle implements Packing { @Override public String pack() { return "Bottle"; } }

Schritt 3

Erstelle eine abstrakte Klasse, die das Item-Interface implementiert und Standardfunktionalität bereitstellt.

Burger.java

public abstract class Burger implements Item { @Override public Packing packing() { return new Wrapper(); } @Override public abstract float price(); }

ColdDrink.java

public abstract class ColdDrink implements Item { @Override public Packing packing() { return new Bottle(); } @Override public abstract float price(); }

Schritt 4

Erstelle Entitätsklassen, die Burger und ColdDrink erweitern.

VegBurger.java

public class VegBurger extends Burger { @Override public float price() { return 25.0f; } @Override public String name() { return "Vegetarischer Burger"; } }

ChickenBurger.java

public class ChickenBurger extends Burger { @Override public float price() { return 50.5f; } @Override public String name() { return "Hähnchenburger"; } }

Coke.java

public class Coke extends ColdDrink { @Override public float price() { return 30.0f; } @Override public String name() { return "Coke"; } }

Pepsi.java

public class Pepsi extends ColdDrink { @Override public float price() { return 35.0f; } @Override public String name() { return "Pepsi"; } }

Schritt 5

Erstelle eine Meal-Klasse, die die oben definierten Item-Objekte enthält.

Meal.java

import java.util.ArrayList; import java.util.List; public class Meal { private List<Item> items = new ArrayList<Item>(); public void addItem(Item item){ items.add(item); } public float getCost(){ float cost = 0.0f; for (Item item : items) { cost += item.price(); } return cost; } public void showItems(){ for (Item item : items) { System.out.print("Artikel : "+item.name()); System.out.print(", Verpackung : "+item.packing().pack()); System.out.println(", Preis : "+item.price()); } } }

Schritt 6

Erstellen Sie eine MealBuilder-Klasse, die eigentliche Builder-Klasse, die für die Erstellung von Meal-Objekten verantwortlich ist.

MealBuilder.java

public class MealBuilder { public Meal prepareVegMeal (){ Meal meal = new Meal(); meal.addItem(new VegBurger()); meal.addItem(new Coke()); return meal; } public Meal prepareNonVegMeal (){ Meal meal = new Meal(); meal.addItem(new ChickenBurger()); meal.addItem(new Pepsi()); return meal; } }

Schritt 7

BuiderPatternDemo verwendet MealBuilder, um das Builder-Muster zu demonstrieren.

BuilderPatternDemo.java

public class BuilderPatternDemo { public static void main(String[] args) { MealBuilder mealBuilder = new MealBuilder(); Meal vegMeal = mealBuilder.prepareVegMeal(); System.out.println("Vegetarisches Essen"); vegMeal.showItems(); System.out.println("Gesamtkosten: " +vegMeal.getCost()); Meal nonVegMeal = mealBuilder.prepareNonVegMeal(); System.out.println("\n\nNicht-vegetarisches Essen"); nonVegMeal.showItems(); System.out.println("Gesamtkosten: " +nonVegMeal.getCost()); } }

Schritt 8

Führen Sie das Programm aus, geben Sie das Ergebnis aus:

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0


Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

Ähnliche Artikel

Weitere Erweiterungen