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