设计模式：Abstract Facotry（抽象工厂） 模式

Abstract Factory 抽象工厂模式：

简单工厂，主要目的是为了创建具体的Object，对象比较单一化。而且简单工厂基本采用继承机制。而抽象工厂对象比较复杂，需要为特定情况创建对象组。

抽象工厂的主要目的：协调对象组，提供一种方式，将如何执行对象实例化的规则从使用这些对象的客户对象提取出来。

理解：

举个栗子：

现在一家电子工厂正在加工设备，现在生产PC和手机，手机有Windows系统和Linux系统，PC也具有Windows和Linux系统，现在我们要加工各种手机和各种PC。

那么我们可以这样做：

#include <iostream>
#include <string>
using namespace  std;

class CLinux
{
public:
	virtual ~CLinux(){};
	virtual void Start() = 0;
};


class CLinuxMobile : public CLinux
{
public:
	CLinuxMobile()
	{
		cout << "create linux mobile." << endl;
	}
	virtual ~CLinuxMobile() {};
	virtual void Start()
	{
		cout << "linux mobile start." << endl;
	};
};

class CLinuxPC : public CLinux
{
public:
	CLinuxPC()
	{
		cout << "create linux PC." << endl;
	}
	virtual ~CLinuxPC() {};
	virtual void Start()
	{
		cout << "linux PC start." << endl;
	};
};

class CWindows
{
public:
	virtual ~CWindows() {};
	//产品使用公共接口
	virtual void Start() = 0;
};

class CWindowsMobile : public CWindows
{
public:
	CWindowsMobile()
	{
		cout << "create windows mobile." << endl;
	}
	virtual ~CWindowsMobile() {};
	virtual void Start()
	{
		cout << "windows mobile start." << endl;
	};
};
class CWindowsPC : public CWindows
{
public:
	CWindowsPC()
	{
		cout << "create windows PC." << endl;
	}
	virtual ~CWindowsPC() {};
	virtual void Start()
	{
		cout << "windows PC start." << endl;
	};
};

class CFactory
{
public:
	virtual ~CFactory(){};
	//产品族有个产品组件
	virtual CLinux* CreateLinux() = 0;
	virtual CWindows* CreateWindows() = 0;
};

class CMobileFactory : public CFactory
{
public:
	CMobileFactory()
	{
		cout << "create mobile factory." << endl;
	}
	virtual ~CMobileFactory(){};
	virtual CLinux* CreateLinux()
	{
		return new CLinuxMobile;
	};
	virtual CWindows* CreateWindows()
	{
		return new CWindowsMobile;
	};
};

class CPCFactory : public CFactory
{
public:
	CPCFactory()
	{
		cout << "create PC factory." << endl;
	}
	virtual ~CPCFactory(){};
	virtual CLinux* CreateLinux()
	{
		return new CLinuxPC;
	};
	virtual CWindows* CreateWindows()
	{
		return new CWindowsPC;
	};
};
void Test(CFactory* pFactory)
{
	CLinux* pLinux = NULL;
	CWindows* pWindows = NULL;

	pLinux = pFactory->CreateLinux();
	pWindows = pFactory->CreateWindows();
	pLinux->Start();
	pWindows->Start();
	delete pWindows;
	delete pLinux;
};

int main()
{
	CFactory* pFactory = NULL;

	//手机工厂。生产手机产品族，种类有Linux和Windows
	pFactory = new CMobileFactory;
	Test(pFactory);
	delete pFactory;
	cout << endl;

	//PC工厂。生产PC产品族，种类有Linux和Windows
	pFactory = new CPCFactory;
	Test(pFactory);
	delete pFactory;

	system("pause");
	return 0;
}

解释 ：

AbstractProductA可以看做是Windows，ProductA1 和ProductA2可看做WindowsMobile和WindowsPC。

AbstractProductB可以看做是Linux，ProductB1 和ProductB2可看做LinuxMobile 和LinuxPC。

AbstractFactory可以看做是Factory，这里包含了创建Windows 和Linux 组件的方法。

那么我们在加工手机和PC时，就可以创建Mobile工厂和PC工厂，继承自AbstractFactory，那么再调用相应的方法即可。

要点:

1. 抽象工厂应用场景：

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

2. 新增产品复杂。抽象工厂增加产品组件时，需要更改所有工厂的接口。如增加产品ProductC，则工厂基类和具体工厂需要增加接口CreateProductC。

3. 抽象工厂模式与工厂方法模式的区别:

a． 重点不同。工厂方法模式强调的是不同的创建者根据自身需求去生产不同的具体产品，重点是生产具体产品；而抽象工厂模式则定位为“在不指定实体类别的前提下，提供了一个可以创建一系列相关或互相依赖之组件的接口”，重点是创建相关组件。
b． 抽象工厂提供了的“相关组件”可以看成是具体的产品（如ProductA1），抽象工厂模式的“相关组件”可由工厂模式实现。ConcreteFactory1.CreateProuductA()生产的具体产品，可以用工厂方法模式实现，即每一个产品用一个工厂方法实现。
c． 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
d． 抽象工厂不能直接创建产品，只能创建工厂，即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法，但需要创建出来的具体的工厂实现，即抽象工厂创建出的工厂创建产品。
e． 工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）；而抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。