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

哪一种更有利?为什么?

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


当前回答

Factory模式几乎可以看作是Builder模式的简化版本。

在Factory模式中,工厂负责根据需要创建对象的各种子类型。

工厂方法的用户不需要知道该对象的确切子类型。工厂方法createCar的示例可能返回Ford或Honda类型的对象。

在生成器模式中,不同的子类型也由生成器方法创建,但同一子类中对象的组成可能不同。

要继续汽车示例,您可能需要一个createCarbuilder方法,该方法创建一个带有4缸发动机的Honda类型的对象,或者一个带有6缸的Honda型对象。构建器模式允许这种更精细的粒度。

生成器模式和工厂方法模式的图表都可以在维基百科上找到。

其他回答

构建模式强调创建对象的复杂性(通过“步骤”解决)

抽象模式强调(多个但相关的)对象的“抽象”。

构建器设计模式描述了一个对象,该对象知道如何在几个步骤中创建另一个特定类型的对象。它在每个中间步骤保持目标项所需的状态。想想StringBuilder是如何生成最终字符串的。

工厂设计模式描述了一个对象,该对象知道如何在一个步骤中创建几种不同但相关的对象,其中特定类型是基于给定参数选择的。想想串行化系统,在这里创建串行化器,它在一次加载调用中构造所需的in对象。

工厂模式在运行时创建一个类的具体实现,即它的主要目的是使用多态性来允许子类决定实例化哪个类。这意味着在编译时我们不知道将要创建的确切类,而Builder模式主要涉及解决伸缩构造函数反模式的问题,这是由于类的大量可选字段而产生的。在构建器模式中,没有多态性的概念,因为我们知道在编译时要构造什么对象。

这两种模式的唯一共同主题是在工厂方法和构建方法后面隐藏构造函数和对象创建,以改进对象构造。

复杂构造是指要构造的对象由抽象表示的不同的其他对象组成。

考虑麦当劳的菜单。菜单包括饮料、主菜和配菜。根据单个抽象的后代组合在一起,创建的菜单具有另一种表示。

例如:可乐、巨无霸、薯条示例:雪碧、掘金、卷曲薯条

在那里,我们得到了两个具有不同表示的菜单实例。施工过程保持不变。您可以创建一个菜单,其中包含饮料、主菜单和副菜单。

通过使用生成器模式,可以将创建复杂对象的算法与用于创建它的不同组件分开。

就构建器模式而言,算法封装在控制器中,而构建器用于创建完整的部分。在控制器的算法中改变使用的生成器会导致不同的表示,因为其他部分都是由菜单组成的。菜单的创建方式保持不变。

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

假设我们有一辆车

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

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