设计模式学习笔记一:Simple factory pattern,简单工厂模式

以下纯属个人学习笔记，并不是文章，但是还是希望有人可以指出错误，大家一起学习，谢谢

 

编程需要用尽可能的办法去避免重复。

 

先写一个父类，在父类中写一个虚方法，然后通过编写各种新的子类来继承这个父类，并且重写父类的那个虚方法，以上步骤完成后，再新建一个类用于判断在什么时候实例化那个类，而这个新建的类就是Simple factory pattern的体现，具体参照一下示例代码。

计算器程序，用Simple factory pattern思想进行编写

(1)准备被继承的父类，运算类

    public class Operation
    {
        private double _numberA = 0;

        private double _numberB = 0;

        //构造器数字A
        public double NumberA
        {
            get 
            {
                return _numberA;
            }
            set
            {
                _numberA = value;
            }
        }

        //构造器数字B
        public double NumberB
        {
            get
            {
                return _numberB;
            }
            set 
            {
                _numberB = value;
            }
        }

        //需要被重写的虚方法，计算两个数字的方法
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

(2)各种继承并且重写父类的子类

 1     /// <summary>
 2     /// 加法
 3     /// </summary>
 4     class OperationAdd : Operation
 5     {
 6         public override double GetResult()
 7         {
 8             double result = 0;
 9             result = NumberA + NumberB;
10             return result;
11         }
12     }
13 
14     /// <summary>
15     /// 减法
16     /// </summary>
17     class OperationSub : Operation
18     {
19         public override double GetResult()
20         {
21             double result = 0;
22             result = NumberA - NumberB;
23             return result;
24         }
25     }
26 
27     /// <summary>
28     /// 乘法
29     /// </summary>
30     class OperationMul : Operation
31     {
32         public override double GetResult()
33         {
34             double result = 0;
35             result = NumberA * NumberB;
36             return result;
37         }
38     }
39 
40     /// <summary>
41     /// 除法
42     /// </summary>
43     class OperationDiv : Operation
44     {
45         public override double GetResult()
46         {
47             double result = 0;
48             if (NumberB == 0)
49             {
50                 throw new Exception("除数不能为0");
51             }
52             result = NumberA / NumberB;
53             return result;
54         }
55     }

(3)工厂类

 1     public class OperationFactory
 2     {
 3         /// <summary>
 4         /// 定义了一个返回类型为运算类(Operation)的静态方法
 5         /// </summary>
 6         /// <param name="operate">操作符</param>
 7         /// <returns></returns>
 8         public static Operation createOperate(string operate)
 9         {
10             Operation oper = null;
11             switch (operate)
12             { 
13                 case "+":
14                     oper = new OperationAdd();
15                     break;
16                 case "-":
17                     oper = new OperationSub();
18                     break;
19                 case "*":
20                     oper = new OperationMul();
21                     break;
22                 case "/":
23                     oper = new OperationDiv();
24                     break;
25             }
26             return oper;
27         }
28     }

(4)前台运用

         protected void Page_Load(object sender, EventArgs e)
2         {
3             Operation oper;  //声明一个运算类
4             oper = OperationFactory.createOperate("+");  //告诉工厂类，实例化加法运算的子类
5             oper.NumberA = 1;  //给予运算类数字A赋值
6             oper.NumberB = 2;  //给予运算类数字A赋值
7             double result = oper.GetResult();  //使用已经被实例化成加法类的运算类进行GetResult函数运算。
8         }

 以上，就是一个计算器的开发，使用了Simple factory pattern设计思想，在开发初期知道了(1)这个类中的方法在日后的开发过程中可能被多次添加或者修改，那么这个时候就可以确定这个父类需要使用一个虚方法在各种子类中进行实现，从而开始编写(2),在各种子类中继承了父类，并且使用override关键字对父类的虚方法进行了重写以达到各种功能的实现，这个步骤完成之后就可以开始编写工厂类(3)了，使用工厂类使得整个程序得到了封装和多态的特性，在日后的维护中也不会破坏其他的独立部分。

 

如果需要加新功能之需要新写一个类来继承运算类，然后在工厂类中新添加一个分支，完全不会波及到已经运行稳定的程序部分，如果需要修改那就更加方便，之需要对单独的运算子类进行编辑就可以了。

 

 

 

其实我理解中使用Simple factory pattern的主要过程已经完全体现了面向对象的封装，继承，多态，这个模式主要达到的目的是在为某一个功能新加功能或者修正原本某一个分支功能的时候，不会对原有的运行良好的功能代码产生影响，如果我们需要新加一个功能之需要新写一个类来继承那个有虚方法的父类，如果修改之需要修改一个子类就可以，完全不会波及到其他的类。