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

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

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

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

Builder对象封装了复杂对象的配置。Director对象知道使用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.

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

假设我们有一辆车

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

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

生成器和抽象工厂有着不同的目的。根据正确的用例，您必须选择合适的设计模式。

生成器的显著特点：

生成器模式使用简单对象和分步方法构建复杂对象生成器类逐步构建最终对象。此生成器独立于其他对象在这种情况下替换为Factory方法/抽象工厂：从客户端程序传递给Factory类的参数太多，容易出错某些参数可能是可选的，不像工厂中强制发送所有参数

工厂（简单工厂）的显著特点：

创建型模式基于继承Factory返回一个Factory方法（接口），然后返回具体对象您可以用新的具体对象替换接口，客户端（调用者）不应该知道所有具体实现客户端始终只访问接口，您可以在Factory方法中隐藏对象创建详细信息。

通常，设计从使用工厂方法（不那么复杂，更可定制，子类激增）开始，并向抽象工厂、原型或生成器（更灵活，更复杂）发展

查看相关帖子：

将生成器保持在单独的类中（流畅的接口）

设计模式：工厂vs工厂方法vs抽象工厂

有关详细信息，请参阅以下文章：

资源制造

日志记录设备

生成器模式和工厂模式看起来都很像肉眼，因为它们都为您创建对象。

但你需要仔细观察

这个现实生活中的例子将使两者之间的区别更加明显。

假设你去了一家快餐店，点了食物。

1） 什么食物？

披萨

2） 什么浇头？

辣椒，番茄，烤鸡，无菠萝

因此，不同种类的食物是通过工厂模式制作的，但特定食物的不同变体（口味）是通过构建模式制作的。

不同种类的食物

披萨、汉堡、意大利面

披萨的变体

只有奶酪、奶酪+番茄+辣椒、奶酪+西红柿等。

代码示例

您可以在这里看到这两种模式的示例代码实现生成器模式工厂模式

与工厂模式相比，构建器模式的主要优势在于，如果您希望创建一些具有大量可能自定义的标准对象，但最终通常只能自定义少数对象。

例如，如果你想写一个HTTP客户端，你将设置一些默认参数，比如默认的写/读超时、协议、缓存、DNS、拦截器等。

客户端的大多数用户将只使用这些默认参数，而其他一些用户可能希望自定义一些其他参数。在某些情况下，您只需要更改超时并按原样使用其余部分，而在其他情况下，可能需要自定义例如缓存。

以下是实例化客户端的可能方法（取自OkHttpClient）：

//just give me the default stuff
HttpClient.Builder().build()   

//I want to use custom cache
HttpClient.Builder().cache(MyCache()).build() 

//I want custom connection timeout
HttpClient.Builder().connectTimeout(30, TimeUnit.SECONDS).build() 

//I am more interested in read/write timeout
HttpClient.Builder()
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS).build()

如果你使用一个工厂模式，你最终会写出很多方法，包括所有可能的创造参数组合。对于构建器，您只需指定您关心的参数，并让构建器为您构建它，同时考虑所有其他参数。