设计模式之简单工厂模式

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

该模式中包含的角色及其职责：

工厂（Creator）角色

   简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

抽象产品（Product）角色

  简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品（Concrete Product）角色

    是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

简单工厂模式是用一个单独的类来创造实例化的过程。只是解决了对象的创建问题。

用书上的例子编辑一个计算器解释下：

 //创建运算类operation，定义double型变量。
      public 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;
        }  
    }

//简单工厂运算类。根据需要“生产”出运算符。就像工厂一样，简单工厂模式是根据客户端不同的“要求”，
    //产生不同的具体对象，再利用多态特性调用相应具体对象的方法。
    public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationADD();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;

            }
            return oper;
        }
    }

在客户端输出。

class Program
    {
        static void Main(string[] args)
        {
            //客户端代码。输入+号就实例出加法运算类。
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
        }
    }

这样就实现计算器了。好处是根据需要，工厂实例化出合适的对象，通过多态，返回父类的方式实现计算器。松耦合，这样就在之后的维护或者更新中不会大动代码。