设计模式---抽象工厂





Abstract Factory

一、功能

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

二、示例代码

namespace DesignPattern_AbstractFactory
{
	class AbstractProductA {};	// Product A
	class ProductA1 : public AbstractProductA {};
	class ProductA2 : public AbstractProductA {};

	class AbstractProductB {};	// Product B
	class ProductB1 : public AbstractProductB {};
	class ProductB2 : public AbstractProductB {};

	class AbstractFactory
	{
	public:
		virtual AbstractProductA* CreateProductA() = 0 ;// 创建ProductA
		virtual AbstractProductB* CreateProductB() = 0 ;// 创建ProductB

	} ;

	class ConcreteFactory1 : public AbstractFactory
	{
	public:
		virtual AbstractProductA* CreateProductA() { return new ProductA1() ; }
		virtual AbstractProductB* CreateProductB() { return new ProductB1() ; }

		static ConcreteFactory1* Instance() { static ConcreteFactory1 instance ; return &instance ; }
	protected:
		ConcreteFactory1() {}
	private:
		ConcreteFactory1(const ConcreteFactory1&) ;
		ConcreteFactory1& operator=(const ConcreteFactory1&) ;
	} ;

	class ConcreteFactory2 : public AbstractFactory
	{
	public:
		virtual AbstractProductA* CreateProductA() { return new ProductA2() ; }
		virtual AbstractProductB* CreateProductB() { return new ProductB2() ; }

		static ConcreteFactory2* Instance() { static ConcreteFactory2 instance ; return &instance ; }
	protected:
		ConcreteFactory2() {}
	private:
		ConcreteFactory2(const ConcreteFactory2&) ;
		ConcreteFactory2& operator=(const ConcreteFactory2&) ;
	} ;
}

客户端代码：
{
	using namespace DesignPattern_AbstractFactory ;
	// 第一种创建方法
	AbstractFactory *pFactory = ConcreteFactory1::Instance() ;
	AbstractProductA *pProductA = pFactory->CreateProductA() ;
	AbstractProductB *pProductB = pFactory->CreateProductB() ;

	// 第二种创建方法
	pFactory = ConcreteFactory2::Instance() ;
	pProductA = pFactory->CreateProductA() ;
	pProductB = pFactory->CreateProductB() ;
}

用通俗的话，解释一遍“功能：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。”用例子解说，在上面的客户端代码示例中，

我们原本要创建 ProductA1， ProductB1, ProductA2，ProductB2,四个对象，如果使用抽象工厂模式，首先，我们要提取一个抽象工厂类，就是

class AbstractFactory
{
public:
	virtual AbstractProductA* CreateProductA() = 0 ;// 创建ProductA
	virtual AbstractProductB* CreateProductB() = 0 ;// 创建ProductB
} ;

并在 AbstracFactory的具体子类中实现具体对象的创建过程，如：class AbstractFactory1, class AbstractFactory2.
在客户代码中，我们使用统一的对象创建过程：

pProductA = pFactory->CreateProductA() ;
pProductB = pFactory->CreateProductB() ;

创建对象。

客户代码不需要关心那4个具体对象的类。

优点：客户代码逻辑单一，指需要使用特定的具体子类，如，AbstractFactory1 的对象来创建其子对象。而不需要知道ProductA1，ProductB1类。

缺点：当新增一个具体对象类，如ProductC1时，要在抽象工厂类中新增抽象的创建方法，并在各个具体实现子类中增加。