it-swarm.com.de

Was ist der Unterschied zwischen Builder Design Pattern und Factory Design Pattern?

Was ist der Unterschied zwischen dem Builder-Designmuster und dem Factory-Designmuster? 

Welcher ist vorteilhafter und warum? 

Wie stelle ich meine Ergebnisse als Grafik dar, wenn ich diese Muster testen und vergleichen/vergleichen möchte?

525
Penguen

Bei Entwurfsmustern gibt es normalerweise keine "vorteilhaftere" Lösung, die in allen Fällen funktioniert. Es hängt davon ab, was Sie implementieren müssen.

Von Wikipedia: 

  • Builder konzentriert sich auf die Erstellung einer komplexes Objekt Schritt für Schritt. Abstrakt Factory betont eine Produktfamilie Objekte (entweder einfach oder komplex) . Der Builder gibt das Produkt als endgültiges .__ zurück. Schritt, aber soweit das Abstract Fabrik ist besorgt, das Produkt bekommt sofort zurückgegeben.
  • Builder erstellt häufig ein Composite.
  • Entwürfe beginnen oft mit der Factory-Methode (weniger kompliziert, mehr anpassbar, Unterklassen breiten sich aus) und entwickeln sich zur abstrakten Fabrik, Prototyp oder Builder (flexibler, Komplexer) als Designer entdeckt, wo mehr Flexibilität ist erforderlich.
  • Manchmal ergänzen sich Kreationsmuster: Builder kann eine .__ verwenden. der anderen zu implementierenden Muster Welche Komponenten werden gebaut? Abstrakt Factory, Builder und Prototype können Verwenden Sie Singleton in ihrer Implementierungen.

Wikipedia-Eintrag für das Fabrikmuster: http://en.wikipedia.org/wiki/Factory_method_pattern

Wikipedia-Eintrag für Builder-Entwurfsmuster: http://en.wikipedia.org/wiki/Builder_pattern

384
Adrian Grigore

A factory ist einfach eine Wrapper-Funktion um einen Konstruktor (möglicherweise eine andere Klasse). Der Hauptunterschied besteht darin, dass für ein Factory-Method-Muster das gesamte Objekt in einem einzigen Methodenaufruf erstellt werden muss, wobei alle Parameter in einer einzigen Zeile übergeben werden. Das endgültige Objekt wird zurückgegeben.

Ein Builder-Pattern dagegen ist im Wesentlichen ein Wrapper-Objekt, das alle möglichen Parameter enthält, die Sie möglicherweise in einen Konstruktoraufruf übergeben möchten. Auf diese Weise können Sie Setter-Methoden verwenden, um Ihre Parameterliste langsam aufzubauen. Eine zusätzliche Methode für eine Builder-Klasse ist eine build () - Methode, die das Builder-Objekt einfach an den gewünschten Konstruktor übergibt und das Ergebnis zurückgibt.

In statischen Sprachen wie Java wird dies wichtiger, wenn Sie mehr als eine Handvoll (potenziell optionaler) Parameter haben, da für alle möglichen Kombinationen von Parametern keine Teleskopkonstruktoren erforderlich sind. Mit einem Builder können Sie auch Setter-Methoden verwenden, um schreibgeschützte oder private Felder zu definieren, die nach dem Aufruf des Konstruktors nicht direkt geändert werden können.

Basisfabrikbeispiel

// Factory
static class FruitFactory {
    static Fruit create(name, color, firmness) {
        // Additional logic
        return new Fruit(name, color, firmness);
    }
}

// Usage
Fruit fruit = FruitFactory.create("Apple", "red", "crunchy");

Basic Builder Beispiel

// Builder
class FruitBuilder {
    String name, color, firmness;
    FruitBuilder setName(name)         { this.name     = name;     return this; }
    FruitBuilder setColor(color)       { this.color    = color;    return this; }
    FruitBuilder setFirmness(firmness) { this.firmness = firmness; return this; }
    Fruit build() {
        return new Fruit(this); // Pass in the builder
    }
}

// Usage
Fruit fruit = new FruitBuilder()
        .setName("Apple")
        .setColor("red")
        .setFirmness("crunchy")
        .build();

Es kann sich lohnen, die Codebeispiele dieser beiden Wikipedia-Seiten zu vergleichen:

