Factory 工厂模式

概述

Factory工厂模式是最常用的设计模式之一，它提供了一种创建对象的最佳方式；
在工厂模式中，我们在创建对象时不会对用户暴露逻辑，而是通过使用一个共同的接口来指向新创建的对象。

简单工厂

定义

简单工厂模式是工厂模式中最简单的一种，它用比较简单的方式来隐藏创建对象的细节，对修改不封闭，新增产品就需要修改工厂，不符合开闭原则。

结构

该模式包含的角色有：工厂角色、抽象产品角色、具体产品角色，类图如下：

示例程序

#include <iostream>
using namespace std;

/* 定义手机类型 */
enum PRODUCTTYPE { OPPO, VIVO, HUAWEI };

/* 抽象产品phone */
class phoneBase
{
public:
	virtual ~phoneBase() {};
	virtual void show() = 0;
};

/* OPPO具体产品phone */
class OPPOPhone :public phoneBase
{
public:
	void show() { cout << "OPPO Phone" << endl; }
};

/* VIVO具体产品phone */
class VIVOPhone :public phoneBase
{
public:
	void show() { cout << "VIVO Phone" << endl; }
};

/* HUAWEI具体产品phone */
class HUAWEIPhone :public phoneBase
{
public:
	void show() { cout << "HUAWEI Phone" << endl; }
};

/* 手机工厂 */
class Factory
{
public:
	/* 根据相应的类型进行生产 */
	phoneBase* createPhone(PRODUCTTYPE type)
	{
		switch (type)
		{
		case OPPO:
			return new OPPOPhone(); // 生产OPPO手机
			break;
		case VIVO:
			return new VIVOPhone(); // 生产VIVO手机
			break;
		case HUAWEI:
			return new HUAWEIPhone(); // 生产HUAWEI手机
			break;
		default:break;
		}

	}
};

int main()
{
	Factory factory;

	phoneBase* p1 = factory.createPhone(OPPO);
	p1->show();
	phoneBase* p2 = factory.createPhone(VIVO);
	p2->show();
	phoneBase* p3 = factory.createPhone(HUAWEI);
	p3->show();

	delete p1;
	delete p2;
	delete p3;
	return 0;
}

工厂方法

定义

工厂方法模式定义了一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中；

这样一来，核心类就是这个抽象工厂角色，它仅负责具体工厂子类必须实现的产品创建接口。这样进一步抽象化的好处是：使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引入新产品；

其完全实现开闭原则，实现了可扩展。

结构

该模式包含的角色有：抽象工厂角色、具体工厂角色、抽象产品角色、具体产品角色，类图如下：

示例程序

// 工厂方法
#include <iostream>
using namespace std;

/* 定义手机类型 */
enum PRODUCTTYPE { OPPO, VIVO, HUAWEI };

/* 抽象产品phone */
class phoneBase
{
public:
	virtual ~phoneBase() {};
	virtual void show() = 0;
};
/* OPPO具体产品phone */
class OPPOPhone :public phoneBase
{
public:
	void show() { cout << "OPPO Phone" << endl; }
};

/* VIVO具体产品phone */
class VIVOPhone :public phoneBase
{
public:
	void show() { cout << "VIVO Phone" << endl; }
};

/* HUAWEI具体产品phone */
class HUAWEIPhone :public phoneBase
{
public:
	void show() { cout << "HUAWEI Phone" << endl; }
};

/* 抽象工厂 */
class Factory
{
public:
	/* 提供抽象生产接口，由各个具体工厂实现 */
	virtual phoneBase* createPhone() = 0;
};

/* OPPO工厂 —— 专门负责生产OPPO手机 */
class OPPOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new OPPOPhone();
	}
};

/* VIVO工厂 —— 专门负责生产VIVO手机 */
class VIVOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new VIVOPhone();
	}
};

/* HUAWEI工厂 —— 专门负责生产HUAWEI手机 */
class HUAWEIFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new HUAWEIPhone();
	}
};


int main()
{
	OPPOFactory Ofactory;
	phoneBase* p1 = Ofactory.createPhone();
	p1->show();

	VIVOFactory Vfactory;
	phoneBase* p2 = Vfactory.createPhone();
	p2->show();

	HUAWEIFactory Hfactory;
	phoneBase* p3 = Hfactory.createPhone();
	p3->show();

	delete p1;
	delete p2;
	delete p3;
	return 0;
}

