Abstract Factory（抽象工厂）模式

1.意图

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

2.适用性

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

3.结构图

    如上图所示为抽象工厂的结构图，每一个工厂负责创建一系列产品。

4.C++代码实例

#include <cstdlib>
#include <string>
class AbstractFactory;

class Client
{
public:
    Client(){};
    ~Client(){};
    AbstractFactory *GetFactory(std::string type);
private:
    AbstractFactory *pFactory;

};

class AbstractProductA
{
public:
    AbstractProductA()
    {
    }
    virtual ~AbstractProductA()
    {
    };
};


class AbstractProductB
{
public:
    AbstractProductB()
    {
    }
    virtual ~AbstractProductB()
    {
    };
};

class AbstractProductA;
class AbstractProductB;

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

#include "AbstractFactory.h"

class AbstractProductA;
class AbstractProductB;

class ConcreteFactory1 : public AbstractFactory
{
public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    AbstractProductA * CreateProductA();
    AbstractProductB * CreateProductB();
};

class ConcreteFactory2 : public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    AbstractProductA * CreateProductA();
    AbstractProductB * CreateProductB();
};

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include "AbstractProduct.h"

class ConcreteProductA1 : public AbstractProductA
{
public:
    ConcreteProductA1()
    {
        std::cout << "ConcreteProductA1 is Created" << std::endl;
    }
    ~ConcreteProductA1()
    {
    }
};

class ConcreteProductA2 : public AbstractProductA
{
public:
    ConcreteProductA2()
    {
        std::cout << "ConcreteProductA2 is Created" << std::endl;
    }
    ~ConcreteProductA2()
    {
    }
};

class ConcreteProductB1 : public AbstractProductB
{
public:
    ConcreteProductB1()
    {
        std::cout << "ConcreteProductB1 is Created" << std::endl;
    }

    ~ConcreteProductB1()
    {
    }
    
};

class ConcreteProductB2 : public AbstractProductB
{
public:
    ConcreteProductB2()
    {
        std::cout << "ConcreteProductB2 is Created" << std::endl;
    }

    ~ConcreteProductB2()
    {
    }
};

#include "ConcreteFactory.h"
#include "ConcreteProduct.h"



ConcreteFactory1::ConcreteFactory1()
{
}

ConcreteFactory1::~ConcreteFactory1()
{
}

AbstractProductA * ConcreteFactory1::CreateProductA()
{
    auto product = new ConcreteProductA1();
    return product;
}

AbstractProductB * ConcreteFactory1::CreateProductB()
{
    auto product = new ConcreteProductB1();
    return product;
}


ConcreteFactory2::ConcreteFactory2()
{
}

ConcreteFactory2::~ConcreteFactory2()
{
}

AbstractProductA * ConcreteFactory2::CreateProductA()
{
    auto product = new ConcreteProductA2();
    return product;
}

AbstractProductB * ConcreteFactory2::CreateProductB()
{
    auto product = new ConcreteProductB2();
    return product;
}

#include "Client.h"
#include "ConcreteFactory.h"

 AbstractFactory *Client::GetFactory(std::string type)
 {
     if("1" == type)
     {
         auto pFactory = new ConcreteFactory1();
         return pFactory;
     }
     else if ("2" == type)
     {
         auto pFactory = new ConcreteFactory2();
         return pFactory;
     }
 }

#include "Client.h"
#include "AbstractFactory.h"
#include "AbstractProduct.h"

int main()
{
    auto client = new Client();
    auto pFactory = client->GetFactory("1");
    auto pProductA = pFactory->CreateProductA();
    auto pProductB = pFactory->CreateProductB();
    delete pProductB;
    pProductB = NULL;
    delete pProductA;
    pProductA = NULL;
    delete pFactory;
    pFactory = NULL;

    pFactory = client->GetFactory("2");
    pProductA = pFactory->CreateProductA();
    pProductB = pFactory->CreateProductB();
    delete pProductB;
    pProductB = NULL;
    delete pProductA;
    pProductA = NULL;
    delete pFactory;
    pFactory = NULL;
    delete client;
    client=NULL;

    while(1);
    

}

测试结果：

如测试代码中所写，先创建1系列的产品A和B，后创建2系列的产品A和B。

5.效果

• 分离了具体的类，产品的类名不出现在测试代码（即客户代码）中。
• 使得易于交换产品系列。
• 利于产品的一致性。
• 难以支持新种类的产品

6.相关模式

抽象工厂类通常用工厂方法实现，但是也可以用原型实现。一个具体的工厂通常是一个单件。