Was ist der Unterschied zwischen dem Builder-Design-Muster und dem Factory-Design-Muster?

Question

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

Welches ist vorteilhafter und warum?

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

Answer 1

Mit Entwurfsmuster gibt es in der Regel keine „vorteilhafte“ Lösung, die für alle Fälle funktioniert. Es hängt davon ab, was Sie implementieren müssen.

Aus Wikipedia:

  

  
• Builder konzentriert sich ein auf den Bau   komplexes Objekt Schritt für Schritt. Abstrakt   Fabrik legt Wert auf eine Familie von Produkt   Objekte (entweder einfach oder komplex).   Builder liefert das Produkt als abschließendes   Schritt, aber so weit wie die Zusammenfassung   Factory ist besorgt, das Produkt bekommt   sofort zurückgegeben.
  
• Builder baut oft über einen Composite.
  
• Oft Designs beginnen mit Factory-Methode (weniger kompliziert, mehr   kundengerecht, Subklassen wuchern)   und entwickeln sich in Richtung Abstract Factory,   Prototype oder Builder (flexibler,   komplexere) als Designer   entdeckt, wo mehr Flexibilität   erforderlich.
  
• sind manchmal Erzeugungsmuster ergänzen: Builder kann man verwenden   die anderen Muster zu implementieren   welche Komponenten erhalten gebaut. Abstrakt   Fabrik, Builder und Prototype kann   verwenden Singleton in ihrem   Implementierungen.
  

Wikipedia-Eintrag für Fabrik-Entwurfsmuster: http://en.wikipedia.org/wiki/Factory_method_pattern

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

Answer 2

Eine Fabrik ist einfach eine Wrapper-Funktion um einen Konstruktor (möglicherweise in einer anderen Klasse). Der wesentliche Unterschied ist, dass ein Fabrikmethode das gesamte Objekt erfordert, in einem einzigen Verfahrensaufruf aufgebaut werden, wobei alle Parameter in einer einzigen Zeile in passieren. Das endgültige Objekt wird zurückgegeben.

Ein Baumeister Muster , auf der anderen Seite ist ein Wrapper-Objekt um alle möglichen Parameter im Wesentlichen möchten Sie vielleicht in einen Konstruktor Aufruf. Auf diese Weise können Sie Setter-Methoden verwenden, um langsam die Parameterliste aufzubauen. Eine weitere Methode für eine Builder-Klasse ist eine Build () Methode, die einfach übergibt das Builder-Objekt in den gewünschten Konstruktor, und gibt das Ergebnis zurück.

In statischen Sprachen wie Java, wird dies noch wichtiger, wenn Sie mehr als eine Handvoll (möglicherweise optional) Parameter haben, da sie die Anforderung vermeidet Teleskopbauer haben für alle möglichen Kombinationen von Parametern. Auch ein Builder können Sie Setter-Methoden verwenden, um zu definieren schreibgeschützt oder private Felder, die nicht direkt geändert werden kann, nachdem der Konstruktor aufgerufen wurde.

Grund Fabrik Beispiel

// 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");

Grund 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 aus diesen beiden wikipedia Seiten zu vergleichen:

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

Answer 3

Das Muster Factory kann fast als eine vereinfachte Version des Builder-Muster zu sehen.

Fabrik Muster, die Fabrik ist verantwortlich für verschiedene Subtypen eines Objekts zu schaffen je nach Bedarf.

Der Benutzer einer Factory-Methode braucht nicht die genaue Subtyp des Objekts zu kennen. Ein Beispiel für eine Factory-Methode createCar könnte ein Ford oder ein Honda typisierte Objekt zurück.

Builder Muster werden verschiedene Subtypen auch durch eine Builder-Methode erstellt, aber die Zusammensetzung der Objekte können innerhalb der gleichen Unterklasse unterscheiden.

das Auto Beispiel fortzusetzen Sie könnten eine createCar Builder-Methode haben, die ein Honda typisierte Objekt mit einem 4-Zylinder-Motor erzeugt oder ein Honda typisierte Objekt mit 6 Zylindern. Der Erbauer Muster ermöglicht diese feinere Granularität.

Diagramme sowohl des Builder Muster und die Factory-Methode Muster auf Wikipedia verfügbar ist.

Answer 4

