简单工厂设计模式

目录

-简单工厂模式

• 概念定义

• 应用场景

• 角色组成

• 案例代码

• 优、缺点
  工厂方法模式、抽象工厂模式

1、简单工厂模式

概念定义：

简单工厂模式，是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。

应用场景：

• 工厂类负责创建的对象比较少。
• 客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心。

角色组成：

• 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。
• 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。
• 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

案例代码

计算器

#include<iostream>
using namespace std;
//---------------运算类------------------
class Operation
{
public:
	Operation()
	{
		_numberA=0;
		_numberB=0;
	}
	Operation(double numberA,double numberB)
	{
		_numberA=numberA;
		_numberB=numberB;
	}
	void setNumberA(double value)
	{
		_numberA=value;
	}
	double getNumberA()
	{
		return _numberA;
	}
	void setNumberB(double value)
	{
		_numberB=value;
	}
 
	double getNumberB()
	{
		return _numberB;
	}
	virtual double GetResult()  
    {  
        double result = 0;  
        return result;  
    }  
private:
	double _numberA;
	double _numberB;
};
//----------加减乘除类----------
class OperationAdd:public Operation
{//加
public:
	OperationAdd(){}
	OperationAdd(double numberA,double numberB):Operation(numberA,numberB){}
	double GetResult()
	{
		double result=0;
		result=getNumberA()+getNumberB();
		return result;
	}
};
 
class OperationSub:public Operation
{//减
public:
	OperationSub(){}
	OperationSub(double numberA,double numberB):Operation(numberA,numberB){}
	double GetResult()
	{
		double result=0;
		result=getNumberA()-getNumberB();
		return result;
	}
};
class OperationMul:public Operation
{//乘
public:
	OperationMul(){}
	OperationMul(double numberA,double numberB):Operation(numberA,numberB){}
	double GetResult()
	{
		double result=0;
		result=getNumberA()*getNumberB();
		return result;
	}
};
class OperationDiv:public Operation
{//除
public:
	OperationDiv(){}
	OperationDiv(double numberA,double numberB):Operation(numberA,numberB){}
	double GetResult()
	{
		double result=0;
		if(getNumberB()==0)
		{
			throw new exception("除数不能为0");
		}
		result=getNumberA()/getNumberB();
 
		return result;
	}
};
//------------简单运算工厂类----------------
class OperationFactory
{
public:
	Operation *createOperation(char operate)
	{
		switch(operate)
		{
	 		case '+':
				oper = new OperationAdd();
				break;
			case '-':
				oper = new OperationSub();
				break;
			case '*':
				oper = new OperationMul();
				break;
			case '/':
				oper = new OperationDiv();
				break;
		}
		return oper;
	}
private:
	Operation *oper;
};

下面为代码测试：

 int main()  
{  
    Operation *oper;  
    OperationFactory OperFactory;  
    oper = OperFactory.createOperation('*');  
    oper->setNumberA(6);  
    oper->setNumberB(2);  
    double result = oper->GetResult();  
  
    cout<<"result = "<<result<<endl;
	system("pause");
	return 0;
}  

优点：

• 使用户根据参数获得对应的类实例，避免了直接实例化类，降低了耦合性。

缺点：

• 可实例化的类型在编译期间已经被确定，如果增加新类型，则需要修改工厂，违背了开放封闭原则(ASD) 。 简单工厂需要知道所有要生成的类型，当子类过多或者子类层次过多时不适合使用。