设计模式（2）——抽象工厂模式

抽象工厂设计模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

角色扮演

AbstranctFactory（抽象工厂）

对外提供抽象一组，或多组相互依赖的接口

FactoryA、FactoryB（具体工厂）

包括具体工厂A和工厂B，分别实现具体产品的生产

 Productor（抽象产品）

包括抽象产品A和抽象产品B

ProductA 、ProductAB（具体产品）

抽象产品A中的A0、A1；抽象产品B中的B0、B1

举例说明

//产品：
//抽象产品类0
class Prouctor
{
    public:
        Prouctor();
        virtual ~Prouctor();
        virtual void product0()=  0;
    protected:
    private:
};

//抽象产品类1
class Productor1
{
    public:
        Productor1();
        virtual ~Productor1();
        virtual void product1()=0;
    protected:
    private:
};

//具体产品类A0
class ProductA : public Prouctor
{
    public:
        ProductA();
        virtual ~ProductA();
        void product0(){
          cout << "produuct A0"<<endl;
        }
    protected:
    private:
};
//具体产品类A1
class ProductA1 : public Productor1
{
    public:
        ProductA1();
        virtual ~ProductA1();
        void product1(){
          cout << "produuct A1"<<endl;
        }
    protected:
    private:
};

//具体产品类B0
class ProductB : public Prouctor
{
    public:
        ProductB();
        virtual ~ProductB();
        void product0(){
          cout << "produuct B0"<<endl;
        }
    protected:
    private:
};

//具体产品类B1
class ProductB1 : public Productor1
{
    public:
        ProductB1();
        virtual ~ProductB1();
        void product1(){
          cout << "produuct B1"<<endl;
        }
    protected:
    private:
};

//工厂：
//抽象工厂类：
class AbstranctFactory
{
    public:
        AbstranctFactory();
        virtual ~AbstranctFactory();
        virtual Prouctor*   createproduct0() = 0;
        virtual Productor1* createproduct1() = 0;
    protected:
    private:
};

//具体工厂类A 负责生产产品A0、A1
class FactoryA : public AbstranctFactory
{
    public:
        FactoryA();
        virtual ~FactoryA();
        Prouctor*   createproduct0(){return new ProductA(); }
        Productor1* createproduct1(){return new ProductA1();}
    protected:
    private:
};

//具体工厂类B 负责生产产品B0、B1
class FactoryB : public AbstranctFactory
{
    public:
        FactoryB();
        virtual ~FactoryB();
        Prouctor* createproduct0()  {return new ProductB(); }
        Productor1* createproduct1(){return new ProductB1();}
    protected:
    private:
};

运行：

int main(){

FactoryA * fa = new FactoryA();
fa->createproduct0()->product0();
fa->createproduct1()->product1();

FactoryB * fb = new FactoryB();
fb->createproduct0()->product0();
fb->createproduct1()->product1();
return 0;
}

结果：

 

优点

抽象工厂模式是对工厂方法模式的改进。用于处理产品不只有一类的情况，如上所述，产品A下有产品A1、A0等

缺点

结构过于臃肿，如果产品类型较多或者产品族太多，则会非常难于管理；如果每次添加一组产品，那么所有的工厂类必须添加一个方法，这样也违背了开放-封闭的原则，所以一般适用于产品组合族变化不大的情况

常用的场景

在不必指定产品的具体的情况下，创建多个产品族中的产品对象；一个系统要独立于它的产品的创建、组合和表示时。一个系统要由多个产品系列中的一个来配置时；当你要强调一系列相关的产品对象的设计以便进行联合使用时；当你提供一个产品类库，而只想显示它们的接口而不是实现时。

抽象工厂和工厂模式的区别

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。   
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

工厂方法创建 "一种" 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量代码很可能围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有很多可以复用的特征，所以会和模版方法相随。 

抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承