http://en.wikipedia.org/wiki/Factory_method_pattern
http://en.wikipedia.org/wiki/Builder_pattern

261
James McGuigan

Das Factory-Muster kann fast als vereinfachte Version des Builder-Musters betrachtet werden.

Im Factory -Muster ist das Werk dafür verantwortlich, verschiedene Subtypen eines Objekts abhängig von den Anforderungen zu erstellen.

Der Benutzer einer Factory-Methode muss nicht den genauen Subtyp dieses Objekts kennen. Ein Beispiel für eine Factory-Methode createCar gibt möglicherweise ein Objekt vom Typ Ford oder Honda zurück.

Im Builder -Muster werden auch verschiedene Subtypen von einer Builder-Methode erstellt. Die Zusammensetzung der Objekte kann jedoch innerhalb derselben Unterklasse variieren.

Um das Fahrzeugbeispiel fortzusetzen, haben Sie möglicherweise eine Builder-Methode createCar, die ein Honda-typisiertes Objekt mit einem 4-Zylinder-Motor oder ein Honda- typisiertes Objekt mit 6 Zylindern erstellt. Das Builder-Muster ermöglicht diese feinere Granularität.

Diagramme sowohl des Builder Pattern als auch des Factory Method Pattern sind auf Wikipedia verfügbar.

255
Ben S

Das Builder-Entwurfsmuster beschreibt ein Objekt, das weiß, wie ein anderes Objekt eines bestimmten Typs in mehreren Schritten erstellt werden kann. Es enthält den erforderlichen Status für das Zielelement in jedem Zwischenschritt. Überlegen Sie, was StringBuilder durchläuft, um eine letzte Zeichenfolge zu erzeugen.

Das Factory-Design-Muster beschreibt ein Objekt, das in einem Schritt mehrere verschiedene, aber verwandte Objekttypen erstellen kann, wobei der bestimmte Typ auf der Grundlage vorgegebener Parameter ausgewählt wird. Denken Sie an das Serialisierungssystem, bei dem Sie Ihren Serializer erstellen und das gewünschte Objekt in einem einzigen Ladeaufruf erstellt.

53
Joel Coehoorn
  • Schritt für Schritt ein komplexes Objekt konstruieren: Builder-Muster

  • Ein einfaches Objekt wird mit einer einzigen Methode erstellt: Factory Method Pattern

  • Erstellen eines Objekts mithilfe mehrerer Fabrikmethoden: Abstraktes Fabrikmuster

40

Beide sind Schöpfungsmuster zum Erstellen von Objekten.

1) Factory Pattern - Angenommen, Sie haben eine Superklasse und N Anzahl von Unterklassen. Das Objekt wird erstellt, abhängig davon, welcher Parameter/Wert übergeben wird.

2) Builder-Muster - zum Erstellen komplexer Objekte.

Ex: Make a Loan Object. Loan could be house loan, car loan ,
    education loan ..etc. Each loan will have different interest rate, amount ,  
    duration ...etc. Finally a complex object created through step by step process.
13
Tony

Zuerst einige allgemeine Dinge, die meiner Argumentation folgen:

Die Hauptherausforderung beim Entwurf großer Softwaresysteme besteht darin, dass sie flexibel und unkompliziert sein müssen, um Änderungen vorzunehmen. Aus diesem Grund gibt es einige Metriken wie Kopplung und Kohäsion. Um Systeme zu schaffen, die leicht geändert oder in ihrer Funktionalität erweitert werden können, ohne dass das gesamte System von Grund auf neu gestaltet werden muss, können Sie den Konstruktionsprinzipien (wie SOLID usw.) folgen. Nach einiger Zeit erkannten einige Entwickler, dass es ähnliche Lösungen gibt, die bei ähnlichen Problemen gut funktionieren, wenn sie diesen Prinzipien folgen. Diese Standardlösungen erwiesen sich als Designmuster.

Die Entwurfsmuster sollen Sie dabei unterstützen, die allgemeinen Entwurfsprinzipien zu befolgen, um lose gekoppelte Systeme mit hoher Kohäsion zu erreichen.

Beantwortung der Frage:

Bei der Frage nach dem Unterschied zwischen zwei Mustern müssen Sie sich fragen, welches Muster Ihr System auf welche Weise flexibler macht. Jedes Muster hat seinen eigenen Zweck, um Abhängigkeiten zwischen Klassen in Ihrem System zu organisieren.

