简单工厂模式——设计模式（一）

简单工厂模式解释：

简单工厂模式，又叫静态工厂方法模式，是通过专门定义一个类来创建其他类的实例，被创建的实例通常具有共同的父类。

简单工厂模式的UML图：

简单工厂模式包含以下的角色：

工厂角色：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。

抽象产品角色：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。

具体产品角色：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

简单工厂模式深入分析：

       简单工厂模式解决的问题是如何去实例化一个合适的对象。

       简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。

       具体来说，把产品看着是一系列的类的集合，这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。

       如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑，那么我们就可以使用接口来扮演抽象产品的角色；如果具体产品之间有功能的逻辑或，我们就必须把这些共同的东西提取出来，放在一个抽象类中，然后让具体产品继承抽象类。为实现更好复用的目的，共同的东西总是应该抽象出来的。

结合具体代码

class Program
    {
        static void Main(string[] args)
        {
            try {
                Operation oper;
                oper = OperationFactory.createOperate("+");               //实例化对象
                oper.NumberA = 1;         //赋值
                oper.NumberB = 2;
                double result = oper.GetResult();                  
                Console.WriteLine(result);             //显示运算结果
            }
            catch (Exception ex)
            {
                Console.WriteLine("您的输入有误：" + ex.Message);
            }
        }
        //简单工厂通过参数实例化对象
        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;
            }
        }
        //运算父类
        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;
            }
        }
        
    }

<span style="font-family: Arial; background-color: rgb(255, 255, 255);">	</span><span style="font-family: Arial; background-color: rgb(255, 255, 255);">其实对于本题的简单工厂来说，它虽然在一定程度上优化了程序的可扩展性，但是并不能解决在添加运算（如：开根）时对于运算类的修改，但是由于应用简单工厂模式后，在扩展运算时，只要增加相应的子类（对于运算工厂类的子类），并仅仅修改工厂类的switch语句即可完成。在一定程度上避免了直接修改运算类的而引起的错误风险。（运算类为《大话设计模式》小菜将业务逻辑和界面逻辑分开后的运算类）</span>