抽象工厂

定义

前面介绍的工厂方法模式只考虑一类产品的的生产，也就是说：工厂方法模式只考虑生产同等级的产品，但是实际应用场景下大多数是综合型的工厂，能够生产多等级的产品，比如说手机厂商不仅能生产手机，还能生产各种配件、芯片等；

抽象工厂模式除了具有工厂方法模式的优点外，其它主要优点如下：

• 可以在类内对产品族中相关联的多等级产品共同管理，而不必引入多个新类进行管理；
• 当增加一个新的产品族时，不需要修改源代码，满足开闭原则。

缺点是：当产品族中需要增加一个新产品时，所有的工厂类都需要进行修改。

结构

该模式包含的角色有：抽象工厂角色、具体工厂角色、抽象产品角色、具体产品角色，类图如下：

示例程序

// 抽象工厂
#include <iostream>
using namespace std;

/* 定义手机类型 */
enum PRODUCTTYPE { OPPO, VIVO, HUAWEI };

/* 定义其他产品类型：芯片、配件 */
enum OTHERTYPE { IC, CASE }; 

/* 定义抽象产品phone */
class phoneBase
{
public:
	virtual ~phoneBase() {};
	virtual void show() = 0;
};

/* OPPO具体产品phone */
class OPPOPhone :public phoneBase
{
public:
	void show() { cout << "OPPO Phone" << endl; }
};

/* VIVO具体产品phone */
class VIVOPhone :public phoneBase
{
public:
	void show() { cout << "VIVO Phone" << endl; }
};

/* HUAWEI具体产品phone */
class HUAWEIPhone :public phoneBase
{
public:
	void show() { cout << "HUAWEI Phone" << endl; }
};

/* 定义抽象产品OTHER */
class OTHERBase
{
public:
	virtual ~OTHERBase() {};
	virtual void show() = 0;
};

/* OPPO具体产品OTHER */
class OPPOOTHER :public OTHERBase
{
public:
	void show() { cout << "OPPO OTHER PRODUCT" << endl; }
};

/* VIVO具体产品OTHER */
class VIVOOTHER :public OTHERBase
{
public:
	void show() { cout << "VIVO OTHER PRODUCT" << endl; }
};

/* HUAWEI具体产品OTHER */
class HUAWEIOTHER :public OTHERBase
{
public:
	void show() { cout << "HUAWEI OTHER PRODUCT" << endl; }
};

/* 抽象工厂 : 提供了产品的生成方法。 */
class Factory
{
public:
	virtual phoneBase* createPhone() = 0;
	virtual OTHERBase* createOther() = 0;
};

/* OPPO具体工厂：实现了OPPO产品族的生成方法。 */
class OPPOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new OPPOPhone();
	}

	OTHERBase* createOther()
	{
		return new OPPOOTHER();
	}
};

/* VIVO具体工厂：实现了VIVO产品族的生成方法。 */
class VIVOFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new VIVOPhone();
	}

	OTHERBase* createOther()
	{
		return new VIVOOTHER();
	}
};

/* HUAWEI具体工厂：实现了HUAWEI产品族的生成方法。 */
class HUAWEIFactory : public Factory
{
public:
	phoneBase* createPhone()
	{
		return new HUAWEIPhone();
	}

	OTHERBase* createOther()
	{
		return new HUAWEIOTHER();
	}
};


int main()
{
	OPPOFactory Ofactory;
	phoneBase* p1 = Ofactory.createPhone();
	OTHERBase* p2 = Ofactory.createOther();
	p1->show();
	p2->show();

	VIVOFactory Vfactory;
	phoneBase* p3 = Vfactory.createPhone();
	OTHERBase* p4 = Vfactory.createOther();
	p3->show();
	p4->show();

	HUAWEIFactory Hfactory;
	phoneBase* p5 = Hfactory.createPhone();
	OTHERBase* p6 = Hfactory.createOther();
	p5->show();
	p6->show();

	delete p1;
	delete p2;
	delete p3;
	delete p4;
	delete p5;
	delete p6;
	return 0;
}