Das abstrakte Fabrikmuster: GoF: "Bereitstellung einer Schnittstelle zum Erstellen von Familien verwandter oder abhängiger Objekte, ohne deren konkrete Klassen anzugeben."

Was bedeutet das: Durch die Bereitstellung einer solchen Schnittstelle wird der Aufruf des Konstruktors jedes Produkts der Familie in der Factory-Klasse gekapselt. Und weil dies die einzige Stelle in Ihrem gesamten System ist, an der diese Konstruktoren aufgerufen werden, können Sie Ihr System ändern, indem Sie eine neue Factory-Klasse implementieren. Wenn Sie die Vertretung der Fabrik durch eine andere austauschen, können Sie eine ganze Reihe von Produkten austauschen, ohne den Großteil Ihres Codes zu berühren.

Das Builder-Muster: GoF: "Trennen Sie die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass derselbe Konstruktionsprozess unterschiedliche Repräsentationen erstellen kann."

Was bedeutet das: Sie kapseln den Konstruktionsprozess in einer anderen Klasse ein, die als Direktor (GoF) bezeichnet wird. Dieser Director enthält den Algorithmus zum Erstellen neuer Instanzen des Produkts (z. B. Erstellen eines komplexen Produkts aus anderen Teilen). Um die integralen Bestandteile des gesamten Produkts zu erstellen, verwendet der Regisseur einen Builder. Durch den Austausch des Builders im Director können Sie den gleichen Algorithmus verwenden, um das Produkt zu erstellen, aber die Repräsentationen einzelner Teile (und damit die Repräsentation des Produkts) ändern. Um Ihr System in der Darstellung des Produkts zu erweitern oder zu ändern, müssen Sie lediglich eine neue Builder-Klasse implementieren.

Also in Kürze: Das Abstract Factory Pattern hat den Zweck, eine Reihe von Produkten auszutauschen, die zusammen verwendet werden sollen. Das Builder-Pattern dient dazu, den abstrakten Algorithmus der Erstellung eines Produkts zu kapseln, um es für verschiedene Darstellungen des Produkts wiederzuverwenden.

Meiner Meinung nach kann man nicht sagen, dass das Abstract Factory Pattern der große Bruder des Builder Patterns ist. JA, es sind beide Schöpfungsmuster, aber die Hauptabsicht der Muster ist völlig unterschiedlich.

10
Janis

Builder Pattern und Factory Pattern, beide scheinen nackten Augen sehr ähnlich zu sein, da beide Objekte für Sie erstellen.

Aber Sie müssen genauer hinschauen

Dieses Beispiel aus der Praxis macht den Unterschied zwischen den beiden klarer. 

Angenommen, Sie sind in ein Fast-Food-Restaurant gegangen und haben Food bestellt. 

1) Welches Essen?

Pizza 

2) Welche Toppings?

Capsicum, Tomate, BBQ Chicken, NO ANANAS 

So werden verschiedene Arten von Lebensmitteln durch Factory-Muster hergestellt, aber die verschiedenen Varianten (Aromen) eines bestimmten Lebensmittels werden durch Builder-Muster hergestellt. 

Verschiedene Arten von Lebensmitteln

Pizza, Burger, Pasta 

Varianten von Pizza

Nur Käse, Käse + Tomaten + Capsicum, Käse + Tomaten usw. 

Codebeispiel

Die Beispielcode-Implementierung beider Muster finden Sie hier
Builder Pattern
Fabrikmuster

7
Rohit Singh

Ein auffallender Unterschied zwischen Builder und Fabrik, den ich feststellen konnte, war folgender:

nehmen wir an, wir haben ein Auto

class Car
{
  bool HasGPS;
  bool IsCityCar;
  bool IsSportsCar;
  int   Cylenders;
  int Seats;

  public:
     void Car(bool hasGPs=false,bool IsCityCar=false,bool IsSportsCar=false, int Cylender=2, int Seats=4);
 };

In der obigen Schnittstelle können Sie das Auto auf folgende Weise erhalten:

 int main()
 {
    BadCar = new Car(false,false,true,4,4);
  }

