抽象工厂模式

一 概念解释
定义：抽象工厂模式提供一个创建一系列相关或者相互依赖的对象接口，而无须指明他们的具体类。抽象模式又称为Kit模式。是一种对象创建模式。
抽象工厂模式是为创建一组对象提供了一种解决方案。与工厂方法模式相比抽象工厂模式中的具体工厂不只是创建一种产品，而是负责创建族产品。
引入相关概念：
1 产品等级结构：即产品的继承结构，比如抽象类是一个矩形，其子类有红色矩形，蓝色矩形，灰色矩形等。
2 产品族 指在同一个工厂生产的，位于不同的产品等级中的一组产品。比如红色工厂生产的有红色矩形，红色圆形，红色三角形。

二 抽象工厂模式结构图

AbstractFactory 抽象工厂，声明一组用于创建一族产品的方法，每一个方法对应一种产品。
ConcreteFactory 具体工厂，实现了抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成一个产品族，每个产品都位于某个产品等级结构中。
AbstractProduct 抽象产品，为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
ConcreteProduct，具体产品，定义具体工厂生产的具体产品对象，实现在抽象产品接口中声明的业务方法。

C++实现的抽象工厂模式

AbstractProductA.h

#include <stdio.h>


class AbstractProductA
{
public:
    AbstractProductA();
    virtual ~AbstractProductA();
    virtual void operationA() = 0;
};

class ProductA_1:public AbstractProductA
{
public:
    ProductA_1();
    virtual ~ProductA_1();
    void operationA();
};

class ProductA_2:public AbstractProductA
{
public:
    ProductA_2();
    ~ProductA_2();
    void operationA();
};

AbstractProductA.cpp

#include "AbstractProductA.h"


AbstractProductA::AbstractProductA(){}

AbstractProductA::~AbstractProductA(){}

ProductA_1::ProductA_1(){}

ProductA_1::~ProductA_1(){}

void ProductA_1::operationA()
{
    printf("hello,operationA for ProductA_1\n");
}

ProductA_2::ProductA_2(){}

ProductA_2::~ProductA_2(){}

void ProductA_2::operationA()
{
    printf("hello,operationA for ProductA_2\n");
}

AbstractProductB.h

#include <stdio.h>


class AbstractProductB
{
public:
    AbstractProductB();
    virtual ~AbstractProductB();
    virtual void operationB() = 0;
};


class ProductB_1:public AbstractProductB
{
public:
    ProductB_1();
    virtual ~ProductB_1();
    void operationB();
};


class ProductB_2:public AbstractProductB
{
public:
    ProductB_2();
    virtual ~ProductB_2();
    virtual void operationB();
};

AbstractProductB.cpp

#include "AbstractProductB.h"


AbstractProductB::AbstractProductB(){}

AbstractProductB::~AbstractProductB(){}

ProductB_1::ProductB_1(){}

ProductB_1::~ProductB_1(){}

void ProductB_1::operationB()
{
    printf("hello,operationB for ProductB_1\n");
}

ProductB_2::ProductB_2(){}

ProductB_2::~ProductB_2(){}

void ProductB_2::operationB()
{
    printf("hello,operationB for ProductB_2\n");
}

AbstractFactory.h

#include "AbstractProductA.h"
#include "AbstractProductB.h"


class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    virtual AbstractProductA * creatProductA() = 0;
    virtual AbstractProductB * creatProductB() = 0;
};


class Factory1:public AbstractFactory
{
public:
    Factory1();
    ~Factory1();
    AbstractProductA * creatProductA();
    AbstractProductB * creatProductB();
};

class Factory2:public AbstractFactory
{
public:
    Factory2();
    ~Factory2();
    AbstractProductA * creatProductA();
    AbstractProductB * creatProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"


AbstractFactory::AbstractFactory(){};

AbstractFactory::~AbstractFactory(){};

Factory1::Factory1(){};

Factory1::~Factory1(){};

AbstractProductA * Factory1::creatProductA()
{
    AbstractProductA * temp = NULL;
    temp = new ProductA_1();
    return temp;
}

AbstractProductB * Factory1::creatProductB()
{
    AbstractProductB * temp = NULL;
    temp = new ProductB_1();
    return temp;
}

Factory2::Factory2(){};

Factory2::~Factory2(){};

AbstractProductA * Factory2::creatProductA()
{
    AbstractProductA * temp = NULL;
    temp = new ProductA_2();
    return temp;
}

AbstractProductB * Factory2::creatProductB()
{
    AbstractProductB * temp = NULL;
    temp = new ProductB_2();
    return temp;
}

client.cpp

int main()
{
    AbstractFactory * factory1 = new Factory1();
    AbstractProductA * productA_1 = factory1->creatProductA();
    AbstractProductB * productB_1 = factory1->creatProductB();
    productA_1->operationA();
    productB_1->operationB();

    delete factory1;
    factory1 = NULL;
    delete productA_1;
    productA_1 = NULL;
    delete productB_1;
    productB_1 = NULL;

    AbstractFactory * factory2 = new Factory2();
    AbstractProductA * productA_2 = factory2->creatProductA();
    AbstractProductB * productB_2 = factory2->creatProductB();
    productA_2->operationA();
    productB_2->operationB();

    delete factory2;
    factory2 = NULL;
    delete productA_2;
    productA_2 = NULL;
    delete productB_2;
    productB_2 = NULL;

    system("pause");
}

运行结果：

抽象工厂的优点：
1 隔离具体类的生成，用户不需要知道什么被创建，只需要知道由哪个工厂创建。
2 可以非常方便的使用一族中间的不同类型的产品。

缺点：
1 结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。
2 添加产品等级结构比较麻烦，所有的工厂都要添加一个方法，违背开闭准则。