读书笔记系列2：大话设计模式 -- 工厂方法模式

工厂方法模式

工厂方法模式，定义一个创建对象的接口，让子类决定实例化哪个类。工厂方法模式使一个类的实例化延续到其子类。

示例：简单的计算器，实现加、减、乘、除。

大家可能首先想到的场景是：定义个Operation类，包含Add(加)、Sub(减)、Mul(乘)、Div(除)四个方法，在客户端通过switch判断来决定调用哪个方法。

这样可以达到功能的实现。

这时有个新的需求，新增一个取余的功能。这时的做法是，在上面定义的Operation类中添加个Mod（取余）方法，然后在客户端的switch中加个case条件。这么做当然可以，但是有没有更好的方法呢？

面向对象的编程需要我们要遵守开放-关闭原则，即对扩展开放，对修改关闭。上面的做法显然违背了对修改关闭原则，也不利于扩展。对已有类的修改可能会导致现有系统的不稳定。这种方法不可取。

设计模式作为一类常见的问题的解决方案，它的出现必然是为了解决一类问题。

针对上面的案例，我们引入工厂方法这一设计模式，来看看它给我们带来了哪些改变。

面向对象编程提倡面向抽象编程。注意抽象的概念。

加、减、乘、除都是具体的操作，所以他们可以抽象出个Operation类，然后分别继承它。

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; }
        }

        /// <summary>
        /// 得到运算结果
        /// </summary>
        /// <returns></returns>
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
}

/// <summary>
    /// 加法类
    ///</summary>
    classOperationAdd : Operation
    {
        publicoverride double GetResult()
        {
           double result = 0;
           result = NumberA + NumberB;
           return result;
        }
    }

    ///<summary>
    /// 减法类
    ///</summary>
    classOperationSub : Operation
    {
        publicoverride double GetResult()
        {
           double result = 0;
           result = NumberA - NumberB;
           return result;
        }
    }

    ///<summary>
    /// 乘法类
    ///</summary>
    classOperationMul : Operation
    {
        publicoverride double GetResult()
        {
           double result = 0;
           result = NumberA * NumberB;
           return result;
        }
    }

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

定义一个工厂的接口

    ///<summary>

    /// 工厂方法

    ///</summary>

    interfaceIFactory

    {
        Operation CreateOperation();
    }

接下来分别定义加、减、乘、除四个工厂，让他们实现接口

/// <summary>
    /// 专门负责生产“+”的工厂
    ///</summary>
    classAddFactory : IFactory
    {
        publicOperation CreateOperation()
        {
           return new OperationAdd();
        }
    }
 
    ///<summary>
    /// 专门负责生产“-”的工厂
    ///</summary>
    classSubFactory : IFactory
    {
        publicOperation CreateOperation()
        {
           return new OperationSub();
        }
    }

    ///<summary>
    /// 专门负责生产“*”的工厂
    /// </summary>
    classMulFactory : IFactory
    {
        publicOperation CreateOperation()
        {
           return new OperationMul();
        }
    }

    ///<summary>
    /// 专门负责生产“/”的工厂
    ///</summary>
    classDivFactory : IFactory
    {
        publicOperation CreateOperation()
        {
           return new OperationDiv();
        }
    }

那么客户端怎么调用呢？

既然是工厂方法，那就是负责生产的。这就好比分别生产鞋子，裤子等工厂，我实例化哪个，哪个工厂就给我相应的产品。

面向对象有个原则是里氏代换原则，什么意思呢？就是只要是任何基类可以出现的地方，子类一定可以出现。举个例子：

AddFactory add = new AddFactory();

可以改为 ：

IFactory add = new AddFactory();

而没有任何问题。但是好处是，凡是实现单独IFactory接口的类都可以保留句柄而只改变实例对象，他们的方法调用不用任何改变。

IFactory operFactory = new AddFactory();
 Operation oper= operFactory.CreateOperation();
 oper.NumberA =1;
 oper.NumberB =2;
 doubleresult=oper.GetResult();
 Console.WriteLine(result);

上面的代码中，我把IFactory operFactory = new AddFactory();

 改为IFactory operFactory = new SubFactory();即可实现减法的功能，而其他代码无需修改。

到这里是不是看到这个模式的优势了。还不止这些呢。如果我们想增加个新功能：取余，就容易多了。

只要单独增加实体类

/// <summary>
    /// 取余
    ///</summary>
    classOperationMod : Operation
    {
        publicoverride double GetResult()
        {
           double result = 0;
           result = NumberA % NumberB;
           return result;
        }
    }

再增加个取余工厂方法

class ModFactory : IFactory
    {
        publicOperation CreateOperation()
        {
           return new OperationMod();
        }
    }

在客户端只要修改IFactory operFactory = new ModFactory ();即可，其他代码不用修改。是不是感觉很豁然开朗：）