aber was passiert, wenn beim Erstellen der Sitze eine Ausnahme auftritt ??? SIE ERHALTEN DAS OBJEKT NICHT AT ALL //BUT

angenommen, Sie haben eine Implementierung wie die folgende 

class Car
 {
    bool mHasGPS;
    bool mIsCityCar;
    bool mIsSportsCar;
    int mCylenders;
    int mSeats;

 public:
    void Car() : mHasGPs(false), mIsCityCar(false), mIsSportsCar(false), mCylender(2), mSeats(4) {}
    void SetGPS(bool hasGPs=false)  {mHasGPs = hasGPs;}
    void SetCity(bool CityCar)  {mIsCityCar = CityCar;}
    void SetSports(bool SportsCar)  {mIsSportsCar = SportsCar;}
    void SetCylender(int Cylender)  {mCylenders = Cylender;}    
    void SetSeats(int seat) {mSeats = seat;}    
};

 class CarBuilder 
 {
    Car* mCar;
public:
        CarBuilder():mCar(NULL) {   mCar* = new Car();  }
        ~CarBuilder()   {   if(mCar)    {   delete mCar;    }
        Car* GetCar()   {   return mCar; mCar=new Car();    }
        CarBuilder* SetSeats(int n) {   mCar->SetSeats(n); return this; }
        CarBuilder* SetCylender(int n)  {   mCar->SetCylender(n); return this;  }
        CarBuilder* SetSports(bool val) {   mCar->SetSports(val); return this;  }
        CarBuilder* SetCity(bool val)   {   mCar->SetCity(val); return this;    }
        CarBuilder* SetGPS(bool val)    {   mCar->SetGPS(val); return this; }
}

Jetzt können Sie so erstellen 

 int main()
 {
   CarBuilder* bp =new CarBuilder;
    Car* NewCar  = bp->SetSeats(4)->SetSports(4)->SetCity(ture)->SetGPS(false)->SetSports(true)->GetCar();

     bp->SetSeats(2);

     bp->SetSports(4);

     bp->SetCity(ture);

     bp->SetSports(true)

     Car* Car_II=  bp->GetCar();

  }

Im zweiten Fall würden Sie das Auto auch erhalten, wenn eine Operation fehlschlägt.

Möglicherweise funktioniert das Auto später nicht perfekt, aber Sie hätten das Objekt.

Denn Factory-Methode gibt Ihnen das Auto in einem einzigen Anruf, während der Builder einen nach dem anderen erstellt.

Obwohl, es hängt von den Bedürfnissen der Persönlichkeit ab, für welche sie sich entscheiden.

6
Fooo

Builder und Abstract Factory waren für unterschiedliche Zwecke gedacht. Abhängig vom richtigen Anwendungsfall müssen Sie ein geeignetes Entwurfsmuster auswählen. 

Builder Hauptmerkmale:

  1. Das Builder-Muster erstellt ein komplexes Objekt mit einfachen Objekten und Schritt für Schritt
  2. Eine Builder-Klasse erstellt das endgültige Objekt Schritt für Schritt. Dieser Builder ist unabhängig von anderen Objekten
  3. Ersatz für die Factory-Methode/Abstract Factory in diesem Szenario: Zu viele Argumente, die vom Client-Programm an die Factory-Klasse übergeben werden können, die fehleranfällig sein können
  4. Einige Parameter können optional sein, im Gegensatz zu Factory, das das Senden aller Parameter erzwingt

Factory (einfache Factory) -Auffälligkeiten:

  1. Kreationelle Muster
  2. Basierend auf Vererbung
  3. Factory gibt eine Factory-Methode (Schnittstelle) zurück, die wiederum Betonobjekt zurückgibt
  4. Sie können die Schnittstelle und den Client (Aufrufer) durch neue konkrete Objekte ersetzen, wenn Sie nicht alle konkreten Implementierungen kennen
  5. Der Client greift immer nur auf die Benutzeroberfläche zu und Sie können die Objekterstellungsdetails in der Factory-Methode ausblenden.

Entwürfe beginnen häufig mit Factory-Methode (weniger kompliziert, anpassbarer, Unterklassen breiten sich aus) und entwickeln sich in Richtung Abstract Factory, Prototyp oder Builder (flexibler, komplexer) ) 

Schauen Sie sich verwandte Beiträge an:

Builder in separaten Klassen (fließende Schnittstelle)

