设计模式之二(简单工厂模式)

前言

　　简单工厂模式根据提供的数据或者参数返回几个可能的类中的一个实例，说通俗点有点像面向对象编程中的多态性，一个基类，有多个派生类，在另外的调用程序中，根据参数来决定返回这个基类的哪个具体的派生类，返回值为基类类型，因为基类的引用可以指向派生类对象，而且这些所有的派生类都包含有基类的函数，也就是说派生类中有相同的函数，但是函数的实现可能不同。

下面我只是来演示一下简单工厂模式，代码不会太复杂。所以大家可以使用Submile Text工具。

使用方法博客文章链接http://www.cnblogs.com/aehyok/archive/2013/05/05/3059087.html可直接编译运行查看效果哦。

简单工厂模式

  
　　假定A是一个基类，AB和AC都是派生于A的派生类，XFactory类中根据提供给它的参数来决定返回AB或者AC 类的哪一个，返回的是哪个类的实例对于编程者来说并不是那么重要，因为这些类有着相同的方法，编程者需要做的就是通过基类引用直接调用方法，不用去关心到底返回的是哪个派生类，因为这些类有相同的方法，只是实现不同而已。如何决定返回哪一个派生类，取决于工厂的设计，该方法可以是非常复杂的函数，也可以是简单的函数。

接下来我们就通过简单加减乘除的计算器来了解和实现简单工厂模式。

第一步：根据上面的小例子首先我来创建一个基类A

    ///Operation运算类
    public class Operation
    {
        public double NumberA { get; set; }

        public double NumberB { get; set; }

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

第二步：然后创建派生类AB AC即加、减、乘、除四个派生类。

    ///加减乘除类
    ///加法类
    public class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = this.NumberA + this.NumberB;
            return result;
        }
    }
    ///减法类
    public class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = this.NumberA - this.NumberB;
            return result;
        }
    }

    /// <summary>
    /// 乘法类
    /// </summary>
    public class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = this.NumberA * this.NumberB;
            return result;
        }
    }

    /// <summary>
    /// 除法类
    /// </summary>
    public class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (this.NumberB == 0)
            {
                throw new Exception("除数不能为0。");
            }
            result = this.NumberA / this.NumberB;
            return result;
        }
    }

第三步：创建XFactory来返回AB、AC。

    ///简单工厂类
    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;
        }
    }

第四步：先来一个加法的调用：

        static void Main(string[] args)
        {
            Operation Oper = OperationFactory.CreateOperate("+");
            Console.WriteLine("请输入第一个数字A：");
            Oper.NumberA =Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入第二个数字B:");
            Oper.NumberB = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("结果为：{0}",Oper.GetResult());
            Console.ReadLine();
        }

运行结果为

总结

 在此简单工厂模式，其实使用了面向对象中的几点编程思想。

创建Operation其实是对业务的封装。

然后实现加减乘除类都继承Operation并重写各自应有的业务逻辑。

我们如果再加一个算法开根（sqrt）算法，那么只需要新增加一个继承Operation的类，然后在简单工厂类中添加一个分支即可。这里我们发现这是易扩展(松耦合)、易维护。