设计模式（2）结合代码和例子来理解简单工厂模式

简介

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

父类或接口）的实例。不属于23个GOF模式,但他可以作为工厂方法模式(Factory Method)的一个引导.属于创建型模

式，又叫做静态工厂方法（StaticFactory Method），是众多工厂模式中最简单实用的模式。

角色构成

抽象产品角色

定义简单工厂创造的对象父类，可以是一个类、或者一个接口。

[csharp] view plaincopyprint?

1. <SPAN style="FONT-SIZE: 18px">//声明创建对象的父类   
2. public class Operation  
3. {  
4.       privat double _numberA=0;   //声明一个双精度变量   
5.       private double _numberB=0;  
6.       public double NumberA  
7.       {  
8.         get {return _numberA;}   //当读取时，取得_numberA=0   
9.         set {_numberA=value ;} //可以动态给_numberA赋值   
10.          public double NumberA  
11. {  
12.           get {return_numberB;}  
13.            set {_numberB=value;}  
14. }  
15.           public virtual double GetResult()  //重写GetResult   
16. <SPAN>  </SPAN>{  
17.             double result =0;  
18.             return result;  
19.   
20. }  
21. }</SPAN>  

//声明创建对象的父类public class Operation{      privat double _numberA=0;   //声明一个双精度变量      private double _numberB=0;      public double NumberA      {        get {return _numberA;}   //当读取时，取得_numberA=0        set {_numberA=value ;} //可以动态给_numberA赋值         public double NumberA{          get {return_numberB;}           set {_numberB=value;}}          public virtual double GetResult()  //重写GetResult	{            double result =0;            return result;}}

具体产品角色 

他是工厂具体加工的对象

[csharp] view plaincopyprint?

1. <SPAN style="FONT-SIZE: 18px">// 声明一个加法操作类，继承上面的operation   
2. class OperatinAdd:operation   
3. {  
4.       public override double GetResult ()  
5.       {  
6.             double result =0;  
7.             result =numberA+numberB;  
8.              return result ;  
9. }  
10. }</SPAN>  

// 声明一个加法操作类，继承上面的operationclass OperatinAdd:operation {      public override double GetResult ()      {            double result =0;            result =numberA+numberB;             return result ;}}

上面是一个加法具体产品角色，还有减法和乘法、除法类似。

工厂角色

simple factory的核心，含所有实例的内部逻辑，可被客户端等调用，用来创建产品所需的对象。

他定义了简单工厂的创造的对象的父类，会在创建的对象的时候继承此类。他可以是一个接口，可以使一个抽象类。

首先构造一个OperationFactory，以此来创建分配各个操作符之间的逻辑关系。比如：加法，就是在我输入加法符号

时，创建一个加法操作。其他运算符同理。代码如下

[csharp] view plaincopyprint?

1. <SPAN style="FONT-SIZE: 18px">//简单工厂类，定义各个操作符之间逻辑   
2. Public class OperateFactory  
3. {  
4.      public static Operation createoperate(string operate)  
5. {  
6.      operation oper=null;   //声明一个无引用的变量   
7.      switch (operate)   //分支语句来处理逻辑关系   
8.      {  
9.             case "+":  
10.              oper=new OperationAdd();   //创建关于加法的操作   
11.              break；  
12.               case  "-":  
13.               oper=new OperationSub();  
14.               break;  
15.                case "*":  
16.                break;  
17.                case "/":  
18.                 oper=new OperationDiv();  
19.                 break;  
20. }  
21.                  return oper;  
22.      }  
23. }</SPAN>  

//简单工厂类，定义各个操作符之间逻辑Public class OperateFactory{     public static Operation createoperate(string operate){     operation oper=null;   //声明一个无引用的变量     switch (operate)   //分支语句来处理逻辑关系     {            case "+":             oper=new OperationAdd();   //创建关于加法的操作             break；              case  "-":              oper=new OperationSub();              break;               case "*":               break;               case "/":                oper=new OperationDiv();                break;}                 return oper;     }}

    以上就是整个的工厂角色，也是整个简单工厂模式的核心。它处理了操作符之间的逻辑关系，他可以被直接调用用

来处理所输入的操作符和数字。

总结这个例子，这里例子分为三部分。我们需要先从简单工厂模式来说起才显得完整。

       第一部分：构造工厂类，处理操作符之间逻辑关系。

       第二部分：创建对象父类。里面声明了类的属性numberA与number B。为下一步在创建对象时直接调用这个属

性，再利用操作符来对这两个属性值进行运算。

      第三部分：创建对象，继承了operation，减少代码的重复。