设计模式之三(工厂方法模式)

前言

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

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

工厂方法模式实现时，客户端需要决定实例化那一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移动到了客户端代码来进行。你想要加功能，本来是改工厂类的（简单工厂模式），而现在是修改客户端。

工厂方法UML类图

 

如果想加一个功能，比如M的N次方，只需要增加此功能的运算类和相应的工厂类就可以了。

代码实现

 1.第一步写好运算类：

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

        public double NumberB { get; set; }

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

2.那么接下来就需要实现加减乘除运算类

/// <summary>
    /// 加法运算类
    /// </summary>
    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;
        }
    }

第三步写好抽象工厂

///抽象工厂 工厂接口
    public interface IFactory
    {
        Operation CreateOperation();
    }

工厂接口返回的就是运算类

第四步实现加减乘除抽象工厂

/// <summary>
    /// 加法工厂类
    /// </summary>
    public class AddFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }

    /// <summary>
    /// 减法工厂类
    /// </summary>
    public class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

    /// <summary>
    /// 乘法工厂类
    /// </summary>
    public class MulFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationMul();
        }
    }

    /// <summary>
    /// 除法工厂类
    /// </summary>
    public class DivFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();
        }
    }

第五步进行调用一个加法的示例

class Program
    {
        static void Main(string[] args)
        {
            ////调用加法的示例
            IFactory OperationFactory = new AddFactory();
            Operation Oper = OperationFactory.CreateOperation();
            Console.WriteLine("输入第一个数字：A");
            Oper.NumberA = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("输入第二个数字：B");
            Oper.NumberB = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine(Oper.GetResult());
            Console.ReadLine();
        }
    }

运行后结果为

总结

 工厂方法模式克服了简单工厂违背开放-封闭原则的缺点，有保持了封装对象创建过程的优点。工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。但缺点是由于每加一个产品，就需要加一个产品工厂的类，增加了额外的开发量。当然还有更好的方案……

如果您对上节的简单工厂模式还不太了解可以看一下​