简单工厂模式

为什么要用设计模式？

     1、设计模式是前人根据经验总结出来的，使用设计模式，就相当于是站在了前人的肩膀上。

     2、设计模式使程序易读。熟悉设计模式的人应该能够很容易读懂运用设计模式编写的程序。

     3、设计模式能使编写的程序具有良好的可扩展性，满足系统设计的开闭原则。比如策略模式，就是将不同的算法封装在子类中，在需要添加新的算法时，只需添加新的子类，实现规定的接口，即可在不改变现有系统源码的情况下加入新的系统行为。

     4、设计模式能降低系统中类与类之间的耦合度。比如工厂模式，使依赖类只需知道被依赖类所实现的接口或继承的抽象类，使依赖类与被依赖类之间的耦合度降低。

     5、设计模式能提高代码的重用度。比如适配器模式，就能将系统中已经存在的符合新需求的功能代码兼容新的需求提出的接口 。

     6、设计模式能为常见的一些问题提供现成的解决方案。

     7、设计模式增加了重用代码的方式。比如装饰器模式，在不使用继承的前提下重用系统中已存在的代码。

目前总结的设计模式有23种使用广泛 ，我们先谈简单工厂模式，光讲定义很难明白的用法 ，我们引用一个案例 ，然大家更好的明白简单设计模式。

案例：假如写一个计算器，你可能很快的写出如下代码：

 1   public  class Operation
 2     {
 3        public    static  double GetResult(double NumberA,double NumberB,string operate)
 4 
 5         {
 6 
 7           double result=0;
 8 
 9           switch(operate){
10 
11             case ''+":
12 
13              result=NumberA+NumberB;
14 
15             break;
16 
17             .......  //减法、 乘法、除法省略
18 
19           }   
20 
21           return  result;
22 
23         }  
24 
25    }

   界面实现代码 省略；

写完这个运算类 我们可以复用此方法 ，可以在web版，手机等 写计算器，但是如果我希望计算器在加一个求平方根的功能，我们只需要在switch里加个语句，似乎很简单，但是你加个语句 却要让加减乘除一起编译一遍 ，所以我们需要对上面进行修改,将每个方法分离，于是我们来用简单工厂模式(SimpleFactory)。

运算类:

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

工厂类：

 1 namespace SimpleFactory
 2 {
 3     public class OperationFactory
 4     {
 5         public static Operation CreateOperate(string operate) {
 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                     oper = new OperationMulti();
17                     break;
18                 case "/":
19                     oper = new OperationDiv();
20                     break;
21                 default:
22                     break;
23             }
24             return oper;
25         }
26     }
27 }

现在，我们只需要输入运算符，实例出相应的类就能实现计算器的结果：

        

     Operation oper = new Operation();
     oper = OperationFactory.CreateOperate("+"); 
     oper.NumberA = 1;
     oper.NumberB = 2;

     double result=oper.GetResult();

如果我们需要加入什么新运算，只需要添加子类就可以了，加分支和改界面都和运算类没关系了！

简单工厂模式的类图：

作者：X-Space
出处：http://www.cnblogs.com/xspaceworld/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。