设计模式之简单工厂，工厂方法模式

Qt暂时断了，项目上暂时不用。这段时间回顾以前写的代码，不忍直视，现在的也好不哪里去，索性看看设计模式吧，就当练内功了~~啦啦。。。废话不说上代码。

C#代码。

设计一个简单的计算器，只实现加减，其他的暂不考虑，

namespace MySimpleFactory
{//运算类
    class MyOperation
    {
       public  MyOperation() { }

        private double dNumberA = 0;
        private double dNumberB = 0;

        public double NumberA
        {
            get 
            { 
                return dNumberA;
            }
            set
            {
                dNumberA = value;
            }
        }

        public double NumberB
        {
            get
            {
                return dNumberB;
            }
            set
            {
                dNumberB = value;
            }
        }

        public virtual double ReturnResult()
        {
            double result = 0;
            return result;
        }

    }
//加法类继承计算类
    class OperationAdd:MyOperation
    {
        public  OperationAdd():base(){}
        public override double ReturnResult()
        {
            double result = 0;
            result = NumberB + NumberA;
            return result;
        }
    }

    class OperationSub:MyOperation
    {
        public OperationSub() : base() { }

        public override double ReturnResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
//简单工厂类
    class OperationFactory
    {
        public static MyOperation creatroperator(string operate)
        {
            MyOperation oper = null;
            switch(operate)
            {
                case "+":
                   oper = new OperationAdd();
                   break;
                case "-":
                   oper = new OperationSub();
                    break;
            }
            return oper;
        }
    }
}

调用：我们无需提供具体的子类类名，只需要提供一个字符串即可得到相应的实例对象 

  private void btnAdd_Click(object sender, EventArgs e)
        {
       //     int isnum = txtIsNull();
        //    if (isnum == 1)
        //    {
       //         return;
       //     }

            oper = OperationFactory.creatroperator("+");
            oper.NumberA =Convert.ToDouble(txtNumberA.Text);
            oper.NumberB = Convert.ToDouble(txtnumberB.Text);
            txtResult.Text =Convert.ToString(oper.ReturnResult());
        }

简单工厂模式：到底要实列化谁，将来会不会增加实列的化对象，应当考虑用一个单独的类来做这个创造实列的过程。

但是缺点也很明显：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建的对象还不少的话，我们要在这个简单工厂类里编写很多个方法，每个方法里都得写很多相应的业务代码，而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高，而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。

既然简单工厂违反开—闭原则，那么肯定有不违反的，于是工厂模式来了，还是直接上代码，嗯，我一贯的原则，看写代码是程序员最直接的学习方式。

namespace MySimpleFactory
{
    class MyOperation
    {
        public MyOperation() { }

        private double dNumberA = 0;
        private double dNumberB = 0;

        public double NumberA
        {
            get
            {
                return dNumberA;
            }
            set
            {
                dNumberA = value;
            }
        }

        public double NumberB
        {
            get
            {
                return dNumberB;
            }
            set
            {
                dNumberB = value;
            }
        }

        public virtual double ReturnResult()
        {
            double result = 0;
            return result;
        }

    }

    class OperationAdd : MyOperation
    {
        public OperationAdd() : base() { }
        public override double ReturnResult()
        {
            double result = 0;
            result = NumberB + NumberA;
            return result;
        }
    }

    class OperationSub : MyOperation
    {
        public OperationSub() : base() { }

        public override double ReturnResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
//上面的都没变，这里做出了改变，写成工厂接口
    interface OperationFactory
    {
         MyOperation creatroperator();
    }
//实践工厂方法接口
    class OperationSubFactory:OperationFactory
    {
        public MyOperation creatroperator()
        {
            return new OperationSub();
        }
    }

    class OperationAddFactory:OperationFactory
    {
        public MyOperation creatroperator()
        {
            return new OperationAdd();
        }
    }    
}

//调用 
  OperationFactory factory = new OperationSubFactory();//如果要改变方法，改这里
            MyOperation opera = factory.creatroperator();
            opera.NumberA = Convert.ToDouble(txtNumberA.Text);
            opera.NumberB = Convert.ToDouble(txtnumberB.Text);
            txtResult.Text = Convert.ToString(opera.ReturnResult());

工厂方法就是简单工厂模式的进一步抽象和推广。由于用了多态性，工厂模式保持了简单工厂的有点，克服了它的缺点。但是由于每增加一个产品，就需要增加一个产品工厂的类，增加了额外的开发量。