简单工厂模式
在创建对象时,通过传入的参数的值决定要实例化的对象。
弊端:增加功能时,需要修改工厂类代码,不符合开放-封闭原则。
示例:实现加减运算
//父类
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;
}
}
//加法类
public class OperationAdd extends Operation {
public double getResult() {
return getNumberA() + getNumberB();
}
}
//减法类
public class OperationSub extends Operation {
public double getResult() {
return getNumberA() - getNumberB();
}
}
//工厂类
public class OperationFactory {
public static Operation createOperate(String operate) {
Operation oper = null;
switch (operate) {
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
default:
break;
}
return oper;
}
}
策略模式
将不同的算法(变化点)封装起来,让它们可以相互替换,这种模式使算法的变化不会影响到使用算法的客户。
选择策略类作为参数传入Context类中,在运行时调用对应的算法。
示例:商场收费(正常收费、打折收费、满减收费)
//父类
public abstract class CashSupper {
public abstract double acceptCash(double money);
}
//正常收费
public class CashNormal extends CashSupper {
@Override
public double acceptCash(double money) {
// TODO Auto-generated method stub
return money;
}
}
//打折收费
public class CashRebate extends CashSupper {
private double moneyRebate = 1d;
public CashRebate(String moneyRebate) {
this.moneyRebate = Double.parseDouble(moneyRebate);
}
@Override
public double acceptCash(double money) {
// TODO Auto-generated method stub
return money * moneyRebate;
}
}
//满减收费
public class CashReturn extends CashSupper {
private double moneyCondition = 0.0d;//满减条件
private double moneyReturn = 0.0d;//返利值
public CashReturn(String moneyCondition, String moneyReturn) {
this.moneyCondition = Double.parseDouble(moneyCondition);
this.moneyReturn = Double.parseDouble(moneyReturn);
}
@Override
public double acceptCash(double money) {
// TODO Auto-generated method stub
if(money >= moneyCondition) {
return money - Math.floor(money / moneyCondition) * moneyReturn;
}else {
return money;
}
}
}
public class CashContext{
private CashSupper cashSupper;
public CashContext(CashSupper cs){
this.cashSupper = cs;
}
public double getResult(double money){
return cashSupper.acceptCash(money);
}
}
客户端代码:
CashContext cashContext = null;
switch(type){
case "正常收费":
cashContext = new CashContext(new CashNormal());
break;
case "打八折":
cashContext = new CashContext(new CashRebate("0.8"));
break;
case "满300减100":
cashContext = new CashContext(new CashReturn("300","100"));
break;
}
//获取最后的费用
cashContext.getResult(money);
为了避免在客户端判断用哪个算法,可以将工厂模式结合进来。
//更改后的CashContext
public class CashContext {
private CashSupper cashSupper;
public CashContext(String type) {
switch (type) {
case "正常收费":
cashSupper = new CashNormal();
break;
case "打八折":
cashSupper = new CashRebate("0.8");
break;
case "满300减100":
cashSupper = new CashReturn("300", "100");
default:
break;
}
}
public double getResult(double money) {
return cashSupper.acceptCash(money);
}
}
只需要将 CashContext 类做出修改,更改后的客户端代码:
public static void main(String[] args) {
// TODO Auto-generated method stub
String type = "满300减100";
double money = 900d;
CashContext cashContext = new CashContext(type);
System.out.println(cashContext.getResult(money));
}