设计模式——简单工厂模式

转载请注明出处！

简单工厂模式简单说明：用一个单独的类来实现创造实例的过程，这就是工厂。

这里用简单工厂模式设计一个简单的控制台计算器，用户输入数字A和数字B，并输入一个运算符，然后得到计算结果。这里的工厂类作用就是根据运算符创建不同的运算类，而每个运算类就相当于不同产品，互不影响。

简单代码说明如下：

//运算操作的父类，各种操作运算继承此类
    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()
        {
            return 0;
        }
    }

//不同的运算类，可继续扩展
public class OperationAdd : Operation   //加法运算
    {
        public override double GetResult()
        {
            return NumberA + NumberB;
        }
    }

public class OperationSub : Operation  //减法运算
    {
        public override double GetResult()
        {
            return NumberA - NumberB;
        }
    }

public class OperationMul : Operation   //乘法运算
    {
        public override double GetResult()
        {
            return NumberA * NumberB;
        }
    }

public class OperationDiv : Operation   //除法运算
    {
        public override double GetResult()
        {
            if (NumberB == 0)
                Console.WriteLine("除数不能为0！");
            return NumberA / NumberB;
        }
    }

//操作工厂类
    public class OperationFactory
    {
        //输入运算符，来创建不同的实例
        public static Operation CreateOperate(string operate)
        {
            Operation operation = null;
            switch (operate)
            {
                case "+":
                    operation = new OperationAdd();
                    break;
                case "-":
                    operation = new OperationSub();
                    break;
                case "*":
                    operation = new OperationMul();
                    break;
                case "/":
                    operation = new OperationDiv();
                    break;
            }

            return operation;

        }
    }

//控制台代码    
class Program
    {
        static void Main(string[] args)
        {
            Operation oper = null;
            Console.WriteLine("请输入数字A：");
            string numberA = Console.ReadLine();
            int _numA;
            while (!int.TryParse(numberA, out _numA))
            {
                Console.WriteLine("输入的A不是数字，请重新输入数字A：");
                numberA = Console.ReadLine();
            }

            Console.WriteLine("请输入运算符：");
            string operate = Console.ReadLine();

            while (operate != "+" && operate != "-" && operate != "*" && operate != "/")
            {
                Console.WriteLine("输入的运算符不正确，请重新输入运算符：");
                operate = Console.ReadLine();
            }
            oper = OperationFactory.CreateOperate(operate); //用工厂创建实例

            Console.WriteLine("请输入数字B：");
            string numberB = Console.ReadLine();
            int _numB;
            while (!int.TryParse(numberB, out _numB))
            {
                Console.WriteLine("输入的B不是数字，请重新输入数字B：");
                numberB = Console.ReadLine();
            }

            oper.NumberA = _numA;
            oper.NumberB = _numB;

            double result = oper.GetResult();
            Console.WriteLine("结果为：" + result);
            Console.ReadKey();

        }
    }

这是一个简单工厂模式的具体实现，当我们要增加新的运算时，只需要增加新运算的类并且继承Operation类，然后在工厂类OperationFactory中添加新运算的判断即可，而不会影响以前的运算操作。