大话设计模式C++实现-第8章-工厂方法模式

一、UML图

二、概念

工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法是一个类的实例化延迟到其子类。

三、包括的角色

（1）抽象工厂

（2）详细工厂

（3）抽象产品

（4）详细产品

四、优势

（1）工厂方法模式是对简单工厂模式的略微的改进。工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际工作推迟到子类中。

（2）与简单工厂模式相比，制造产品的工厂类不再 仅仅有一个。而是每种详细产品类都相应一个生产它的详细工厂类。

而这些详细工厂类的共同特征再被提取出来形成一个抽象产品类，这些详细产品类都继承自这个抽象产品类。

（3）当须要添加一种产品的时候，须要做的是：添加一种继承自抽象产品的详细产品类。添加一种继承在抽象工厂的详细工厂类。更改client。而不须要在简单工厂模式中那样更改工厂内的switch。

五、C++实现

（1）计算器的样例

#include <iostream>
#include <cstdlib>

using namespace std;

//抽象产品类
class Operation
{
protected:
	double numberA;
	double numberB;

public:
	double getA()
	{
		return numberA;
	}
	double getB()
	{
		return numberB;
	}
	void setA(double number)
	{
		numberA=number;
	}
	void setB(double number)
	{
		numberB=number;
	}

	virtual double GetResult()
	{
		double result=0;
		return result;
	}
};
//以下是四个详细产品类
class OperationAdd:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		result=numberA+numberB;
		return result;
	}
};

class OperationSub:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		result=numberA-numberB;
		return result;
	}
};

class OperationMul:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		result=numberA*numberB;
		return result;
	}
};

class OperationDiv:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		if(numberB!=0)
			result=numberA/numberB;
		return result;
	}
};

//抽象工厂类
class AbstractFactory
{
public:
	virtual Operation* createOperation()
	{
		return new Operation;
	}
};
//以下是四个详细工厂类。分别用于产生四个详细产品
class AddFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationAdd;
		return oper;
	}
};

class SubFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationSub;
		return oper;
	}
};

class MulFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationMul;
		return oper;
	}
};

class DivFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationDiv;
		return oper;
	}
};

//client
void main()
{
	AbstractFactory* af=NULL;
	af=new AddFactory();
	
	Operation* oper=NULL;
	oper=af->createOperation();
	
	oper->setA(1);
	oper->setB(2);
	cout<<oper->GetResult()<<endl;
	
	if(af!=NULL)
	{
		delete af;
		af=NULL;
	}
	if(oper!=NULL)
	{
		delete oper;
		oper=NULL;
	}

	system("pause");
}

（2）雷锋工厂的样例

#include <iostream>
#include <cstdlib>

using namespace std;

//抽象产品类：雷锋
class Leifeng
{
public:
	virtual void Sweep()
	{
		cout<<"扫地"<<endl;
	}
	virtual void Wash()
	{
		cout<<"洗衣"<<endl;
	}
	virtual void BuyRice()
	{
		cout<<"买米"<<endl;
	}
};

//以下是两个详细产品类
class Undergraduate:public Leifeng
{
public:
	void Sweep()
	{
		cout<<"学生-扫地"<<endl;
	}
	void Wash()
	{
		cout<<"学生-洗衣"<<endl;
	}
	void BuyRice()
	{
		cout<<"学生-买米"<<endl;
	}
};

class Volunteer:public Leifeng
{
public:
	void Sweep()
	{
		cout<<"志愿者-扫地"<<endl;
	}
	void Wash()
	{
		cout<<"志愿者-洗衣"<<endl;
	}
	void BuyRice()
	{
		cout<<"志愿者-买米"<<endl;
	}
};

//抽象工厂类
class AbstractFactory
{
public:
	virtual Leifeng* CreateLeifeng()
	{
		return new Leifeng;
	}
};

//以下是两个详细工厂类，分别于两个详细产品相相应
class UndergraduateFactory:public AbstractFactory
{
public:
	Undergraduate* CreateLeifeng()
	{
		return new Undergraduate;
	}
};

class VolunteerFactory:public AbstractFactory
{
public:
	Volunteer* CreateLeifeng()
	{
		return new Volunteer();
	}
};

//client
void main()
{
	//想要生产Volunteer产品的话，仅仅须要将此处的UndergraduateFactory更改为VolunteerFactory就可以。
	AbstractFactory* af=NULL;
	af=new VolunteerFactory;
	
	Leifeng* lf=NULL;
	lf=af->CreateLeifeng();

	lf->BuyRice();
	lf->Sweep();
	lf->Wash();

	if(af!=NULL)
	{
		delete af;
		af=NULL;
	}
	if(lf!=NULL)
	{
		delete lf;
		lf=NULL;
	}

	system("pause");
}

（3）执行截图