设计模式之——简单工厂模式

现在，有这样一个需求，你的领导告诉你说，写了一个计算器，能够进行加法计算。于是，你三下五除二分分钟搞定了，设计了美观的界面，看起来一切都是那么的完美。你按照计算的思路，读取变量a，读取变量b，读取+号，两个数相加，得出结论。

过了一天，你的领导说，我需要再增加减法运算，于是，Ctrl+C,Ctrl+V,分分钟搞定了。

又过了一天，你的领导说，增加乘法。。

再过了几天，增加除法。。

。。

一切都按照你的设计进行着。当你的程序已经非常繁杂了，有一天，突然有人告诉你，这个“=”太丑了，需要全部换。这下，你傻眼了。

如果一开始我们把这个问题抽象一下，加法，减法，乘法这些就是运算，输入的数据是固定的，我们就可以把整个需求改成下面这样子。

运算类：

/**
 * <p>
 * Description:运算类
 * </p>
 *
 * @author dailei
 * @version V1.0.0
 * @className Operation
 * @date 2016/11/10
 */
public class Operation
{
    private double numberA = 0;
    private double numberB = 0;
    private double result = 0;

    public double getNumberA()
    {
        return numberA;
    }

    public void setNumberA(double numberA)
    {
        this.numberA = numberA;
    }

    public double getNumberB()
    {
        return numberB;
    }

    public void setNumberB(double numberB)
    {
        this.numberB = numberB;
    }

    public double getResult()
    {
        return result;
    }
}

数据A，数据B，得到结果三个函数。

运算类：

/**
 * <p>
 * Description:加法器
 * </p>
 *
 * @author dailei
 * @version V1.0.0
 * @className Summator
 * @date 2016/11/10
 */
public class Summator extends Operation
{
    @Override
    public double getResult()
    {
        return getNumberA() + getNumberB();
    }
}

/**
 * <p>
 * Description:减法器
 * </p>
 *
 * @author dailei
 * @version V1.0.0
 * @className Subtractor
 * @date 2016/11/10
 */
public class Subtractor extends Operation
{
    @Override
    public double getResult()
    {
        return getNumberA()-getNumberB();
    }
}

加法器继承了运算类，减法器继承了运算类，他们都有一个相同的地方，那就是获得结果。但是，如果我们只是使用乘法，难道要把每一个计算器都加载吗，这么多的对象，极大的损耗了内存，做了无用功。

这个时候，我们就需要用到简单工厂模式了，用我们的工厂去生产各种不同的计算方式，用到那种计算方法再创建哪个对象。

工厂类：

public class OperationFactory
{
    private static OperationFactory instance = null;
    public static OperationFactory getInstance()
    {
        if(instance == null)
        {
            instance = new OperationFactory();
        }
        return instance;
    }
    private OperationFactory(){}
    public Operation createOperation(String operate)
    {
        Operation operation = null;
        if(operate == null)
        {
            return null;
        }
        switch (operate)
        {
            case "+" : operation = new Summator();
                break;
            case "-" : operation = new Subtractor();
                break;
        }
        return operation;
    }
}

这下，我们就可以像下面这样去用我们的工厂去生产我们需要的计算器了。

Operation operation = OperationFactory.getInstance().createOperation("+");
                operation.setNumberA(12);
                operation.setNumberB(6);
                Log.d(TAG,"result:"+operation.getResult());

这样，是不是极大的减少了损耗，而且可扩展性很强呢？减少了不同组件的依赖，当我们再次需要增加其他的计算方式的时候，只需要增加一个计算类，继承Operation，再OperationFactory里面增加这个计算类型的判别就可以了。