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

哪一种更有利?为什么?

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


当前回答

区别很明显在生成器模式中,生成器将为您创建特定类型的对象。你必须告诉我什么建筑商必须建造。在工厂模式中,使用抽象类可以直接构建特定对象。

在这里,生成器类充当主类和特定类型类之间的中介。更抽象。

其他回答

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

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

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

伸缩构造器模式

类比:

工厂:考虑一家餐馆。创建“今天的饭”是一种工厂模式,因为你告诉厨房“给我今天的饭吃”,厨房(工厂)根据隐藏的标准决定生成什么对象。生成器:如果您订购自定义披萨,则会显示生成器。在这种情况下,服务员告诉厨师(构建者)“我需要一个比萨饼;在其中添加奶酪、洋葱和培根!”因此,构建者公开了生成对象应该具有的属性,但隐藏了如何设置这些属性。

礼貌

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

假设我们有一辆车

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则逐个构建。

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

两者都是创造模式,以创建对象。

1) 工厂模式-假设您有一个超级类和N个子类。对象的创建取决于传递的参数/值。

2) 生成器模式-创建复杂对象。

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.

对于设计模式,通常没有适用于所有情况的“更有利”解决方案。这取决于您需要实施什么。

来自维基百科:

Builder专注于构建一步一步复杂的物体。摘要工厂强调产品系列对象(简单或复杂)。生成器将产品作为最终产品返回步骤,但就抽象而言工厂关心,产品得到立即返回。生成器通常构建一个复合。通常,设计开始时使用工厂方法(不那么复杂,更多可定制,子类激增)并向抽象工厂发展,原型或生成器(更灵活,更复杂)发现更灵活的地方需要。有时创造模式是互补的:构建者可以使用要实现的其他模式构建哪些组件。摘要工厂、建造商和原型可以使用Singleton实现。

工厂设计模式维基百科条目:http://en.wikipedia.org/wiki/Factory_method_pattern

构建器设计模式的维基百科条目:http://en.wikipedia.org/wiki/Builder_pattern