工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

      工厂方法模式是的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开-闭原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

      工厂方法模式的对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不在负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

      工厂方法模式(Factory Method pattern)是最典型的模板方法模式(Templete Method pattern)应用。

      工厂方法的UML图如下：

　　　　　　　　　　　　　　图1---工厂方法模式

工厂方法模式角色与结构

　　抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。 

　　具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。 

　　抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。 

　　具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

工厂方法模式的应用

      工厂方法经常用在以下两种情况中: 

　　第一种情况是对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。 

　　第二种情况，只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。

 

为了对比前面的简单工厂模式，下面用工厂方法模式实现前面工厂模式实现的计算器：

FactoryMethod.cs代码如下：

using System; using System.Collections.Generic; using System.Text; namespace 工厂方法_计算器 {
   /// 
 /// 运算类 /// 
     class Operation     {
   private double _numberA = 0; private double _numberB = 0; public double NumberA         {
   get { return _numberA; } set { _numberA = value; }         } public double NumberB         {
   get { return _numberB; } set { _numberB = value; }         } /// 
 /// 得到运算结果 /// 
 /// 
              public virtual double GetResult()         {
   double result = 0; return result;         }     } /// 
 /// 加法类 /// 
     class OperationAdd : Operation     {
   public override double GetResult()         {
   double result = 0;             result = NumberA + NumberB; return result;         }     } /// 
 /// 减法类 /// 
     class OperationSub : Operation     {
   public override double GetResult()         {
   double result = 0;             result = NumberA - NumberB; return result;         }     } /// 
 /// 乘法类 /// 
     class OperationMul : Operation     {
   public override double GetResult()         {
   double result = 0;             result = NumberA * NumberB; return result;         }     } /// 
 /// 除法类 /// 
     class OperationDiv : Operation     {
   public override double GetResult()         {
   double result = 0; if (NumberB == 0) throw new Exception("除数不能为0。");             result = NumberA / NumberB; return result;         }     } /// 
 /// 工厂方法 /// 
     interface IFactory     {
           Operation CreateOperation();     } /// 
 /// 专门负责生产“+”的工厂 /// 
     class AddFactory : IFactory     {
   public Operation CreateOperation()         {
   return new OperationAdd();         }     } /// 
 /// 专门负责生产“-”的工厂 /// 
     class SubFactory : IFactory     {
   public Operation CreateOperation()         {
   return new OperationSub();         }     } /// 
 /// 专门负责生产“*”的工厂 /// 
     class MulFactory : IFactory     {
   public Operation CreateOperation()         {
   return new OperationMul();         }     } /// 
 /// 专门负责生产“/”的工厂 /// 
     class DivFactory : IFactory     {
   public Operation CreateOperation()         {
   return new OperationDiv();         }     } }

Program.cs的代码如下：

using System; using System.Collections.Generic; using System.Text; namespace 工厂方法_计算器 {
   class Program     {
   static void Main(string[] args)         {
               IFactory operFactory = new AddFactory();             Operation oper = operFactory.CreateOperation();             oper.NumberA = 1;             oper.NumberB = 2; double result=oper.GetResult();             Console.WriteLine(result);             Console.Read();         }     } }

 模式总结

　1 优点：

　　　　工厂方法去除了条件分支（解除了工厂类与分支的耦合），解决了简单工厂对修改开放的问题。

　2 缺点：

　　　　工厂方法模式实现时，客户端需要决定实例化哪个工厂来实现对具体产品的构建，选择判断依然存在，也就是说，工厂方法模式将简单工厂的逻辑判断交给客户端去处理。

　　　　对简单工厂模式来说，增加功能是要修改工厂类的；但对工厂方法模式，修改的是客户端。

　3 使用场景：

　　　　对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。

　　　　子类的数量不固定，随时可能有新的功能子类出现。