工厂模式

一 简介

工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。

二 简单工厂

它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产厂家，它只有一个工厂，能够生产两种型号的产品。客户需要什么样的产品，一定要显示地告诉生产工厂。

简单工厂UML图

下面给出一种实现方案。

enum ProductType
{
	em_ProductA,
	em_ProductB,
};
//产品基类
class Product
{
public:
	virtual ~Product() {};
	virtual void show() = 0;

};
//A产品
class ProductA :public Product
{
public:
	void show() { cout << "Product A" << endl; }
};
//B产品
class ProductB : public Product
{
public:
	void show() { cout << "Product B" << endl; }

};
//唯一的工厂，可以生产两种型号的产品，在内部判断 
class Factory
{
public:
	Product * createProcuct(ProductType productType);

};

Product * Factory::createProcuct(ProductType productType)
{
	switch (productType)
	{
	case em_ProductA:
		return new ProductA();
	case em_ProductB:
		return new ProductB();
	default:
		break;
	}
	return nullptr;
}

int main()
{
	Factory fac;
	Product * proA = fac.createProcuct(em_ProductA);
	Product * proB = fac.createProcuct(em_ProductB);
	proA->show();
	proB->show();
	
	delete proA;
	delete proB;

	getchar();
	return 0;
}

这样设计的主要缺点，就是要增加新的产品类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

三 工厂方法模式

听起来很抽象，还是以刚才的例子解释。这家产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的产品，而原来的工厂专门用来生产A型号的产品。这时，客户要做的是找好工厂，比如要A型号的产品，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的产品了。

工厂方法模式UML图

下面给出一个实现方案。

//产品基类
class Product
{
public:
	virtual ~Product() {};
	virtual void show() = 0;

};
//产品A
class ProductA :public Product
{
public:
	void show() { cout << "Product A" << endl; }

};
//产品B
class ProductB :public Product
{
public:
	void show() { cout << "Product B" << endl; }

};
//工厂基类
class Factory
{
public:
	virtual Product * createProduct() = 0;
	virtual ~Factory() {};

};
//生产A产品的工厂
class FactoryA :public Factory
{
public:
	Product * createProduct() { return new ProductA(); }
};
//生产B产品的工厂
class FactoryB :public Factory
{
public:
	Product * createProduct() { return new ProductB(); }
};


int main()
{
	FactoryA facA;
	Product * proA = facA.createProduct();

	FactoryB facB;
	Product * proB= facB.createProduct();

	proA->show();
	proB->show();

	delete proA;
	delete proB;

	getchar();
	return 0;
}

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的产品，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

四 抽象工厂模式

既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产产品1，也能生产产品2。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产1型号的产品，而另一个工厂专门用来生产2型号的产品。
抽象工厂模式UML图

下面给出实现的代码

//产品A基类
class ProductA
{
public:
	virtual void show() = 0;
	virtual ~ProductA() {};
};
//产品A的新类型1
class ProductA1 :public ProductA
{
public:
	void show() { cout << "Product A1" << endl; }
};
//产品A的新类型2
class ProductA2 :public ProductA
{
public:
	void show() { cout << "Product A2" << endl; }
};
//产品B基类
class ProductB
{
public:
	virtual void show() = 0;
	virtual ~ProductB() {};
};

//产品B的新类型1
class ProductB1 :public ProductB
{
public:
	void show() { cout << "Product B1" << endl; }
};
//产品B的新类型2
class ProductB2 :public ProductB
{
public:
	void show() { cout << "Product B2" << endl; }
};
//工厂基类
class Factory
{
public:
	virtual ProductA * createProductA() = 0;
	virtual ProductB * createProductB() = 0;
	virtual ~Factory() {};
};
//专门生产1号产品的工厂
class Factory1 :public Factory
{
public:
	ProductA * createProductA() { return new ProductA1(); }
	ProductB * createProductB() { return new ProductB1(); }
};
//专门生产2号产品的工厂
class Factory2 :public Factory
{
public:
	ProductA * createProductA() { return new ProductA2(); }
	ProductB * createProductB() { return new ProductB2(); }
};

int main()
{
	Factory1 fac1;
	ProductA *proA1 = fac1.createProductA();
	ProductB *proB1 = fac1.createProductB();
	proA1->show();
	proB1->show();

	Factory1 fac2;
	ProductA *proA2 = fac2.createProductA();
	ProductB *proB2 = fac2.createProductB();
	proA2->show();
	proB2->show();

	delete proA1;
	delete proA2;
	delete proB1;
	delete proB2;

	getchar();
	return 0;
}