设计模式记录2之"简单工厂模式"

下了本《大话设计模式》电子版在学习，据说也是cnblogs出身的，打算好好学习一下设计模式。今天上班趁着空闲阅读了"简单工厂模式"和"策略模式"。

 先记录一下"简单工厂模式"吧。

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

以一个简单的计算器为例子，上代码。

首先创建一个父类，其实也可以创建一个接口。

 1    ///   <summary>
 2       ///  简单工厂模式
 3       ///  计算类
 4       ///  成员：两个数，虚方法
 5       ///   </summary>
 6       public   class  Operation
 7      {
 8           private   double  numberOne;
 9 
10           public   double  NumberOne
11          {
12               get  {  return  numberOne; }
13               set  { numberOne  =  value; }
14          }
15           private   double  numberTwo;
16 
17           public   double  NumberTwo
18          {
19               get  {  return  numberTwo; }
20               set  { numberTwo  =  value; }
21          }
22          // 虚方法，子类重写父类的这个方法
23           public   virtual   double  GetOperation()
24          { 
25               double  result = 0 ;
26               return  result;
27          }
28      }

 然后创建计算子类，继承自这个父类。为方便，我在这里只建立两个计算类，加法和减法。其实这里可以根据需求来创建的，可以增加除法计算和乘法算法：

 1  ///   <summary>
 2       ///  加法计算类，继承自计算类Operation
 3       ///   </summary>
 4       ///   <returns></returns>
 5       public    class  AddOperation:Operation
 6      {
 7           // 重写父类中的计算方法
 8           public   override   double  GetOperation()
 9          {
10               // 继承了父类，可以直接调用两个成员
11               double  result  =  NumberOne  +  NumberTwo;
12               return  result;
13          }
14      }
15 
16 
17  ///   <summary>
18       ///  减法类，继承自计算类
19       ///  重写父类的虚方法
20       ///   </summary>
21       ///   <returns></returns>
22       public   class  SubOperation:Operation
23      {
24          
25           public   override   double  GetOperation()
26          {
27               double  result  =   0 ;
28              result  =  NumberOne  -  NumberTwo;
29               return   base .GetOperation();
30          }
31      }

 接着，创建工厂。在这个工厂中决定实例化哪一个类。

 1  ///   <summary>
 2       ///  工厂类
 3       ///  根据参数决定实例哪一个类
 4       ///   </summary>
 5       public   class  Factory
 6      {
 7        // 静态的工厂方法
 8         public   static  Operation createOperation( string  operation)
 9         {
10              // 定义父类，为空
11              Operation oper  =   null ;
12               switch  (operation)
13              { 
14                    // 根据参数决定实例化哪一个计算子类
15                   case   " + " :
16                      oper  =   new  AddOperation();
17                       break ;
18                   case   " - " :
19                      oper  =   new  SubOperation();
20                       break ;
21              }
22               return  oper;
23          }
24      }

 至此，简单工厂就已经写完了，在客户端我们可以这样用：

1  // 简单工厂客户端方法
2           public   double  Client( double  num1,  double  num2,  string  oper)
3          {
4              Operation operation  =  Factory.createOperation(oper);
5              operation.NumberOne  =  num1;
6              operation.NumberTwo  =  num2;
7               return  operation.GetOperation();
8          }

 至此，如果我们要有乘法或者除法或者其他更多的运算，只需要继续增加子类继承Operation，然后在工厂类中的switch语句中增加分支就可以了。