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

现在，有这样一个需求，你的领导告诉你说，写了一个计算器，能够进行加法计算。于是，你三下五除二分分钟搞定了，设计了美观的界面，看起来一切都是那么的完美。你按照计算的思路，读取变量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里面增加这个计算类型的判别就可以了。