设计模式之简单工厂模式

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

该模式中包含的角色及其职责：

工厂（Creator）角色

   简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

抽象产品（Product）角色

  简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品（Concrete Product）角色

    是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
简单工厂模式是用一个单独的类来创造实例化的过程。只是解决了对象的创建问题。



用书上的例子编辑一个计算器解释下：

//创建运算类operation，定义double型变量。
public class Operation
{
private double _numberA = 0;
private double _numberB = 0;

public double NumberA
{
get { return _numberA; }
set { _numberA = value; }
}
public double NumberB
{
get { return _numberB; }
set { _numberB = value; }
}
public virtual double GetResult()
{
double result = 0;
return result;
}
}
//继承于运算类的加法类
class OperationADD:Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
//继承于运算类的减法类
class OperationSub:Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA - NumberB;
return result;
}
}
//继承于运算类的乘法类
class OperationMul:Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA * NumberB;
return result;
}
}
//继承于运算类的除法类
class OperationDiv:Operation
{
public override double GetResult()
{
double result = 0;
if (NumberB == 0)
throw new Exception("除数不能为0。");
result = NumberA/ NumberB;
return result;
}
}

//简单工厂运算类。根据需要“生产”出运算符。就像工厂一样，简单工厂模式是根据客户端不同的“要求”，
//产生不同的具体对象，再利用多态特性调用相应具体对象的方法。
public class OperationFactory
{
public static Operation createOperate(string operate)
{
Operation oper = null;
switch (operate)
{
case "+":
oper = new OperationADD();
break;
case "-":
oper = new OperationSub();
break;
case "*":
oper = new OperationMul();
break;
case "/":
oper = new OperationDiv();
break;

}
return oper;
}
}

在客户端输出。

class Program
{
static void Main(string[] args)
{
//客户端代码。输入+号就实例出加法运算类。
Operation oper;
oper = OperationFactory.createOperate("+");
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult();
}
}

这样就实现计算器了。好处是根据需要，工厂实例化出合适的对象，通过多态，返回父类的方式实现计算器。松耦合，这样就在之后的维护或者更新中不会大动代码。