设计模式：抽象工厂模式（C++）【工厂方法升级】

抽象工厂模式介绍

在上一集的设计模式：工厂方法模式（C++）我们使用工厂方法模式能带来一系列的好处，我们将生成产品的工厂类进行了抽象化，一种产品 用专门的工厂进行生产。我们也知道 当产品种类特别多的时候 我们的工厂类会变的非常的多 ，产品有多少种，那么我们生成对应产品的工厂列就有多少种！难度没有更好一点的办法么？当然有嘛，有更好的设计模式来解决这个问题嘛。试想一下 一个工厂难道就只能生成一种产品？当然不是，可以生产一系列的产品。那么我们就可以进一步的抽象，工厂能够生成一系列的产品。

我们的抽象工厂模式 就是将工厂进行抽象 ，但是它是生产一系列的产品 ，它是针对产品族的！产品 对应的有多个产品系列。比如说我们以汽车工厂举例，抽象的汽车工厂可以生产宝马车、奔驰车、哈弗车。我们的具体工厂->中国工厂生产 国产宝马、国产奔驰、国产哈弗 这一系列的产品。宝马产品族 可以有 国产宝马、日产宝马、美国产的宝马。请看下面的模型图。

抽象工厂模式模型图

抽象工厂模式代码

Car.h 汽车类相关代码

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//宝马汽车基类 抽象宝马车
class BMWCar
{
public:
	BMWCar(string name)
	{
		this->name = name;
	}
	virtual void run() = 0;//纯虚函数
	void setName(string name)
	{
		this->name = name;
	}
	string getName()
	{
		return this->name;
	}
private:
	string name;
};
//奔驰汽车基类 抽象奔驰车
class BenzCar
{
public:
	BenzCar(string name)
	{
		this->name = name;
	}
	virtual void run() = 0;//纯虚函数
	void setName(string name)
	{
		this->name = name;
	}
	string getName()
	{
		return this->name;
	}
private:
	string name;
};
//哈弗汽车基类 抽象哈弗车
class HavalCar
{
public:
	HavalCar(string name)
	{
		this->name = name;
	}
	virtual void run() = 0;//纯虚函数
	void setName(string name)
	{
		this->name = name;
	}
	string getName()
	{
		return this->name;
	}
private:
	string name;
};
//国产宝马
class ChinaBMW :public BMWCar
{
public:
	ChinaBMW(string name) :BMWCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "国产宝马汽车欢迎您。" << endl;
	}
};
//国产奔驰
class ChinaBenz :public BenzCar
{
public:
	ChinaBenz(string name) :BenzCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "国产奔驰汽车欢迎您。" << endl;
	}
};
//国产哈弗
class ChinaHaval :public HavalCar
{
public:
	ChinaHaval(string name) :HavalCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "国产哈弗汽车欢迎您。" << endl;
	}
};
//美国宝马
class AmericaBMW :public BMWCar
{
public:
	AmericaBMW(string name) :BMWCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "美国宝马汽车欢迎您。" << endl;
	}
};
//美国奔驰
class AmericaBenz :public BenzCar
{
public:
	AmericaBenz(string name) :BenzCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "美国奔驰汽车欢迎您。" << endl;
	}
};
//美国哈弗
class AmericaHaval :public HavalCar
{
public:
	AmericaHaval(string name) :HavalCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "美国哈弗汽车欢迎您。" << endl;
	}
};
//小日本造的宝马
class JapanBMW :public BMWCar
{
public:
	JapanBMW(string name) :BMWCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "小日本造的宝马汽车欢迎您。" << endl;
	}
};
//小日本造的奔驰
class JapanBenz :public BenzCar
{
public:
	JapanBenz(string name) :BenzCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "小日本造的奔驰汽车欢迎您。" << endl;
	}
};
//小日本造的哈弗
class JapanHaval :public HavalCar
{
public:
	JapanHaval(string name) :HavalCar(name)
	{

	}
	void run()
	{
		cout << this->getName() << "已经启动。" << "小日本造的哈弗汽车欢迎您。" << endl;
	}
};

AbstractFactory.cpp 抽象工厂代码

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include "03 Car.h"
using namespace std;
/*
抽象工厂模式 针对的是产品族
每个具体的工厂 将生成不同系列的产品
*/
class AbstractCarFactory
{
public:
	virtual BMWCar* CreateBMWCar() = 0;//纯虚函数
	virtual BenzCar* CreateBenzCar() = 0;
	virtual HavalCar* CreateHavalCar() = 0;
};
//中国工厂 在中国生产的系列产品
class ChinaCarFactory :public AbstractCarFactory
{
public:
	BMWCar* CreateBMWCar()
	{
		return new ChinaBMW("中国宝马");
	}
	BenzCar* CreateBenzCar()
	{
		return new ChinaBenz("中国奔驰");
	}
	HavalCar* CreateHavalCar()
	{
		return new ChinaHaval("中国哈佛");
	}
};
//美国工厂 
class AmericaCarFactory :public AbstractCarFactory
{
public:
	BMWCar* CreateBMWCar()
	{
		return new AmericaBMW("美国牌宝马");
	}
	BenzCar* CreateBenzCar()
	{
		return new AmericaBenz("美国牌奔驰");
	}
	HavalCar* CreateHavalCar()
	{
		return new AmericaHaval("美国牌哈佛");
	}
};
//日本工厂
class JapanCarFactory :public AbstractCarFactory
{
public:
	BMWCar* CreateBMWCar()
	{
		return new JapanBMW("小日本造宝马");
	}
	BenzCar* CreateBenzCar()
	{
		return new JapanBenz("小日本造奔驰");
	}
	HavalCar* CreateHavalCar()
	{
		return new JapanHaval("小日本造哈佛");
	}
};
int main(int argc, char *argv[])
{
	AbstractCarFactory *chinaFactroy = new ChinaCarFactory();
	AbstractCarFactory *americaFactroy = new AmericaCarFactory();
	AbstractCarFactory *japanFactroy = new JapanCarFactory();
	//中国工厂生产的系列汽车
	BMWCar* chinaBMW  = chinaFactroy->CreateBMWCar();
	BenzCar* chinaBenz = chinaFactroy->CreateBenzCar();
	HavalCar* chinaHaval = chinaFactroy->CreateHavalCar();
	//美国工厂生产的系列汽车
	BMWCar* americaBMW = americaFactroy->CreateBMWCar();
	BenzCar* americaBenz = americaFactroy->CreateBenzCar();
	HavalCar*americaHaval = americaFactroy->CreateHavalCar();
	//小日本工厂生产的系列汽车
	BMWCar* japanBMW = japanFactroy->CreateBMWCar();
	BenzCar* japanBenz = japanFactroy->CreateBenzCar();
	HavalCar*japanHaval = japanFactroy->CreateHavalCar();

	//汽车跑起来。。。
	chinaBMW  ->run();
	chinaBenz ->run();
	chinaHaval->run();

	americaBMW->run();
	americaBenz->run();
	americaHaval->run();

	japanBMW->run();
	japanBenz->run();
	japanHaval->run();

	return EXIT_SUCCESS;
}

代码运行结果