Das Builder-Entwurfsmuster beschreibt ein Objekt, das weiß, wie über mehrere Schritte ein anderes Objekt eines bestimmten Typen zu fertigen. Er hält den benötigten Zustand für den Zielpunkt an jedem Zwischenschritt. Denken Sie, was String geht durch eine endgültige Zeichenfolge zu erzeugen.

Die Fabrik-Entwurfsmuster beschreibt ein Objekt, das weiß, wie man in einem Schritt mehrere unterschiedliche, aber miteinander verbundene Arten von Objekt zu erstellen, in dem die spezifische Art gewählt wird, basierend auf gegebenen Parametern. Denken Sie an der Serialisierung System, in dem Sie Ihre Serializer erstellen und Konstrukte, die gewünscht im Objekt alle in einem Ladeaufruf.

Answer 5

• Konstruktion eines komplexen Objekts Schritt für Schritt: Erbauer

• Ein einfaches Objekt unter Verwendung einer einzigen Methode erstellt wird: Factory-Methode Muster

• Erstellen von Objekt durch mehr Factory-Methode unter Verwendung von: Abstrakte Fabrik

Answer 6

Beide sind Erzeugungsmuster, zu Objekt erstellen.

1) Fabrik-Muster - Angenommen, Sie haben eine Super-Klasse und N Anzahl von Unterklassen.     Das Objekt erstellt wird, hängt von dem Parameter / Wert übergeben wird.

2) Builder-Muster -. Erstellen komplexe Aufgabe

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.

Answer 7

Builder-Muster und Factory-Muster, beide scheinen mit bloßem Auge ziemlich ähnlich zu sein, weil sie beide Objekte für Sie erstellen.

Aber man muss genauer hinsehen

Dieses reale Beispiel wird den Unterschied zwischen den beiden deutlicher machen.

Angenommen, Sie gehen in ein Fastfood-Restaurant und bestellen Essen.

1) Welches Essen?

Pizza

2) Welche Beläge?

Paprika, Tomate, BBQ-Hähnchen, NEIN ANANAS

Verschiedene Arten von Lebensmitteln werden also nach dem Factory-Muster hergestellt, die verschiedenen Varianten (Geschmacksrichtungen) eines bestimmten Lebensmittels jedoch nach dem Builder-Muster.

Verschiedene Arten von Lebensmitteln

Pizza, Burger, Pasta

Varianten von Pizza

Nur Käse, Käse+Tomate+Paprika, Käse+Tomate usw.

Codebeispiel

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

Answer 8

Zunächst einige allgemeine Dinge, die meine Argumentation folgen:

Die größte Herausforderung große Software-Systeme in der Entwicklung ist, dass sie flexibel und unkompliziert zu ändern sein. Aus diesem Grund gibt es einige Metriken wie Kopplung und Kohäsion. Um das zu erreichen Systeme, die in ihrer Funktionalität leicht geändert oder erweitert, ohne die Notwendigkeit werden kann das ganze System von Grund auf neu zu gestalten, können Sie die Design-Prinzipien (wie SOLID, etc.) folgen. Nach einer Weile erkannte einige Entwickler, dass, wenn sie diese Prinzipien gibt es einige ähnliche Lösungen folgen, die gut zu ähnlichen Problemen gearbeitet. Diese Standardlösungen erwies sich die Design-Muster sein.

So sind die Entwurfsmuster sind Sie unterstützen die allgemeinen Gestaltungsprinzipien zu folgen, um lose gekoppelte Systeme mit hoher Kohäsion zu erreichen.

Die Beantwortung der Frage:

Durch den Unterschied zwischen zwei Mustern fragen muss man sich fragen, welche Muster Ihr System macht, in welcher Weise flexibler. Jedes Muster hat seinen eigenen Zweck Abhängigkeiten zwischen den Klassen in Ihrem System zu organisieren.

Die Abstract Factory Muster: GoF: „Geben Sie eine Schnittstelle für Familien verwandter oder abhängiger Objekte zu schaffen, ohne ihre konkreten Klassen angeben.“

Was bedeutet das: Durch die Bereitstellung von Produkt eine Schnittstelle wie dieser den Anruf an den Konstruktor jedes der Familie wird in der Fabrik Klasse gekapselt. Und weil dies ist der einzige Ort in Ihrem gesamten System, wo diese Konstrukteure genannt werden, können Sie Ihr System verändern, indem sie eine neue Fabrik Klasse implementieren. Wenn Sie die Darstellung der Fabrik durch eine andere auszutauschen, können Sie eine ganze Reihe von Produkten austauschen, ohne dass die Mehrheit des Codes zu berühren.

