设计模式记录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     }

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

 //简单工厂客户端方法
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语句中增加分支就可以了。