一.创建型模式 abstractFactory

AbstractFactory建一组相关或者相互依赖的对象。

• AbstractFactory 模式将一组对象的创建封装到一个用于创建对象的类ConcreteFactory)中,维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。
• 我们要创建一组对象(ProductA1,ProductA2)的时候我们只用维护一个创建对象(ConcreteFactory1),大大简化了维护的成本和工作。
• AbstractFactory 模式是为创建一组(有多类)相关或依赖的对象提供创建接口,而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。
• 并且可以看到,AbstractFactory 模式通常都是使用 Factory 模式实现(ConcreteFactory1)。

• #include<iostream>
  #include"abstractFactory.h"
  #include"Product.h"
  using namespace std;
  int main()
  {
      abstractFactory *af1 = new concreteFactory1();
  
      af1->CreateProductA();
      af1->CreateProductB();
  
      abstractFactory *af2 = new concreteFactory2();
  
      af2->CreateProductA();
      af2->CreateProductB();
      system("pause");
      return 0;
  }

  #ifndef PRODUCT_H
  #define PRODUCT_H
  #include<iostream>
  using namespace std;
  
  class abstractProductA
  {
  public:
      virtual ~abstractProductA();
  protected: 
      abstractProductA();
      
  
  private:
  
  };
  class abstractProductB
  {
  public:
      virtual ~abstractProductB();
  protected:
      abstractProductB();
  
  
  private:
  
  };
  class productA :public abstractProductA
  {
  public:
      productA();
      ~productA();
  };
  class productA2 :public abstractProductA
  {
  public:
      productA2();
      ~productA2();
  };
  class productB :public abstractProductB
  {
  public:
      productB();
      ~productB();
  };
  class productB2  :public abstractProductB
  {
  public:
      productB2();
      ~productB2();
  };
  
  #endif // !PRODUCT_H

  #include "Product.h"
  
  abstractProductA::~abstractProductA()
  {
  }
  
  abstractProductA::abstractProductA()
  {
  }
  
  abstractProductB::~abstractProductB()
  {
  }
  
  abstractProductB::abstractProductB()
  {
  }
  
  productA::productA()
  {
      cout << "ProductA1..." << endl;
  }
  
  productA::~productA()
  {
  }
  
  productA2::productA2()
  {
      cout << "ProductA2..." << endl;
  }
  
  productA2::~productA2()
  {
  }
  
  productB::productB()
  {
      cout << "ProductB..." << endl;
  
  }
  
  productB::~productB()
  {
  }
  
  productB2::productB2()
  {
      cout << "ProductB2..." << endl;
  }
  
  productB2::~productB2()
  {
      
  }

  #ifndef ABSTRACTFACTORY
  #define ABSTRACTFACTORY
  #include"Product.h"
  #include<iostream>
  using namespace std;
  class abstractProductA;
  class abstractProductB;
  class abstractFactory
  {
  public:
      abstractFactory();
      virtual ~abstractFactory();
      virtual abstractProductA* CreateProductA() = 0;
      virtual abstractProductB* CreateProductB() = 0;
  };
  
  class concreteFactory1 :public abstractFactory
  {
  public:
      concreteFactory1();
      ~concreteFactory1();
      abstractProductA* CreateProductA();
      abstractProductB* CreateProductB();
      
  };
  class concreteFactory2 :public abstractFactory
  {
  public:
      concreteFactory2();
      ~concreteFactory2();
      abstractProductA* CreateProductA();
      abstractProductB* CreateProductB();
  
  };
  
  #endif // !ABSTRACTFACTORY

  #include "abstractFactory.h"
  
  
  
  abstractFactory::abstractFactory()
  {
  }
  
  
  abstractFactory::~abstractFactory()
  {
  }
  
  concreteFactory1::concreteFactory1()
  {
  }
  
  concreteFactory1::~concreteFactory1()
  {
  }
  
  abstractProductA * concreteFactory1::CreateProductA()
  {
      return new productA();
  }
  
  abstractProductB * concreteFactory1::CreateProductB()
  {
      return new productB();
  }
  
  concreteFactory2::concreteFactory2()
  {
  }
  
  concreteFactory2::~concreteFactory2()
  {
  }
  
  abstractProductA * concreteFactory2::CreateProductA()
  {
      return new productA2();
  }
  
  abstractProductB * concreteFactory2::CreateProductB()
  {
      return new productB2();
  }