Das Builder Muster: GoF: „Trenne die Konstruktion eines komplexen Objekts von seiner Darstellung so, dass die gleiche Bauprozess unterschiedliche Darstellungen erstellen können.“

Was bedeutet das: Sie kapseln den Prozess der Konstruktion in einer anderen Klasse, genannt der Regisseur (GoF). Dieser Direktor enthält den Algorithmus der Schaffung neue Instanzen des Produkts (zum Beispiel ein komplexes Produkt aus anderen Teilen zusammensetzen). Um die integralen Bestandteile des gesamten Produkts erstellen der Regisseur einen Builder verwendet. der Erbauer in dem Regisseur Durch den Austausch können Sie den gleichen Algorithmus verwenden, um ein Produkt zu schaffen, sondern die Darstellungen von Einzelteilen (und so die Darstellung des Produkts) ändern. Zu erweitern oder Ihr System in der Darstellung des Produkts zu ändern, alles, was Sie tun müssen, ist eine neue Builder-Klasse zu implementieren.

Also kurz gesagt: Der Zweck der Abstrakte Fabrik ist eine Reihe von Produkten auszutauschen, die zusammen verwendet werden, hergestellt werden. Der Zweck des Builder-Muster ist die abstrakte Algorithmus zum Erzeugen eines Produkts kapseln sie für unterschiedliche Darstellungen des Produkts wieder zu verwenden.

Meiner Meinung nach kann man nicht sagen, dass die Abstrakte Fabrik der große Bruder des Builder-Musters ist. Ja, sie sind beide Erzeugungsmuster, aber die Hauptabsicht der Muster ist ganz anders.

Answer 9

Ein auffallender Unterschied zwischen Builder & Fabrik, die ich war das folgende

machen konnte

Angenommen, 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 wir Auto durch die folgende Weise erhalten:

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

aber was, wenn einige Ausnahme geschieht, während die Sitze zu schaffen ??? Sie werden nicht das Objekt an ALL GET // ABER

Angenommen, Sie haben die Umsetzung wie folgt aus

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 wie folgt 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();

  }

Hier im zweiten Fall, auch wenn eine Operation fehlschlägt Sie würde immer noch das Auto bekommen.

Kann sein, dass Auto nicht perfekt funktioniert später aber, würden Sie das Objekt haben.

Da Factory Method Sie das Auto in einzelnen Anruf gibt, während der Builder eins nach dem anderen aufbaut.

Obwohl Es hängt von den Bedürfnissen des geruhen, die man für gehen.

Answer 10

+-------------------------------------------------------------------+---------------------------------------------------+
|                              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                           |
+-------------------------------------------------------------------+---------------------------------------------------+  

Teles Constructor Muster

Analogy:

• Factory: ein Restaurant in Betracht. Die Schaffung von „heutigen Mahlzeit“ ist ein Fabrik-Muster, weil man die Küche sagen „mir heutigen Mahlzeit“ und die Küche (Fabrik) entscheidet, was das Objekt auf versteckte Kriterien zu erzeugen, basiert.
• Builder: Der Builder wird angezeigt, wenn Sie eine benutzerdefinierte Pizza bestellen. In diesem Fall sagt der Kellner des Koch (Baumeister) „Ich brauche eine Pizza;! Käse, Zwiebeln und Speck, um es hinzuzufügen“ Somit setzt der Bauherr die Attribute der erzeugte Gegenstand haben sollte, aber versteckt, wie sie eingestellt werden.

Courtesy

Answer 11

Builder und Abstract Factory hat für verschiedene Zwecke gedacht. Je nach rechts Anwendungsfall haben Sie geeignetes Design-Muster zu wählen.

Builder Eigenschaften aus:

1. Builder Muster bauen ein komplexes Objekt mit einfachen Objekten und ein schrittweises Vorgehen mit
2. Ein Builder-Klasse baut das letzte Objekt Schritt für Schritt. Dieser Builder ist unabhängig von anderen Objekten
3. Ersatz to Factory-Methode / Abstract Factory in diesem Szenario: Zu viele Argumente von Client-Programm auf die Factory-Klasse zu übergeben, die fehleranfällig sein können
4. Einige der Parameter können optional sein im Gegensatz zu in der Fabrik, die alle Parameter senden zwingt

