设计模式（一）： 简单工厂模式

一、模式定义

简单工厂模式（Simple Factory Pattern）：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单来说，也就是由一个工厂类根据传入的参数决定创建出哪一种产品类的实例。

二、模式结构

 

（图片来自博客：https://blog.csdn.net/xingjiarong/article/details/49999121）

 

简单工厂模式主要有三个部分组成:

• 工厂类（Creator）：这个类是简单工厂模式中的核心，含有与引用紧密相关的商业逻辑。
• 抽象类（AbstractProduct）：这个类是有简单工厂模式所创建的对象的父类，或他们共同拥有接口。
• 具体实现（ConcreteProduct）：这个类是简单工厂模式实例化对象的类。

三、代码示例

此处代码分为二个版本迭代，第二个版本为最终版本，可以直接查看。代码实现的功能仅仅是数字之间的加减法。

版本一：此版本将业务逻辑与界面逻辑分开：

/// <summary>
/// 该版本将运算类封装,不考虑输入错误的情况
/// </summary>
public class VersionOne
{
    public void GetResult()
    {
        try
        {
            Console.WriteLine("请输入数字A：");
            string strNumberA = Console.ReadLine();
            Console.WriteLine("请选择运算符号（+、-、*、/）");
            string strOperate = Console.ReadLine();
            Console.WriteLine("请输入数字B：");
            string strNumberB = Console.ReadLine();
            string strResult = "";
            strResult = Convert.ToString(OperationVerOne.GetResult(Convert.ToDouble(strNumberA), Convert.ToDouble(strNumberB), strOperate));
            Console.WriteLine("结果是：" + strResult);
            Console.ReadKey();
        }
        catch (Exception e)
        {
            Console.WriteLine("您输入的有错" + e.Message);
        }
    }
}

public class OperationVerOne
{
    public static double GetResult(double numberA, double numberB, string operate)
    {
        double result = 0d;
        switch (operate)
        {
            case "+":
                result = numberA + numberB;
                break;
            case "-":
                result = numberA - numberB;
                break;
            case "*":
                result = numberA * numberB;
                break;
            case "/":
                result = numberA / numberB;
                break;
        }

        return result;
    }
}

版本二， 通过继承的方式实现加减乘除运算分离的操作遵守开放--封闭的原则，并通过工厂实现运算：

class VersionTwo
{
　　 public void Operation()
    {
        OperationTwo oper;
        Console.WriteLine("请输入数字A：");
        string strNumberA = Console.ReadLine();
        Console.WriteLine("请选择运算符号（+、-、*、/）");
        oper = OperationFactory.createOperation(Console.ReadLine());
        Console.WriteLine("请输入数字B：");
        string strNumberB = Console.ReadLine();

        oper.NumberA = Convert.ToDouble(strNumberA);
        oper.NumberB = Convert.ToDouble(strNumberB);

        double result = oper.GetResult();

        Console.WriteLine("结果是: " + result);
        Console.ReadKey();
    }
}

// 工厂类
// 通过传入的参数创建对应的操作类
public class OperationFactory
{
    public static OperationTwo createOperation(string operate)
    {
        OperationTwo oper = null;
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }

        return oper;
    }
}

// Operation 类，基类
public class OperationTwo
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { this._numberA = value; }
    }

    public double NumberB
    {
        get { return _numberB; }
        set { this._numberB = value; }
    }

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

// 加减乘除类
class OperationAdd : OperationTwo
{
    public override double GetResult()
    {
        double result = 0;
        result = this.NumberA + this.NumberB;
        return result;
    }
}

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

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

class OperationDiv : OperationTwo
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA / NumberB;
        return result;
    }
}

 该示例中的UML 图

四、优缺点

• 优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。
• 缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

五、使用场景

• 工厂类负责创建的对象比较少；
• 客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
• 由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

代码的github：https://github.com/gp112/DesignPattern

参考：

《大话设计模式》

博客：https://blog.csdn.net/xingjiarong/article/details/49999121