设计模式 - 简单工厂模式

简单工厂模式：
考虑代码的可维护性，可重用性，可扩展性，灵活性。

用一个单独的类去创建实例的过程，就是工厂。

实例代码：

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 
  6 namespace ConsoleApplication1
  7 {
  8     enum Operators
  9     {
 10         Add,
 11         Sub,
 12         Mul,
 13         Div
 14     }
 15 
 16     #region Opertaots
 17 
 18     class Operator
 19     {
 20         public double NumberA
 21         {
 22             get;
 23             set;
 24         }
 25 
 26         public double NumberB
 27         {
 28             get;
 29             set;
 30         }
 31 
 32         public virtual double GetResult()
 33         {
 34             double result = 0d;
 35             return result;
 36         }
 37     }
 38 
 39     class OperatorAdd: Operator
 40     {
 41         public override double GetResult()
 42         {
 43             double result = 0d;
 44             result = NumberA + NumberB;
 45 
 46             return result;
 47         }
 48     }
 49 
 50     class OperatorSub : Operator
 51     {
 52         public override double GetResult()
 53         {
 54             double result = 0d;
 55             result = NumberA - NumberB;
 56 
 57             return result;
 58         }
 59     }
 60 
 61     class OperatorMul : Operator
 62     {
 63         public override double GetResult()
 64         {
 65             double result = 0d;
 66             result = NumberA * NumberB;
 67 
 68             return result;
 69         }
 70     }
 71 
 72     class OperatorDiv : Operator
 73     {
 74         public override double GetResult()
 75         {
 76             double result = 0d;
 77             if (NumberB == 0)
 78                 throw new Exception("divisor cannot be 0!");
 79 
 80             result = NumberA / NumberB;
 81 
 82             return result;
 83         }
 84     }
 85 
 86     #endregion
 87 
 88     #region Operators Factory
 89 
 90     class OperatorFactory
 91     {
 92         public static Operator CreateOperator(Operators ope)
 93         {
 94             Operator myOperator = null;
 95 
 96             switch (ope)
 97             {
 98                 case Operators.Add:
 99                     myOperator = new OperatorAdd();
100                     break;
101                 case Operators.Sub:
102                     myOperator = new OperatorSub();
103                     break;
104                 case Operators.Mul:
105                     myOperator = new OperatorMul();
106                     break;
107                 case Operators.Div:
108                     myOperator = new OperatorDiv();
109                     break;
110             }
111 
112             return myOperator;
113         }
114     }
115 
116     #endregion
117 
118     class Program
119     {
120         static void Main(string[] args)
121         {
122             Operator ope = OperatorFactory.CreateOperator(Operators.Add);
123             ope.NumberA = 5.25;
124             ope.NumberB = 3.69;
125 
126             double result = ope.GetResult();
127 
128             Console.ReadLine();
129         }
130     }
131 }

以上实例中：基类Operator，可以在Code中直接实例化此类，设置两个操作数，但是并不知道它是具体哪个操作符，调用GetResult方法始终获取到0，并不是最优的Class设计。

优化后的简单工厂模式Code：将基类标记为抽象类，不能直接实例化。

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 
  6 namespace ConsoleApplication1
  7 {
  8     enum Operators
  9     {
 10         Add,
 11         Sub,
 12         Mul,
 13         Div
 14     }
 15 
 16     #region Opertaots
 17 
 18     abstract class Operator
 19     {
 20         public double NumberA
 21         {
 22             get;
 23             set;
 24         }
 25 
 26         public double NumberB
 27         {
 28             get;
 29             set;
 30         }
 31 
 32         public abstract double GetResult();
 33     }
 34 
 35     class OperatorAdd: Operator
 36     {
 37         public override double GetResult()
 38         {
 39             double result = 0d;
 40             result = NumberA + NumberB;
 41 
 42             return result;
 43         }
 44     }
 45 
 46     class OperatorSub : Operator
 47     {
 48         public override double GetResult()
 49         {
 50             double result = 0d;
 51             result = NumberA - NumberB;
 52 
 53             return result;
 54         }
 55     }
 56 
 57     class OperatorMul : Operator
 58     {
 59         public override double GetResult()
 60         {
 61             double result = 0d;
 62             result = NumberA * NumberB;
 63 
 64             return result;
 65         }
 66     }
 67 
 68     class OperatorDiv : Operator
 69     {
 70         public override double GetResult()
 71         {
 72             double result = 0d;
 73             if (NumberB == 0)
 74                 throw new Exception("divisor cannot be 0!");
 75 
 76             result = NumberA / NumberB;
 77 
 78             return result;
 79         }
 80     }
 81 
 82     #endregion
 83 
 84     #region Operators Factory
 85 
 86     class OperatorFactory
 87     {
 88         public static Operator CreateOperator(Operators ope)
 89         {
 90             Operator myOperator = null;
 91 
 92             switch (ope)
 93             {
 94                 case Operators.Add:
 95                     myOperator = new OperatorAdd();
 96                     break;
 97                 case Operators.Sub:
 98                     myOperator = new OperatorSub();
 99                     break;
100                 case Operators.Mul:
101                     myOperator = new OperatorMul();
102                     break;
103                 case Operators.Div:
104                     myOperator = new OperatorDiv();
105                     break;
106             }
107 
108             return myOperator;
109         }
110     }
111 
112     #endregion
113 
114     class Program
115     {
116         static void Main(string[] args)
117         {
118             Operator ope = OperatorFactory.CreateOperator(Operators.Add);
119             ope.NumberA = 5.25;
120             ope.NumberB = 3.69;
121 
122             double result = ope.GetResult();
123 
124             Console.ReadLine();
125         }
126     }
127 }

UML类图：

类：矩形框表示。
第一行为类名，如果为抽象类，类名用斜体表示；
第二行为特性，就是字段和属性；
第三行为操作，通常是方法和行为，+表示 public，- 表示private， #表示protected；

接口：矩形框表示，和类图的区别主要是顶端有<<interface>>显示。
第一行为接口名称；
第二行为接口方法；
接口的另一种表示，棒棒糖表示法。顶端有个类似棒棒糖的形状，棒棒糖旁边是接口名称。

继承用三角形+实线表示，实现接口用三角形+虚线表示。

关联关系（Association）：用实线+箭头表示。

聚合关系（Aggregation）：表示一种弱的拥有关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分，用空心菱形+实线箭头表示。

组合（合成）Composite：是一种强拥有关系，体现的是严格的部分和整体的关系，部分和整体的声明周期一样，用实心菱形+实线箭头表示。

关联，聚合，合成关系都可以有基数。

依赖关系（Dependency）：虚线箭头表示。

posted on 2018-07-10 10:24 zzunstu 阅读(85) 评论(0) 编辑收藏举报