Fabrik (einfache Factory) Eigenschaften aus:

1. Erzeugungsmuster
2. Basierend auf Vererbung
3. Fabrik gibt eine Factory-Methode (Schnittstelle), die wiederum Beton Object
zurück
4. Sie können neue Beton-Objekte für die Schnittstelle und Client (Anrufer) ersetzen sollte von allen konkreten Implementierungen nicht bewusst sein,
5. Client Zugriff auf immer Schnittstelle nur, und Sie können die Objekterstellung Details in der Fabrik Methode verbergen.

Oft Designs beginnen mit Factory Method (weniger kompliziert, anpassbarer, Subklassen vermehren) und entwickeln sich in Richtung Abstract Factory Prototype , oder Builder (flexibler, complex)

Hier finden Sie aktuelle related posts:

Keeping builder in separater Klasse (Fluent Interface)

Design Patterns: Factory-vs-Fabrik-Methode vs Abstract Factory

Sie können auf unter Artikel verweisen für weitere Informationen:

sourcemaking

journaldev

Answer 12

Abstract Factory & Builder Muster sind beide Erzeugungsmuster, aber mit unterschiedlichen Absichten.

Abstrakte Fabrik betont Objekterstellung für Familien verwandter Objekte, bei denen:

• Jede Familie ist eine Gruppe von Klassen von einer gemeinsamen Basisklasse / Schnittstellen abgeleitet.
• wird jedes Objekt sofort als Ergebnis eines Aufruf zurückgegeben.

Builder-Muster konzentriert sich auf ein komplexes Objekt Schritt für Schritt aufzubauen. Sie entkoppelt die Darstellung aus dem Prozess des komplexe Objekt konstruieren, so dass die gleiche Bauprozess für unterschiedliche Darstellungen verwendet werden kann.

• Builder-Objekt kapselt Konfiguration des komplexen Objekts.
• kennt Director Objekt, das Protokoll der Baumeister der Verwendung, wo die Protokoll definiert alle logischen Schritte erforderlich, um das komplexe Objekt aufzubauen.

Answer 13

eine komplexe Konstruktion ist, wenn das Objekt aufgebaut werden soll, aus verschiedenen anderen Objekten zusammengesetzt, die durch Abstraktionen dargestellt ist.

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

1. Beispiel: Cola, Big Mac, Französisch Fries
2. Beispiel: Sprite, Nuggets, Curly Fries

Dort haben wir zwei Instanzen des Menüs mit verschiedenen Darstellungen. Der Prozess der Konstruktion wiederum bleibt gleich. Sie erstellen ein Menü mit einem Getränk, ein Haupt- und ein Neben.

die Erbauer Durch die Verwendung trennen Sie den Algorithmus ein komplexes Objekt aus den verschiedenen Komponenten zu schaffen, es erstellt wird.

Im Hinblick auf den Erbauer wird der Algorithmus in dem Regisseur verkapselt während der Erbauer verwendet werden, um die Bestandteile zu erstellen. Durch Variation der verwendeten Builder im Algorithmus des Direktor führt zu einer anderen Darstellung, weil andere Teile zu einem Menü zusammengesetzt sind. Die Art und Weise ein Menü erstellt wird, bleibt das gleiche.

Answer 14

Fabrik : Wird für eine Instanz eines Objekts zu schaffen, wo die Abhängigkeiten des Objekts werden durch die Fabrik vollständig gehalten. Für die Abstrakte Fabrik , gibt es oft viele konkrete Implementierungen der gleichen abstrakten Fabrik. Die richtige Umsetzung der Fabrik wird über Dependency Injection injiziert.

Builder : Gebrauchte bauen unveränderlich Objekte, wenn die Abhängigkeiten des Objekts instanziiert werden teilweise im Voraus bekannt und teilweise zur Verfügung gestellt von der Client des Erbauers.

Answer 15

Der Unterschied ist klar  In Erbauer wird, Baumeister bestimmte Art von Objekt für Sie. Sie haben zu sagen, was Baumeister hat zu bauen.  In der Fabrikmuster, mit abstrakten Klasse, die Sie direkt den Aufbau der spezifischen Objekt werden.

