设计模式笔记————简单工厂模式和策略模式

简单工厂模式

在创建对象时，通过传入的参数的值决定要实例化的对象。

弊端：增加功能时，需要修改工厂类代码，不符合开放-封闭原则。

示例：实现加减运算

//父类
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));
}