简单工厂模式

原文地址：http://www.cnblogs.com/xiaocen/p/3726763.html

在学习简单工厂模式之前让我们先看看不用简单工厂模式所带来的不便把，我们以一个四则运算的计算器为例逐步的进行说明问题，首先先看看用面向程序的思想实现计算器的过程

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 简单工厂模式
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.Write("请输入数字A");
                string strNumber1 = Console.ReadLine();
                Console.Write("请输入数字B");
                string strNumber2 = Console.ReadLine();
                Console.Write("请输入符号（+、-、*、/）");
                string strOperate = Console.ReadLine();
                string result = "";
                switch (strOperate)
                {
                    case "+":
                        result = Convert.ToString(Convert.ToInt32(strNumber1) + Convert.ToInt32(strNumber2));
                        break;
                    case "-":
                        result = Convert.ToString(Convert.ToInt32(strNumber1) - Convert.ToInt32(strNumber2));
                        break;
                    case "*":
                        result = Convert.ToString(Convert.ToInt32(strNumber1) * Convert.ToInt32(strNumber2));
                        break;
                    case "/":
                        if (strNumber2 != "0")
                        {
                            result = Convert.ToString(Convert.ToInt32(strNumber1) / Convert.ToInt32(strNumber2));
                        }
                        else
                        {
                            result = "除数不能为零";
                        }
                        break;
                }
                Console.WriteLine("计算结果是：{0}", result);
                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.ReadKey();
            }
        }
    }
}

虽然上面的代码可以实现四则运算但他确是面向程序实现的，这就意味着这种代码不具有易维护，易扩展，易复用，灵活性强的特点

所以我们现在就要将客户端代码和运算类代码分开，降低程序的耦合度，使得程序修改一处的时候不影响另一处

如下代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 简单工厂模式进阶
{
    //利用面向对象的思想将显示与计算分开
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("请输入数字A");
            string strNumber1 = Console.ReadLine();
            Console.Write("请输入数字B");
            string strNumber2 = Console.ReadLine();
            Console.Write("请输入符号（+、-、*、/）");
            string strOperate = Console.ReadLine();
            string strresult="0";
            Operate oprat = new Operate();
            oprat.number1 = Convert.ToDouble(strNumber1);
            oprat.number2 = Convert.ToDouble(strNumber2);
            oprat.result = Convert.ToDouble(strresult);
            oprat.oprate = strOperate;
            string Result = "";
            Result = Convert.ToString(oprat.GetResult());
            Console.WriteLine(Result);
            Console.ReadKey();
            

        }
    }
    public class Operate
    {
        public double number1, number2, result;
        public string oprate;
        public double GetResult()
        {
            switch (oprate)
            {
                case "+":
                    result = number1 + number2;
                    break;
                case "-":
                    result = number1 - number2;
                    break;
                case "*":
                    result = number2 * number1;
                    break;
                case "/":
                    if (number2 != 0)
                    {
                        result = number1 / number2;
                    }
                    else
                    {
                        Console.WriteLine("除数不能为零");
                       
                       
                    }
                    break;
            }
            return result;
        }
    }
}

虽然这样确实好了很多，但还是存在很大不足，加入你要加入一个运算类型那就必须进入这个类，如果不小心将其中的一个运算改了，那麻烦可就大了（尤其和金钱有关的系统）

所以我们就要想办法让程序对扩展开放，对修改关闭——开放封闭原则

在这里我们就要引入多态的概念，就是子类继承父类的属性和方法，并以不同的方式实现，用父类实例化子类，并用父类调用子类中的方法和属性进行计算（自己的理解）

下面这段代码就引进多态的概念同时也是我们今天的主题——简单工厂模式，让大家深切的感受一下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 简单工厂模式示例
{
    class Program
    {
        static void Main(string[] args)
        {
            opration oper;
            oper = OperationFactory.createopration("*");
            oper.NumberA = 1;
            oper.NumberB = 6;
            string result= Convert.ToString(oper.GetResult());
            Console.WriteLine(result);
            Console.ReadKey();

        }
    }
     public class opration
    {
        private double Number1 = 0;
        private double Number2 = 0;
        public double NumberA
        {
            get { return Number1; }
            set { Number1 = value; }
        }
        public double NumberB
        {
            get { return Number2; }
            set { Number2 = value; }
        }
        public virtual double GetResult()
        {
            double result=0;
            return result;
        }
    }
    class Add : opration
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
            
        }
    }
    class Sub : opration
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class Mul : opration
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class Div : opration
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
            {
                throw new Exception("除数不能为零");   
            }
            result = NumberA / NumberB;
            return result;
        }
    }
    //类的默认访问级别是internal（只能在同一个命名空间下访问）
     class OperationFactory
    {
         public static opration createopration(string op)
        {
            opration opra=null;
            switch (op)
            {
                case "+":
                    opra = new Add();
                    break;
                case "-":
                    opra = new Sub();
                    break;
                case "*":
                    opra = new Mul();
                    break;
                case "/":
                    opra = new Div();
                    break;
            }
            return opra;
        }
    }

}

所谓简单工厂就是将运算类与前台程序的交互封装起来，用户只需输入所要进行计算的符号，工厂就会自动帮助用户选择要使用哪个运算类进行计算