抽象工厂模式

抽象工厂模式和工厂方法模式看上去十分像，其类图结构都一样，都是在一个基类中声明对象创建抽象接口，将实际的创建工作延迟到子类中去。但是他们的意图确是不一样的，同时他们的使用策略也不一样，我想这也是将他们作为不同模式的原因之一吧。

工厂方法模式使用继承的方式在其子类中实现了工厂方法，同时供子类中的其他成员函数调用创建对应的对象。而抽象工厂模式则是提供一组接口，创建对象家族。并以引用的形式，供其他类创建对象。这里确实让人感到很纠结，我们需要仔细思考一下他们的运用场景，也许这样才知道什么时候用什么样的工厂模式。

抽象工厂模式主要用于将一个产品家族的创建集成起来，而工厂方法往往用于创建一个产品，是客户端代码与实例化的具体类解耦。

就说这么多吧，来看看抽象工厂模式的类图：

这里只画了一个产品对象分支，其余的就难得画了，大家应该能看明白吧，有疑问留言交流

要写一个这个模式的例子，代码还不少，主要是设计的类比较多，毕竟咱们要实现一个创建产品家族的模式，类不多，怎么能称得上是一个产品家族呢？

贴源码了：

#include <iostream>
#include <string>

using namespace std;

//汽车车轮
class CarWheel
{
public:
	CarWheel() : name("CarWheel"){}
	string name;
};

class BMWAmericaCarWheel : public CarWheel
{
public:
	BMWAmericaCarWheel()
	{
		name = "BMWAmericaCarWheel";
	}
};

class BenzAmericaCarWheel : public CarWheel
{
public:
	BenzAmericaCarWheel()
	{
		name = "BenzAmericaCarWheel";
	}
};

class BMWChinaCarWheel : public CarWheel
{
public:
	BMWChinaCarWheel()
	{
		name = "BMWChinaCarWheel";
	}
};

class BenzChinaCarWheel : public CarWheel
{
public:
	BenzChinaCarWheel()
	{
		name = "BenzChinaCarWheel";
	}
};


//汽车方向盘
class CarCircle
{
public:
	CarCircle() : name("CarCircle"){}
	string name;
};

class BMWAmericaCarCircle : public CarCircle
{
public:
	BMWAmericaCarCircle()
	{
		name = "BMWAmericaCarCircle";
	}
};

class BenzAmericaCarCircle : public CarCircle
{
public:
	BenzAmericaCarCircle()
	{
		name = "BenzAmericaCarCircle";
	}
};

class BMWChinaCarCircle : public CarCircle
{
public:
	BMWChinaCarCircle()
	{
		name = "BMWChinaCarCircle";
	}
};

class BenzChinaCarCircle : public CarCircle
{
public:
	BenzChinaCarCircle()
	{
		name = "BenzChinaCarCircle";
	}
};


//汽车座椅
class CarSeat
{
public:
	CarSeat() : name("CarSeat"){}
	string name;
};

class BMWAmericaCarSeat : public CarSeat
{
public:
	BMWAmericaCarSeat()
	{
		name = "BMWAmericaCarSeat";
	}
};

class BenzAmericaCarSeat : public CarSeat
{
public:
	BenzAmericaCarSeat()
	{
		name = "BenzAmericaCarSeat";
	}
};

class BMWChinaCarSeat : public CarSeat
{
public:
	BMWChinaCarSeat()
	{
		name = "BMWChinaCarSeat";
	}
};

class BenzChinaCarSeat : public CarSeat
{
public:
	BenzChinaCarSeat()
	{
		name = "BenzChinaCarSeat";
	}
};



//汽车配件工厂
class CarPartFactory
{
public:
	virtual CarWheel* createWheel(string type) = 0;
	virtual CarCircle* createCircle(string type) = 0;
	virtual CarSeat* createSeat(string type) = 0;
};

class AmericaCarPartFactory : public CarPartFactory
{
	CarWheel* createWheel(string type)
	{
		CarWheel *carWheel = NULL;

		if (type == "BMWCarWheel")
		{
			carWheel = new BMWAmericaCarWheel;
		}
		else if (type == "BenzCarWheel")
		{
			carWheel = new BenzAmericaCarWheel;
		}

		return carWheel;
	}