Design Patterns: Factory vs Factory Methode vs Abstrakte Fabrik

Weitere Informationen finden Sie in den folgenden Artikeln:

Sourcemaking

journaldev

4
Ravindra babu
+-------------------------------------------------------------------+---------------------------------------------------+
|                              Builder                              |                      Factory                      |
+-------------------------------------------------------------------+---------------------------------------------------+
| Return only single instance to handle complex object construction | Retrun various instances on multiple constructors |
| No interface required                                             | Interface driven                                  |
| Inner classes is involved (to avoid telescopic constructors)      | Subclasses are involved                           |
+-------------------------------------------------------------------+---------------------------------------------------+  

Teleskopkonstruktormuster

Analogie: 

  • Factory: Betrachten Sie ein Restaurant. Die Erstellung von "today meal" ist ein Fabrikmuster, denn Sie sagen der Küche "holt mir heute Mahlzeit" und die Küche (Fabrik) entscheidet anhand versteckter Kriterien, welches Objekt erzeugt werden soll.
  • Builder: Der Builder wird angezeigt, wenn Sie eine benutzerdefinierte Pizza bestellen. In diesem Fall sagt der Kellner dem Chef (Baumeister): "Ich brauche eine Pizza; fügen Sie Käse, Zwiebeln und Speck hinzu!" Der Builder macht also die Attribute des generierten Objekts verfügbar, verbirgt jedoch die Einstellung.

Höflichkeit

4
Premraj

Abstract Factory & Builder Pattern sind beide Creation Patterns, haben aber unterschiedliche Absichten.

Abstract Factory Pattern betont die Objekterstellung für Familien verwandter Objekte, bei denen:

  • Jede Familie besteht aus einer Gruppe von Klassen, die von einer gemeinsamen Basisklasse/Schnittstelle abgeleitet werden.
  • Jedes Objekt wird sofort als Ergebnis eines Anrufs zurückgegeben.

Builder Pattern konzentriert sich darauf, ein komplexes Objekt Schritt für Schritt zu konstruieren. Sie entkoppelt die Repräsentation vom Konstruktionsprozess des komplexen Objekts, sodass derselbe Konstruktionsprozess für verschiedene Repräsentationen verwendet werden kann.

  • Das Builder-Objekt kapselt die Konfiguration des komplexen Objekts.
  • Das Director-Objekt kennt das Protokoll zur Verwendung des Builders, wobei das Protokoll .__ alle logischen Schritte definiert, die zum Erstellen des komplexen Objekts erforderlich sind. 
3
Saurabh Kumar

Eine komplexe Konstruktion ist, wenn das zu konstruierende Objekt aus verschiedenen anderen Objekten besteht, die durch Abstraktionen dargestellt werden.

Betrachten Sie ein Menü in McDonalds. Ein Menü enthält ein Getränk, eine Haupt- und eine Seite. Abhängig davon, welche Nachkommen der einzelnen Abstraktionen zusammengesetzt sind, hat das erstellte Menü eine andere Darstellung.

  1. Beispiel: Cola, Big Mac, Pommes Frites
  2. Beispiel: Sprite, Nuggets, Curly Fries

Dort haben wir zwei Instanzen des Menüs mit unterschiedlichen Darstellungen erhalten. Der Bauprozess bleibt wiederum derselbe. Sie erstellen ein Menü mit einem Getränk, einer Haupt- und einer Seite.

Mit dem Builder-Muster trennen Sie den Algorithmus zum Erstellen eines komplexen Objekts von den verschiedenen Komponenten, die für die Erstellung verwendet wurden.

In Bezug auf das Builder-Muster wird der Algorithmus im Director verkapselt, während die Builder zum Erstellen der integralen Teile verwendet werden. Das Ändern des verwendeten Builders im Algorithmus des Direktors führt zu einer anderen Darstellung, da andere Teile zu einem Menü zusammengesetzt sind. Die Art und Weise, wie ein Menü erstellt wird, bleibt gleich.

2
Janis

Beide sind sich sehr ähnlich. Wenn Sie jedoch eine große Anzahl von Parametern für die Objekterstellung haben, von denen einige optional sind und einige Standardwerte enthalten, wählen Sie das Builder-Muster.

1
Praveen Kumar