Hier Builder-Klasse fungiert als Vermittler zwischen Hauptklasse und spezifischen Typklassen.  Mehr Abstraktion.

Answer 16

Beide sind sehr ähnlich, aber wenn Sie eine große Anzahl von Parametern für die Objekterstellung mit einigen von ihnen optional mit einigen Standardwerte haben, gehen Sie für Builder-Muster.

Answer 17

Ich glaube, können die Nutzung von und die Differenz zwischen Factory & Builder-Muster zu verstehen / geklärt leichter in einer bestimmten Zeitperiode, wie Sie auf der gleichen Code-Basis und wechselnde Anforderungen gearbeitet.

Aus meiner Erfahrung, in der Regel, Sie mit einem Factory-Mustern einschließlich paar statischen Konzept Methoden starten. Als Ihre Objekthierarchie komplexer wird (oder wie Sie mehr Typen hinzufügen), erhalten Sie wahrscheinlich mit mit Ihren Methoden bevölkerten mit mehr Parametern und nicht zu erwähnen würden Sie haben Ihr Werksmodul neu zu kompilieren. All jene Dinge, erhöht die Komplexität der Schöpfer Methoden, verringert sich die Lesbarkeit und macht das Modul zum Erzeugen von zerbrechlicher.

Dieser Punkt möglicherweise wird der Übergangspunkt sein. Der Übergang von der Fabrikmuster-Generator. Damit erstellen Sie einen Wrapper-Modul um die Konstruktionsparameter und dann werden Sie in der Lage neue repräsentieren sein (ähnlich) Objekte, die von einem paar mehr Abstraktionen Zugabe (vielleicht) und Implementierungen ohne tatsächliche Ihre Kreation Logik zu berühren. So haben Sie weniger komplexe Logik und neu kompiliert Quellcode hatte

Ehrlich gesagt, mit Bezug auf etwas Art „ein Objekt in einem Schritt oder mehreren Schritten erstellt haben, um die Differenz“ als Faktor einzige Vielfalt war nicht ausreichend, um mich um sie zu unterscheiden, da ich beide Wege für fast alle Fälle nutzen konnte ich konfrontiert bisher ohne irgendeinen Nutzen zu erfahren. Also das ist, was habe ich endlich dachte darüber nach.

Answer 18

Der wesentliche Unterschied zwischen ihnen ist, dass die Baumeister Muster in erster Linie beschreibt die Erstellung von komplexen Objekten Schritt für Schritt. Im Abstrakte Fabrik liegt der Schwerpunkt auf Familien von Objekten-Produkten . Builder liefert das Produkt in dem letzten Schritt . Während in dem Muster Abstract Factory das Produkt verfügbar sofort .

Beispiel:  Lassen Sie sagen, dass wir schaffen Maze

1. Abstract Factory:

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

2. Erbauer:

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

Answer 19

Build Muster betont auf Komplexität Objekt zu schaffen (gelöst durch "Schritte")

Abstrakte Muster betonen „nur“ auf „Abstraktion“ von (mehrere, aber miteinander verbundenen) Objekten.

Answer 20

Meiner Meinung Builder-Muster verwendet, wenn Sie ein Objekt aus einer Reihe von anderen Objekten und Schaffung von Teil erstellen möchten unabhängig sein muss des Objekts, das Sie erstellen möchten. Es hilft, die Erstellung eines Teils von dem Client zu verstecken Builder und Client-unabhängig zu machen. Es ist für komplexe Objekte Schöpfung (Objekte, die aus komplizierten Eigenschaften können) verwendet,

Während Fabrik Muster gibt an, dass Objekte einer gemeinsamen Familie erstellen möchten und Sie wollen es auf einmal zu cerated. Es ist für die einfachere Objekte verwendet.

Answer 21

IMHO

Builder ist eine Art komplexer Factory.

Aber in Builder Sie Objekte mit Verwendung eines anderen Fabriken instanziieren , die erforderlich sind, endgültig und gültige Objekt zu bauen.

Also, im Gespräch über „Erzeugungsmuster“ Evolution von Komplexität kann man darüber nachdenken, es auf diese Art und Weise:

Dependency Injection Container -> Service Locator -> Builder -> Factory

Answer 22

  

Builder und Abstract Factory

     

