简单工厂模式

定义:

　　简单工厂模式（Simple Factory Pattern）:通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

类图：

简单工厂模式中包含的角色及其相应的职责如下：

工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。

抽象产品角色（Product）：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。

具体产品角色（Concrete Product）：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

例子：计算器实现基本运算(加,减,乘,除)

后台代码：

  1     /// <summary>
  2     /// 运算操作类
  3     /// </summary>
  4     public abstract class Operation
  5     {
  6         /// <summary>
  7         /// 运算数
  8         /// </summary>
  9         private double _numberA = 0;
 10 
 11         public double NumberA
 12         {
 13             get { return _numberA; }
 14             set { _numberA = value; }
 15         }
 16 
 17         private double _numberB = 0;
 18 
 19         public double NumberB
 20         {
 21             get { return _numberB; }
 22             set { _numberB = value; }
 23         }
 24 
 25         /// <summary>
 26         /// 运算结果
 27         /// </summary>
 28         private double _result = 0;
 29 
 30         public double Result
 31         {
 32             get { return _result; }
 33             set { _result = value; }
 34         }
 35 
 36         /// <summary>
 37         /// 运算方法
 38         /// </summary>
 39         public abstract void GetResult();
 40     }
 41 
 42     /// <summary>
 43     /// 加法类
 44     /// </summary>
 45     public class OperationAdd : Operation
 46     {
 47         public override void GetResult()
 48         {
 49             Result = NumberA + NumberB;
 50         }
 51     }
 52 
 53     /// <summary>
 54     /// 减法类
 55     /// </summary>
 56     public class OperationSub : Operation
 57     {
 58         public override void GetResult()
 59         {
 60             Result = NumberA - NumberB;
 61         }
 62     }
 63 
 64     /// <summary>
 65     /// 乘法类
 66     /// </summary>
 67     public class OperationMul : Operation
 68     {
 69         public override void GetResult()
 70         {
 71             Result = NumberA * NumberB;
 72         }
 73     }
 74 
 75     /// <summary>
 76     /// 除法类
 77     /// </summary>
 78     public class OperationDiv : Operation
 79     {
 80         public override void GetResult()
 81         {
 82             if (NumberB == 0)
 83             {
 84                 throw new Exception("除数不能为0");
 85             }
 86             Result = NumberA / NumberB;
 87         }
 88     }
 89 
 90     /// <summary>
 91     /// 简单工厂类
 92     /// </summary>
 93     public class OperationFactory
 94     {
 95         public static Operation createOperation(string operation)
 96         {
 97             Operation oper = null;
 98             switch(operation)
 99             {
100                 case "+":
101                     oper = new OperationAdd();
102                     break;
103                 case "-":
104                     oper = new OperationSub();
105                     break;
106                 case "*":
107                     oper = new OperationMul();
108                     break;
109                 case"/":
110                     oper = new OperationDiv();
111                     break;
112                 default:
113                     break;
114             }
115             return oper;
116         }
117     }

View Code

客户端代码

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //调用工厂方法实例化具体操作类
 6             Operation oper = OperationFactory.createOperation("+");
 7             oper.NumberA = 1;
 8             oper.NumberB = 2;
 9 
10             //调用子类的操作方法
11             oper.GetResult();
12             Console.WriteLine(oper.Result);
13 
14             Console.Read();
15         }
16     }

View Code

应用场景：
网上一个广为流传的例子：

GG请自己的女朋友和众多美女吃饭，但是GG自己是不会做饭的或者做的饭很不好，这说明GG不用自己去创建各种食物的对象；各个美女都有各自的爱好，到麦当劳后她们喜欢吃什么直接去点就行了，麦当劳就是生产各种食物的工厂，这时候GG不用自己动手，也可以请这么多美女吃饭，所要做的就是买单O(∩_∩)O哈哈~。

简单工厂模式的优缺点分析：

优点：工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

缺点：由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连；而且由于简单工厂模式的产品室基于一个共同的抽象类或者接口，这样一来，但产品的种类增加的时候，即有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种种类的产品，这就和创建何种种类产品的产品相互混淆在了一起，违背了单一职责，导致系统丧失灵活性和可维护性。而且更重要的是，简单工厂模式违背了“开放封闭原则”，就是违背了“系统对扩展开放，对修改关闭”的原则，因为当我新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。

总结一下：简单工厂模式分离产品的创建者和消费者，有利于软件系统结构的优化；但是由于一切逻辑都集中在一个工厂类中，导致了没有很高的内聚性，同时也违背了“开放封闭原则”。另外，简单工厂模式的方法一般都是静态的，而静态工厂方法是无法让子类继承的，因此，简单工厂模式无法形成基于基类的继承树结构。