Der Hauptunterschied zwischen ihnen besteht darin, dass das Builder-Muster hauptsächlich die schrittweise Erstellung komplexer Objekte beschreibt. Im Muster der abstrakten Fabrik liegt der Schwerpunkt auf Familien von Gegenständen-Produkten. Builder gibt das Produkt im letzten Schritt zurück. Im Abstract Factory-Muster ist das Produkt sofort verfügbar.

Beispiel: Angenommen, wir erstellen Maze

1. Abstrakte Fabrik:

Maze* MazeGame::CreateMaze (MazeFactory& factory) {
Maze* maze = factory.MakeMaze(); /// product is available at start!!
 /* Call some methods on maze */
return maze;
}

2. Builder:

Maze* MazeGame::CreateMaze (MazeBuilder& builder) {
builder.buildMaze(); /// We don't have access to maze
 /* Call some methods on builder */
return builder.GetMaze();
}
1
XYZ123

Ich glaube, die Verwendung und der Unterschied zwischen Factory- und Builder-Mustern können in einem bestimmten Zeitraum leichter verstanden/geklärt werden, da Sie an derselben Codebasis und an sich ändernden Anforderungen gearbeitet haben. 

Nach meiner Erfahrung beginnen Sie normalerweise mit einem Factory-Muster, das einige statische Erstellermethoden enthält. Wenn Ihre Objekthierarchie komplexer wird (oder Sie mehr Typen hinzufügen), werden Ihre Methoden wahrscheinlich mit mehr Parametern gefüllt, und ganz zu schweigen davon, dass Sie Ihr Factory-Modul neu kompilieren müssen. All dies erhöht die Komplexität Ihrer Erstellermethoden, verringert die Lesbarkeit und macht das Erstellungsmodul anfälliger.

Dieser Punkt wird möglicherweise der Übergangspunkt sein. Übergang vom Fabrik zum Builder-Muster. Auf diese Weise erstellen Sie ein Wrapper-Modul um die Konstruktionsparameter und können dann neue (ähnliche) Objekte darstellen, indem Sie (möglicherweise) weitere Abstraktionen und Implementierungen hinzufügen, ohne Ihre Erstellungslogik zu berühren. Sie hatten also eine weniger komplexe Logik und einen neu kompilierten Quellcode

Ehrlich gesagt, es ist der Unterschied, wenn man sich auf eine Art "Objekt in einem Schritt oder in mehreren Schritten" bezieht, da der einzige Diversitätsfaktor für mich nicht ausreichte, um sie zu unterscheiden, da ich beide Möglichkeiten für fast alle Fälle verwenden konnte, die ich vor mir hatte jetzt ohne Nutzen zu erfahren. Das ist, was ich endlich darüber nachgedacht habe.

1
stdout

Der Unterschied ist klar Im Builder-Muster erstellt der Builder einen bestimmten Objekttyp für Sie. Sie müssen sagen, welcher Builder errichten soll. Im Factory-Pattern erstellen Sie mit Hilfe der abstrakten Klasse das spezifische Objekt direkt.

Die Builder-Klasse fungiert hier als Vermittler zwischen Haupt- und bestimmten Typklassen . Mehr Abstraktion.

1
user2738678

Factory : Wird zum Erstellen einer Instanz eines Objekts verwendet, bei dem die Abhängigkeiten des Objekts vollständig von der Factory gehalten werden. Für das Musterabstract factorygibt es oft viele konkrete Implementierungen derselben abstrakten Fabrik. Die richtige Implementierung der Fabrik wird über Abhängigkeitseinspritzung eingespritzt.

Builder : Wird zum Erstellen vonimmutableobjects verwendet, wenn die Abhängigkeiten des zu instanziierenden Objekts teilweise im Voraus bekannt sind und teilweise vom Client des Builders bereitgestellt werden.

0
Hamady C.

Build-Muster betont Komplexität des Objekterstellens (gelöst durch "Schritte")

Das abstrakte Muster betont "nur" die "Abstraktion" von (mehreren, aber verwandten) Objekten.

0
Sandeep Jindal

Baumeister und abstrakte Fabrik