Das Builder Design-Muster ist sehr ähnlich, in einem gewissen Grad an die Abstract Factory-Muster. Deshalb ist es wichtig, den Unterschied zwischen der Situation machen zu können, wenn eine oder das andere verwendet wird. Im Fall des Abstract Factory, verwendet der Client die Methoden des Fabrik auf seine eigenen Objekte zu erstellen. Im Fall des Builder wird die Builder-Klasse angewiesen, wie das Objekt zu erstellen, und dann wird es danach gefragt, aber die Art und Weise, dass die Klasse zusammen bis zu der Builder-Klasse gesetzt wird, ist dieses Detail den Unterschied zwischen den beiden Mustern zu machen.

     

Common Interface für Produkte

     

Praxis in den von dem Betonbauer erstellt Produkte eine Struktur signifikant unterschiedlich, also, wenn es nicht ein Grund ist, verschiedene Produkte einen gemeinsamen Elternklasse abzuleiten. Dies unterscheidet auch die Builder-Muster aus dem Abstract Factory-Muster, das von einem gemeinsamen Typ abgeleitete Objekte erstellt.

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

Answer 23

kommen Beide Muster für die gleiche Notwendigkeit: Verstecken von einem Client-Code, um die Konstruktionslogik eines komplexen Objekts. Aber was macht „Komplex“ (oder manchmal erschweren) ein Objekt? Vor allem ist es zu Abhängigkeiten durch, oder vielmehr der Zustand eines Objekts durch mehr Teilstaaten zusammengesetzt ist. Sie können Abhängigkeiten von Konstruktor injizieren, um den anfänglichen Objektzustand zu setzen, sondern ein Objekt kann eine Menge von ihnen verlangen, einige werden in einem Standardausgangszustand sein (nur weil wir gelernt haben sollten, die eine Standard-Abhängigkeit auf null nicht der sauberste Weg ist ) und einiger anderer Satz auf einen Zustand von einer Bedingung angetrieben wird. Darüber hinaus gibt es Objekteigenschaften, die eine Art „vergesslich Abhängigkeiten“ sind aber auch sie können optional Zustände annehmen.

Es gibt zwei bekannte Möglichkeiten, um die Komplexität zu beherrschen:

• Zusammensetzung / Aggregation: ein Objekt Construct, konstruiert seine abhängigen Objekte, dann miteinander verdrahten. Hier kann ein Builder macht transparent und flexibel den Prozess, der die Regeln bestimmt, die den Bau der Komponente führen.

• Polymorphism: Bau Regeln werden direkt in Subtyp Definition deklariert, so haben Sie eine Reihe von Regeln für jeden Subtyp und eine Bedingung entscheidet, welche man unter diesem Satz von Regeln, um das Objekt zu konstruieren anzuwenden. Eine Fabrik paßt perfekt in diesem Szenario.

Nichts hindert diese beiden Ansätze zu mischen. Eine Familie von Produkt könnte abstrakte Objekterstellung mit einem Baumeister getan, ein Baumeister Fabrik verwenden könnte, welche Komponente Objekt instantiate zu bestimmen.

Answer 24

Werksmuster schafft eine konkrete Implementierung einer Klasse zur Laufzeit, das heißt seine Hauptabsicht Polymorphismus zu verwenden ist, damit Subklassen entscheiden, welche Klasse zu instanziiert. Das bedeutet, bei der Kompilierung uns die genaue Klasse nicht wissen, die erstellt werden, während Builder-Muster mit der Lösung des Problems des Teleskopbauer Antipattern in erster Linie betroffen ist, die durch eine große Anzahl von optionalen Feldern einer Klasse entsteht. In Erbauer gibt es keine Vorstellung von Polymorphismus, wie wir wissen, welche Aufgabe wir bei der Kompilierung zu konstruieren versuchen.

Das einzige gemeinsame Thema dieser beiden Muster ist das Verstecken von Konstrukteuren und Objekterstellung hinter Fabrikmethoden, und das Build-Verfahren für eine verbesserten Objektbau.

Answer 25

Werks Muster können Sie auf einmal auf einmal ein Objekt erstellen, während Builder Muster, das Sie den Erstellungsprozess eines Objekts lassen brechen. Auf diese Weise können Sie verschiedene Funktionen bei der Erstellung eines Objekts hinzufügen.