简单工厂和工厂模式

工厂模式】：

     定义一个用于创建对象的接口， 让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

适用性
当一个类不知道它所必须创建的对象的类的时候。
当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

以简单计算器为例：

【简单工厂实现】：

using System;

//【简单工厂类】

class OperationFactory

{

  public static Operation CreateOperation(string operate)

  {

Operation oper=null;//保存Operation类的一个引用。

//让子类决定实例化哪一个类

switch(operate)

{

  case "+":

  oper=new OperationAdd();

      break;

  case "-":

  oper=new OperationSub();

      break;

  case "*":

  oper=new OperationMul();
      break;

  case "/":

  oper=new OperationDiv();
      break;

}

return oper;

  }

}

//【运算类】

abstract class Operation 

{

  public int NumberA;

  public int NumberB;

  public abstract void GetResult();

}

class OperationAdd:Operation

{

   public override void GetResult()

   {

     Console.WriteLine("计算加法时结果为："+(NumberA+NumberB));

   }

}

class OperationSub:Operation

{

   public override void GetResult()

   {

     Console.WriteLine("计算减法时结果为："+(NumberA-NumberB));

   }

}

class OperationMul:Operation

{

   public override void GetResult()

   {

     Console.WriteLine("计算乘法时结果为："+(NumberA*NumberB));

   }

}

class OperationDiv:Operation

{

   public override void GetResult()

   {

     Console.WriteLine("计算除法时结果为："+(NumberA/NumberB));

   }

}

//【客户端代码】

class App

{

  static void Main()

  {

    Operation oper;

oper=OperationFactory.CreateOperation("+");

oper.NumberA=1;

oper.NumberB=2;

oper.GetResult();

  }

}

工厂模式实现

【工厂模式】：

using System;

//【运算类】

abstract class Operation //运算基类；

{

  public int NumberA;

  public int NumberB;

  public abstract void GetResult();

}

class OperationAdd:Operation //加法；

{

   public override void GetResult()

   {

     Console.WriteLine("计算加法时结果为："+(NumberA+NumberB));

   }

}

class OperationSub:Operation //减法；

{

   public override void GetResult()

   {

     Console.WriteLine("计算减法时结果为："+(NumberA-NumberB));

   }

}

class OperationMul:Operation  //乘法；

{

   public override void GetResult()

   {

     Console.WriteLine("计算乘法时结果为："+(NumberA*NumberB));

   }

}

class OperationDiv:Operation  //除法；

{

   public override void GetResult()

   {

     Console.WriteLine("计算除法时结果为："+(NumberA/NumberB));

   }

}

//【Factory接口】

interface IFactory

{

  Operation CreateOperaion();

}

//【工厂类】

class AddFactory:IFactory//加法工厂类

{

  public Operation CreateOperaion()

  {

    return new OperationAdd();

  }

}

class SubFactory:IFactory//减法工厂类

{

  public Operation CreateOperaion()

  {

    return new OperationSub();

  }

}

class MulFactory:IFactory//乘法工厂类

{

  public Operation CreateOperaion()

  {

    return new OperationMul();

  }

}

class DivFactory:IFactory//除法工厂类

{

  public Operation CreateOperaion()

  {

    return new OperationDiv();

  }

}

//【客户端代码】

class App

{

  static void Main()

  {

    //真正体现对接口编程

    IFactory operFactory=new AddFactory();//实例化一个加法工厂；

    Operation oper=operFactory.CreateOperaion();

    oper.NumberA=1;

    oper.NumberB=2;

    oper.GetResult();

  }

}

      简单工厂模式的最大优点在于：工厂类中包含了必要的判断逻辑，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，现在只改客户端了。

工厂方法模式克服了简单工厂模式违背开放-封闭原则，又保持了封装对象创建过程的优点。工厂方法模式是简单工厂模式的进一步抽象和推广。