Das Builder-Entwurfsmuster ist in gewissem Maße dem Muster der abstrakten Fabrik sehr ähnlich. Deshalb ist es wichtig, zwischen den Situationen unterscheiden zu können, in denen die eine oder die andere verwendet wird. Im Falle der abstrakten Fabrik verwendet der Client die Methoden der Fabrik, um eigene Objekte zu erstellen. Im Fall des Builders wird die Builder-Klasse über das Erstellen des Objekts informiert und danach gefragt, aber wie die Klasse zusammengestellt wird, hängt von der Builder-Klasse ab. Dieses Detail macht den Unterschied zwischen den beiden Mustern.

Gemeinsame Schnittstelle für Produkte

In der Praxis weisen die von den Betonbauer erstellten Produkte eine deutlich andere Struktur auf. Wenn also kein Grund besteht, verschiedene Produkte von einer gemeinsamen übergeordneten Klasse abzuleiten. Dies unterscheidet auch das Builder-Muster vom Abstract Factory-Muster, das Objekte erzeugt, die von einem allgemeinen Typ abgeleitet sind.

Von: http://www.oodesign.com/builder-pattern.html

0
Arturas M

Beide Muster haben dieselbe Notwendigkeit: Verbergen Sie vor einem Client-Code die Konstruktionslogik eines komplexen Objekts. Aber was macht "komplex" (oder manchmal kompliziert) zu einem Objekt? Dies ist hauptsächlich auf Abhängigkeiten oder eher auf den Zustand eines Objekts zurückzuführen, das aus mehreren Teilzuständen besteht. Abhängigkeiten können vom Konstruktor eingefügt werden, um den anfänglichen Objektstatus festzulegen, aber ein Objekt kann viele davon erfordern. Einige befinden sich in einem Standard-Anfangszustand (nur weil wir wissen sollten, dass das Festlegen einer Standardabhängigkeit auf null nicht die sauberste Methode ist) ) und einige andere auf einen Zustand eingestellt, der von einer Bedingung getrieben wird. Darüber hinaus gibt es Objekteigenschaften, die eine Art "nicht wahrnehmbare Abhängigkeiten" darstellen, aber auch optionale Zustände annehmen können.

es gibt zwei bekannte Möglichkeiten, diese Komplexität zu beherrschen:

  • Zusammensetzung/Aggregation: Konstruieren Sie ein Objekt, konstruieren Sie die abhängigen Objekte und verbinden Sie es dann miteinander. Hier kann ein Builder den Prozess transparent und flexibel machen, der die Regeln bestimmt, die für die Bauteilkonstruktion maßgeblich sind.

  • Polymorphismus: Konstruktionsregeln werden direkt in der Untertypdefinition deklariert. Daher haben Sie für jeden Untertyp einen Satz von Regeln. Einige Bedingungen bestimmen, welche der Regeln für die Konstruktion des Objekts gilt. Eine Fabrik passt perfekt in dieses Szenario.

Nichts hindert diese beiden Ansätze zu vermischen. Eine Produktfamilie könnte die mit einem Builder erstellte Objekterstellung abstrahieren, ein Builder könnte mithilfe von Fabriken ermitteln, welches Komponentenobjekt instanziiert wird.

0
Carmine Ingaldi

Meiner bescheidenen Meinung nach

Builder ist eine Art komplexere Fabrik.

In Builder können Sie jedoch Objekte mit anderen Factories instanziieren, die zum Erstellen des endgültigen und gültigen Objekts erforderlich sind.

Wenn Sie also über die Entwicklung von "Kreationellen Mustern" nach Komplexität sprechen, können Sie auf folgende Weise darüber nachdenken:

Dependency Injection Container -> Service Locator -> Builder -> Factory
0
v.babak

Meiner Meinung nach wird das Builder-Muster verwendet, wenn Sie ein Objekt aus einer Reihe anderer Objekte erstellen möchten und das Erstellen eines Teils unabhängig von dem Objekt sein muss, das Sie erstellen möchten. Es hilft, die Erstellung eines Teils vor dem Client zu verbergen, um Builder und Client unabhängig zu machen. Es wird für die Erstellung komplexer Objekte verwendet (Objekte, die aus komplizierten Eigenschaften bestehen können)

Während des Factory-Musters wird angegeben, dass Sie Objekte einer gemeinsamen Familie erstellen möchten und dass diese auf einmal zertifiziert werden sollen. Es wird für einfachere Objekte verwendet. 

0
AjayLohani