设计模式之(工厂方法)

工厂方法模式：

定义以个用于创建对象的接口，让子类决定实例化哪一个具体的类。工厂方法使一个类的实例化延迟到其子类。

UML图：

Creator: 抽象工厂，提供一个创建产品的方法，具体由其子类去实现。

ConcreteCreator:具体工厂，必须继承抽象工厂，实现创建一个具体的产品，此处为ConcreteProduct。

工厂方法相对于简单工厂方法，其核心类抽象工厂不在负责创建具体的产品，而是交由实现此接口的子类去完成，

当需要添加新的产品，比如Aproduct时，只需要添加一个具体的创建Aproduct的工厂ACreator即可，不需要再去修改Creator。

还是以大话设计模式上的计算器例子为例：

基类：抽象运算类，提供一个抽象方法：getResult() 取运算结果。

/// <summary>
    /// 抽象类
    /// </summary>
    public abstract class Operation
    {
        public double OperateA { get; set; }
        public double OperateB { get; set; }

        //抽象方法  派生类必须重写
        public abstract double getResult();
        //虚方法    派生类可以重写
        public virtual double getResultAgain() { return 0; }
    }

　　派生类：创建 + - * / 四个具体类。重写父类getResult()方法，实现具体运算。

/// <summary>
    /// 具体类ADD
    /// </summary>
    public class AddOperation : Operation
    {
        public override double getResult()
        {
            return OperateA + OperateB;
        }
    }

    /// <summary>
    /// 具体类SUB
    /// </summary>
    public class SubOperation : Operation
    {
        public override double getResult()
        {
            return OperateA - OperateB;
        }

    }

    /// <summary>
    /// 具体类MUL
    /// </summary>
    public class MulOperation : Operation
    {
        public override double getResult()
        {
            return OperateA * OperateB;
        }
    }

    /// <summary>
    /// 具体类DIV
    /// </summary>
    public class DivOperation : Operation
    {
        public override double getResult()
        {
            if (OperateB == 0)
                throw new Exception("除数不能为0");
            return OperateA / OperateB;
        }
    }

　　抽象工厂：它声明了一个工厂方法，要求所有的具体工厂都实现这个工厂方法

/// <summary>
    /// 工厂方法
    /// </summary>
    public interface FactioryMethod
    {
        Operation createOperate();
    }

　　具体工厂：

/// <summary>
    /// 具体工厂ADD
    /// </summary>
    public class AddFactory:FactioryMethod
    {
        public Operation createOperate()
        {
            return new AddOperation();
        }
    }

    /// <summary>
    /// 具体工厂SUB
    /// </summary>
    public class SubFactory : FactioryMethod
    {
        public Operation createOperate()
        {
            return new SubOperation();
        }
    }

    /// <summary>
    /// 具体工厂MUL
    /// </summary>
    public class MulFactory : FactioryMethod
    {
        public Operation createOperate()
        {
            return new MulOperation();
        }
    }

    /// <summary>
    /// 具体工厂DIV
    /// </summary>
    public class DivFactory : FactioryMethod
    {
        public Operation createOperate()
        {
            return new DivOperation();
        }
    }

　　客户端实现：

            var operate = new AddFactory().createOperate();
            operate.OperateA = 1;
            operate.OperateB = 2;
            var ret = operate.getResult();

　　工厂方法模式在实现时，客户端需要决定实例化哪一个工厂来实现一个运算类，选折判断的问题还是存在的，也就是是说，工厂方法模式把简单工厂内部的逻辑判断移动到了客户端来进行，也就是说如果需要加其他的运算方法，本来是修改工厂类，现在是修改客户端代码。虽然客服了简单工厂的缺点，但是也增加了额外的开发量。