	CarCircle* createCircle(string type)
	{
		CarCircle *carCircle = NULL;

		if (type == "BMWCarCircle")
		{
			carCircle = new BMWAmericaCarCircle;
		}
		else if (type == "BenzCarCircle")
		{
			carCircle = new BenzAmericaCarCircle;
		}

		return carCircle;
	}

	CarSeat* createSeat(string type)
	{
		CarSeat *carSeat = NULL;

		if (type == "BMWCarSeat")
		{
			carSeat = new BMWAmericaCarSeat;
		}
		else if (type == "BenzCarSeat")
		{
			carSeat = new BenzAmericaCarSeat;
		}

		return carSeat;
	}
};

class ChinaCarPartFactory : public CarPartFactory
{
	CarWheel* createWheel(string type)
	{
		CarWheel *carWheel = NULL;

		if (type == "BMWCarWheel")
		{
			carWheel = new BMWChinaCarWheel;
		}
		else if (type == "BenzCarWheel")
		{
			carWheel = new BenzChinaCarWheel;
		}

		return carWheel;
	}

	CarCircle* createCircle(string type)
	{
		CarCircle *carCircle = NULL;

		if (type == "BMWCarCircle")
		{
			carCircle = new BMWChinaCarCircle;
		}
		else if (type == "BenzCarCircle")
		{
			carCircle = new BenzChinaCarCircle;
		}

		return carCircle;
	}

	CarSeat* createSeat(string type)
	{
		CarSeat *carSeat = NULL;

		if (type == "BMWCarSeat")
		{
			carSeat = new BMWChinaCarSeat;
		}
		else if (type == "BenzCarSeat")
		{
			carSeat = new BenzChinaCarSeat;
		}

		return carSeat;
	}
};

//汽车组装(这里就简单实现了，比较本文主要将的是抽象工厂模式)
//如果要实现不同类型汽车的创建，在汽车创建这一块可以采用工厂方法模式
class CarProduct
{
public:
	CarProduct(CarPartFactory *carPartFactory)
	{
		this->carPartFactory = carPartFactory;
	}

	~CarProduct()
	{
		delete carWheel;
		delete carCircle;
		delete carSeat;
	}

	void createCar()
	{
		carWheel = carPartFactory->createWheel("BMWCarWheel");
		carCircle = carPartFactory->createCircle("BMWCarCircle");
		carSeat = carPartFactory->createSeat("BMWCarSeat");

		cout << "生产汽车" << endl;
		cout << "使用的零件：" + carWheel->name + "、" + carCircle->name + "、" + carSeat->name << endl;
	}

private:
	CarPartFactory *carPartFactory;
	CarWheel *carWheel;
	CarCircle *carCircle;
	CarSeat *carSeat;


};

void main()
{
	int i = 0;
	CarPartFactory *americaCarPartFactory = new AmericaCarPartFactory;
	CarPartFactory *chinaCarPartFactory = new ChinaCarPartFactory;
	CarProduct *americaCarProduct = new CarProduct(americaCarPartFactory);
	CarProduct *chinaCarProduct = new CarProduct(chinaCarPartFactory);

	americaCarProduct->createCar();
	chinaCarProduct->createCar();

	delete americaCarPartFactory;
	delete chinaCarPartFactory;
	delete americaCarProduct;
	delete chinaCarProduct;

	cin >> i;
}

这里大概解释一下源码：

这里主要以构建一辆汽车为例子，假设我们需要组装宝马和奔驰等各种类型汽车，那么首先我们得先有它的零件吧，不同国家生产的零件还是有区别的，正常情况下美国工厂比中国工厂生产的好，所以我们需要针对不同的国家创建不同的零件生产工厂。既然生产出来的零件不一样，自然每一个零件针对不同国家都有对应的类（所以这里要创建的类就多了），当我们要组装汽车时，只需要将对应的工厂委托给汽车组装类，让委托的零件生产工厂类生产对应的零件进行组装即可。

感觉有点晕，本人水平有限，就只能讲到这种程度了，以后能力提升了，再来好好的理理思路。