设计模式（2）---工厂模式

　　一、引言

　　上一篇介绍了最基本的简单工厂模式，其中提到：简单工厂模式系统难以扩展，一旦添加新产品就不得不修改简单工厂方法，如此会造成简单工厂的实现逻辑过于复杂，本文介绍的工厂模式可以有效的解决此问题。

 

　　二、定义：

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

　　工厂模式实现时，客户端需要决定实例化哪一个工厂类实现运算类，选择判断的问题还是存在的，即：工厂方法把简单工厂的内部逻辑判断转移到了客户端来进行。如果需要增加功能，则修改客户端。

 

　　三、UML图

　　角色：　

　　抽象工厂Creator：声明工厂方法，返回一个产品。　

　　具体工厂角色ConcreteCreator：实现生成具体产品的方法，返回一个具体产品。

　　抽象产品角色Product：上述所有类的父类或者是接口。

　　具体产品角色Concrete Product：由工厂类创建出来的具体的产品实例。

 

　　UML图：

　　

　　四、举例说明：

　　在简单工厂模式中用实现加减乘除的实例进行具体说明，本节将继续使用此例说明工厂模式。

　　

　　抽象产品：　　

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

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

 

　　具体产品：

class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
            {
                throw new Exception("除数不能为0");
            }
            result = NumberA / NumberB;
            return result;
        }
    }

 

　　抽象工厂：

interface IFactory
    {
        Operation CreateOperation();
    }

 

　　具体工厂：

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

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

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

    class DivFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();
        }
    }

 

　　客户端调用：

static void Main(string[] args)
        {
            IFactory operFactory = new AddFactory();
            Operation oper = operFactory.CreateOperation();
            oper.NumberA = 3;
            oper.NumberB = 7;
            double result = oper.GetResult();

            Console.WriteLine(result);
        }

 

　　五、优缺点及适用场合

　　优点：

　　1）基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象。而且如何创建一个具体产品的细节完全封装在具体工厂内部，符合高内聚，低耦合。

　　2）在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，无需修改客户端，也无需修改其他的具体工厂和具体产品，很好的利用了封装和委托。

　　缺点：

　　添加新的功能产品时，需要编写新的具体产品类，并增加相应的具体工厂类。

　　应用场景：

　　1）类不知道需要创建什么对象，由客户端决定需要创建对象时。

　　2）当类将创建对象的职责委托给多个子类中的一个，并且希望子类是代理这一这一信息局部化的时候。（摘抄，不是很明白这一点）

 

　　六、总结

　　工厂模式通过面向对象编程中的多态性将对象的创建延迟到具体的工厂中，从而解决了简单工厂模式中存在的问题，同时遵循设计原则：对扩展开放，对修改关闭。