简单工厂模式和工厂模式

    在对比两种模式之前，首先需要学习  开放-封闭原则。在以前学习的过程中，听说过很多次，编写程序要遵循开闭原则。

    在做项目的过程中，因为需求的添加，经常会更新软件。更新软件，就要设计到修改代码了。在面向对象的程序设计中，经常会写类。如果因为添加需求，去修改已经完成的类。那么他是不符合开闭原则的。

    添加需求，应该让代码去扩展，而不是去修改。通过抽象类和继承来实现开闭原则。

    开闭原则：对于扩展是开放的，对于更改是封闭的。

    使用开闭原则，可以给面向对象的程序设计带来巨大的好处，使得代码可维护、可扩展、可复用、灵活性好。

 

首先来看一下简单工厂模式：

实现的代码：

public class Operation               //定义操作类
    {
        private double num1 = 0;
        private double num2 = 0;
        public double NumberA                //第一个操作数
        {
            get { return num1; }
            set { num1 = value;}
        }
        public double NumberB                   //第二个操作数
        {
            get { return num2; }
            set { num2 = value; }
        }
        public virtual double GetResult()             //返回执行结果
        {
            double result = 0;
            return result;
        }
    }
    public class OperationAdd : Operation            //加法类，继承操作类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    public class OperationSub : Operation               //减法类，继承操作类
    {
        public override double GetResult()
        {
            double result;
            result = NumberA - NumberB;
            return result;
        }
    }
    public class OperationMul : Operation               //乘法类，继承操作类
    {
        public override double GetResult()
        {
            double result;
            result = NumberA * NumberB;
            return result;
        }
    }
    public class OperationDiv : Operation               //除法类，继承操作类
    {
        public override double GetResult()
        {
            double result;
            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;
        }
    }

 

    通过上面的例子，你会发现，在简单工厂模式中，如果要增加需求，必须修改的类有OperationFactory，每次增加需求都需要修改工厂，这样是既对扩展开放，又对修改也开放了。这就就违背了 开-闭 原则。

    在简单工厂里面，不需要管改用哪个类的实例，只需要把'+'给工厂，工厂自动就给出了相应的实力。客户端只需要去做运算就可以了。根据不同的实例去实现不同的运算，扩展需要修改工厂中的case语句。所以违背了开闭原则。

    对于工厂模式，根据不同的实例，来对应不同的工厂。对修改进行封闭。如果需要扩展，只需要增加相应的工厂类即可。这样就不需要修改原有的工厂了。

 

在来看一下工厂模式：

实现的代码：

class Program
    {
        static void Main(string[] args)
        {

        }
    }

    public class Operation              //定义操作类
    {
        private double num1 = 0;
        private double num2 = 0;
        public double NumberA           //第一个操作数
        {
            get { return num1; }
            set { num1 = value; }
        }
        public double NumberB            //第二个操作数
        {
            get { return num2; }
            set { num2 = value; }
        }
        public virtual double GetResult()            //得到执行结果
        {
            double result = 0;
            return result;
        }
    }
    public class OperationAdd : Operation           //加法类，继承操作类
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    public class OperationSub : Operation           //减法类，继承操作类
    {
        public override double GetResult()
        {
            double result;
            result = NumberA - NumberB;
            return result;
        }
    }
    public class OperationMul : Operation           //乘法类，继承操作类
    {
        public override double GetResult()
        {
            double result;
            result = NumberA * NumberB;
            return result;
        }
    }
    public class OperationDiv : Operation           //除法类，继承操作类
    {
        public override double GetResult()
        {
            double result;
            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();
        }
    }

    对比两种设计模式，工厂模式是在简单工厂模式上稍作改进得到的，更优于简单工厂模式，使得代码可维护、可扩展、可复用、灵活性好。