Builder设计模式和Factory设计模式之间的区别是什么?

哪一种更有利?为什么?

如果我想测试和比较/对比这些模式,我如何将我的发现表示为图表?


当前回答

生成器和抽象工厂生成器设计模式在某种程度上与抽象工厂模式非常相似。这就是为什么在使用其中一种或另一种情况时,能够区分不同的情况是很重要的。在抽象工厂的情况下,客户端使用工厂的方法来创建自己的对象。在Builder的例子中,Builder类被指示如何创建对象,然后被要求创建对象,但是类的组合方式取决于Builder类,这一细节决定了两种模式之间的区别。产品通用接口在实践中,由混凝土建设者创建的产品具有明显不同的结构,因此如果没有理由派生不同的产品,则生成一个公共的父类。这也将生成器模式与抽象工厂模式区分开来,抽象工厂模式创建从公共类型派生的对象。

发件人:http://www.oodesign.com/builder-pattern.html

其他回答

我可以看出建筑商和工厂之间的一个显著区别是

假设我们有一辆车

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

在上面的界面中,我们可以通过以下方式获取汽车:

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

但是如果在创建Seats时发生了一些异常呢???你根本得不到这个物体//但是

假设您有如下实现

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

现在您可以这样创建

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

  }

在第二种情况下,即使一次操作失败,你仍然可以得到汽车。

可能是这辆车后来不太好用了,但你会有目标的。

因为Factory方法在一次调用中为您提供Car,而Builder则逐个构建。

尽管如此,这取决于哪一位的需要。

首先,要遵循我的论证:

设计大型软件系统的主要挑战是它们必须灵活且不复杂地进行更改。出于这个原因,有一些度量,如耦合和内聚。为了实现可以轻松更改或扩展其功能而无需从头设计整个系统的系统,您可以遵循设计原则(如SOLID等)。过了一段时间,一些开发人员意识到,如果他们遵循这些原则,就会有一些类似的解决方案可以很好地解决类似问题。这些标准解决方案被证明是设计模式。

因此,设计模式支持您遵循一般设计原则,以实现具有高内聚性的松散耦合系统。

回答问题:

通过询问两种模式之间的差异,你必须问问自己,哪种模式使你的系统更灵活。每个模式都有自己的目的来组织系统中类之间的依赖关系。

抽象工厂模式:GoF:“提供一个接口来创建相关或依赖对象的族,而不指定它们的具体类。”

这意味着什么:通过提供这样的接口,对每个系列产品的构造函数的调用被封装在工厂类中。因为这是整个系统中唯一调用这些构造函数的地方,所以可以通过实现新的工厂类来更改系统。如果您通过另一个交换工厂的表示,则可以在不接触大部分代码的情况下交换一整套产品。

生成器模式:GoF:“将复杂对象的构造与其表示分离,以便相同的构造过程可以创建不同的表示。”

这意味着什么:您将构建过程封装在另一个类中,称为director(GoF)。该导向器包含创建产品新实例的算法(例如,用其他部件组成一个复杂的产品)。为了创建整个产品的组成部分,导演使用了一个生成器。通过在director中交换生成器,您可以使用相同的算法来创建产品,但更改单个零件的表示(以及产品的表示)。要在产品的表示中扩展或修改系统,只需实现一个新的生成器类。

简而言之:抽象工厂模式的目的是交换一组共同使用的产品。生成器模式的目的是封装创建产品的抽象算法,以将其用于产品的不同表示。

在我看来,你不能说抽象工厂模式是生成器模式的大哥。是的,它们都是创造模式,但模式的主要意图完全不同。

工厂模式允许您一次创建一个对象,而生成器模式允许您中断对象的创建过程。这样,您可以在创建对象期间添加不同的功能。

工厂:用于创建对象的实例,其中对象的依赖项完全由工厂保存。对于抽象工厂模式,通常有许多相同抽象工厂的具体实现。工厂的正确实现是通过依赖注入注入的。

生成器:用于构建不可变对象,当要实例化的对象的依赖项部分是预先知道的,部分是由生成器的客户端提供的。

抽象工厂和生成器模式都是创造性模式,但目的不同。

抽象工厂模式强调为相关对象族创建对象,其中:

每个族都是从公共基类/接口派生的一组类。每个对象都会作为一次调用的结果立即返回。

构建器模式侧重于一步一步地构建一个复杂的对象。它将表示与构造复杂对象的过程解耦,以便相同的构造过程可以用于不同的表示。

Builder对象封装了复杂对象的配置。Director对象知道使用Builder的协议,其中协议定义了构建复杂对象所需的所有逻辑步骤。