设计模式解析和实现之二-Abstract Factory模式

作用：

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

    UML结构图：

    抽象基类：

    1）ProductA，ProductB：分别代表不同类型的产品，而它们的派生类则是这种产品的一个实现。

    2）AbstractFactory：生产这一系列产品的一个抽象工厂，它的派生类是不同的实现。

    接口函数：

    1）AbstractFactory：：CreateProductA和AbstractFactory：：CreateProductB：分别是生产不同产品的不同的实现，由各个派生出来的抽象工厂实现之。

    解析：

    Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现的有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂，等等。

    可以举一个简单的例子来解释这个模式：比如，同样是鸡腿（ProductA）和汉堡（ProductB），它们都可以有商店出售（AbstractFactory），但是有不同的实现，有肯德基（ConcreateFactory1）和麦当劳（ConcreateFactory2）两家生产出来的不同风味的鸡腿和汉堡（也就是ProductA和ProductB的不同实现）。

    而负责生产汉堡和鸡腿的就是之前提过的Factory模式了。

    抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现。显而易见的，如果有n种产品同时有m中不同的实现，那么根据乘法原理可知有n*m个Factory模式的使用。

实现：

    1）AbstractFactory.h

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

// 抽象基类AbstractProductA,代表产品A的抽象
class AbstractProductA
{
public:
　　　 AbstractProductA() {}
　　　 virtual ~AbstractProductA(){};
};

// 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
class ConcreateProductA1
　　　 : public AbstractProductA
{
public:
　　　 ConcreateProductA1();
　　　 virtual ~ConcreateProductA1();
};

// 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
class ConcreateProductA2
　　　 : public AbstractProductA
{
public:
　　　 ConcreateProductA2();
　　　 virtual ~ConcreateProductA2();
};

// 抽象基类AbstractProductB,代表产品B的抽象
class AbstractProductB
{
public:
　　　 AbstractProductB() {}
　　　 virtual ~AbstractProductB(){};
};

// 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
class ConcreateProductB1
　　　 : public AbstractProductB
{
public:
　　　 ConcreateProductB1();
　　　 virtual ~ConcreateProductB1();
};

// 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
class ConcreateProductB2
　　　 : public AbstractProductB
{
public:
　　　 ConcreateProductB2();
　　　 virtual ~ConcreateProductB2();
};

// 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class AbstractFactory
{
public:
　　　 AbstractFactory(){}
　　　 virtual ~AbstractFactory(){}

　　　 virtual AbstractProductA* CreateProductA() = 0;
　　　 virtual AbstractProductB* CreateProductB() = 0;
};

// 派生类ConcreateFactory1,继承自AbstractFactory
// 生产产品A和产品B的第一种实现
class ConcreateFactory1
　　　 : public AbstractFactory
{
public:
　　　 ConcreateFactory1();
　　　 virtual ~ConcreateFactory1();

　　　 virtual AbstractProductA* CreateProductA();
　　　 virtual AbstractProductB* CreateProductB();
};

// 派生类ConcreateFactory2,继承自AbstractFactory
// 生产产品A和产品B的第二种实现
class ConcreateFactory2
　　　 : public AbstractFactory
{
public:
　　　 ConcreateFactory2();
　　　 virtual ~ConcreateFactory2();

　　　 virtual AbstractProductA* CreateProductA();
　　　 virtual AbstractProductB* CreateProductB();
};

#endif

 2）AbstractFactory.cpp

#include <iostream>
#include "AbstractFactory.h"

ConcreateProductA1::ConcreateProductA1()
{
　　　 std::cout << "construction of ConcreateProductA1n";
}

ConcreateProductA1::~ConcreateProductA1()
{
　　　 std::cout << "destruction of ConcreateProductA1n";
}

ConcreateProductA2::ConcreateProductA2()
{
　　　 std::cout << "construction of ConcreateProductA2n";
}

ConcreateProductA2::~ConcreateProductA2()
{
　　　 std::cout << "destruction of ConcreateProductA2n";
}

ConcreateProductB1::ConcreateProductB1()
{
　　　 std::cout << "construction of ConcreateProductB1n";
}

ConcreateProductB1::~ConcreateProductB1()
{
　　　 std::cout << "destruction of ConcreateProductB1n";
}

ConcreateProductB2::ConcreateProductB2()
{
　　　 std::cout << "construction of ConcreateProductB2n";
}

ConcreateProductB2::~ConcreateProductB2()
{
　　　 std::cout << "destruction of ConcreateProductB2n";
}

ConcreateFactory1::ConcreateFactory1()
{
　　　 std::cout << "construction of ConcreateFactory1n";
}

ConcreateFactory1::~ConcreateFactory1()
{
　　　 std::cout << "destruction of ConcreateFactory1n";
}

AbstractProductA* ConcreateFactory1::CreateProductA()
{
　　　 return new ConcreateProductA1();
}

AbstractProductB* ConcreateFactory1::CreateProductB()
{
　　　 return new ConcreateProductB1();
}

ConcreateFactory2::ConcreateFactory2()
{
　　　 std::cout << "construction of ConcreateFactory2n";
}

ConcreateFactory2::~ConcreateFactory2()
{
　　　 std::cout << "destruction of ConcreateFactory2n";
}

AbstractProductA* ConcreateFactory2::CreateProductA()
{
　　　 return new ConcreateProductA2();
}

AbstractProductB* ConcreateFactory2::CreateProductB()
{
　　　 return new ConcreateProductB2();
}

 3）Main.cpp（测试代码）

#include "AbstractFactory.h"
#include <stdlib.h>

int main()
{
　　　 // 生产产品A的第一种实现
　　　 ConcreateFactory1 *pFactory1 = new ConcreateFactory1;
　　　 AbstractProductA *pProductA = pFactory1->CreateProductA();

　　　 // 生产产品B的第二种实现
　　　 ConcreateFactory2 *pFactory2 = new ConcreateFactory2;
　　　 AbstractProductB *pProductB = pFactory2->CreateProductB();

　　　 delete pFactory1;
　　　 delete pProductA;
　　　 delete pFactory2;
　　　 delete pProductB;

　　　 system("pause");

　　　 return 0;
}