简单工厂设计模式

                                                                                           简单工厂设计模式

 刚开始学设计模式,犹如刚睁开眼看世界的孩子,满眼都是惊奇,原来代码的世界可以如此的精彩纷呈.当然这些都是前辈智慧的结晶.简单工厂设计模式是接触的第一个设计模式,看完后更多的是不懂和迷糊.不过相信慢慢会懂得其精髓的.

       简单工厂设计模式是创建型(就是把对象的创建和使用分离)模型,又叫静态工厂方法(StaticFactoryMethod)模式.但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简言之简单工厂模式的本质就是选择实现,重点在于选择,因为实现类已经写好了.其目的在于为客户端来选择相应的实现，从而使得客户端和实现之间降低耦合，这样一来，具体实现发生了变化，就不用变动客户端了，这个变化会被简单工厂模式屏蔽掉.

       也因此当我们想要完全封装隔离具体实现，让外部只能通过接口来操作封装体，那么可以选用简单工厂，让客户端通过工厂来获取相应的接口，而无需关心具体实现.如图我们如果想实现一个简单的计算器.

 

 代码如下

 //首先定义运算类        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 OperationPlus : Operation
            {
                public override double GetResult() //重写基类的方法
                {
                    double result = 0;
                    result = NumberA + NumberB;
                    return result;
                }
            }
        //定义减法类,继承了运算类
            class OperationMinus : 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("除数不能为零");
                    result = NumberA / NumberB;
                    return result;
                }
            }



        
        //创建工厂
        public class OperationFactory
        {
            public static Operation createOperate(string operate)
            {
                Operation oper = null;
                switch (operate)
                {
                    case "+":
                        oper = new OperationPlus();
                        break;
                    case "-":
                        oper = new OperationMinus();
                        break;
                    case "*":
                        oper = new OperationMul();
                        break ;
                    case "/":
                        oper = new OperationDiv();
                        break;

                }
                return oper;
            }
        }
         
    //工厂对类实例化的代码范例如下
 static void Main(string[] args)
        {
           
            Operation oper;
            Console.WriteLine("请输入A");
            oper.NumberA =Convert.ToDouble( Console.ReadLine());

            oper = OperationFactory.createOperate("+");
            
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.WriteLine(Convert.ToString(result));
        }

简单工厂虽然很简单，但是非常友好的帮助我们实现了组件的封装，然后让组件外部能真正面向接口编程。通过简单工厂，实现了客户端和具体实现类的分离。如同上面的例子，客户端根本就不知道具体是由谁来实现，也不知道具体是如何实现的，客户端只是通过工厂获取它需要的接口对象。

         简单工厂模式优点是有很多可是简单工厂模式也并不完美,也有很多的缺点,如果通过客户端的参数来选择具体的实现类，那么就必须让客户端能理解各个参数所代表的具体功能和含义，这会增加客户端使用的难度，也部分暴露了内部实现.并且不方便扩展子工厂.

  

总结

 （1）简单工厂模式是专门定义一个类来创建其他类的实例，被创建的实例通常都有公共的父类。

 （2）简单工厂模式又称为静态工厂方法，属于类的创建型模式，通常他根据自变量的不同返回不同类的实例。

 （3）实质：由一个工厂类根据传入的变量，动态的决定创建出哪一个产品类的实例。