工厂方法模式

　　对于上一篇中的简单工厂模式，它利用一个【工厂类】来有选择型的实例化指定的对象（要利用加法类时，传入参数“加法”以后工厂类就会去实例化OperateAdd类，并返回该实例），而对于工厂方法模式来讲，他为每一个操做类都建立一个工厂类，调用工厂类再来实例化指定对象！

首先来建立一个接口，来统一各个工厂类的行为
interface IFactory
{
　　Operation CreateOperation(); //返回值类型为全部操做类的父类
}

public AddFactory:IFactory
{
　　public Operation CreateOperation()
　　{
　　　　return new OperationAdd();
　　}
}

AddFactory-加法工厂类

public SubFactory:IFactory
{
　　public Operation CreateOperation()
　　{
　　　　return new OperationSub();
　　}
}

SubFactory-减法工厂类

public MulFactory:IFactory
{
　　public Operation CreateOperation()
　　{
　　　　return new OperationMul();
　　}
}

MulFactory-乘法工厂类

　　上述这些工厂类都返回给自对应的操做类的实例，当想要利用加法操做时，只须要调用工厂类中的CreateOperation方法便可，那么对于到底该调用那个工厂类的逻辑判断，就须要本身来写了，这一点工厂方法模式和简单工厂模式是不一样的！

　　//定义一个父类，来统一计算操做。
　　public class Operate
    {
        private int _numberA;
        private int _numberB;

        public int numberA
        {
            set { _numberA = value; }
            get { return _numberA; }
        }
        public int numberB
        {
            set { _numberB = value; }
            get { return _numberB; }
        }
　　　　 //其实能够将此类设置为抽象类，此方法设置为抽象方法，由于具体的实现都是在其派生类中进行的！
        public virtual int ObtainResult()
        {return 0;
        }
    }
　　//加法类
    public class OperationAdd:Operate
    {
        public override int ObtainResult()
        {
            return base.numberA + base.numberB;
        }
    }
　　//减法类
    public class OperationSub : Operate
    {
        public override int ObtainResult()
        {
            return base.numberA - base.numberB;
        }
    }

操做类

 

　　1.看起来工厂方法模式对于简单工厂模式来讲也米有优点，算是反倒麻烦了，由于对到底应该调用那一个工厂类的逻辑判断抛了出来，须要在客户端代码中本身来作断定。

　　2.工厂方法模式遵循了 开放-封闭原则，对于工厂方法模式来讲，若是要对其进行扩展（添加除法操做），须要添加了一个继承自Operate类的除法操做类，再添加一个实现IFactory接口的除法工厂类便可，而若是对简单工厂模式进行扩展的话，不只须要增长操做类，还须要去对工厂类进行逻辑的修改，这么一来就违背了开放-封闭原则。其实，二者本质的差异是由于在工厂方法模式中判断到底调用那一个工厂类的操做抛给了客户端代码来实现，因此在组件的范围内就不须要修改，只扩展便可。