设计模式-策略模式

使用简单工厂实现一个商城消费的程序

考虑到商城消费策略经常改动，所以这里通过简单工厂来生成不同的消费策略。如打0.8折的消费策略，又如满300返100的消费策略。
代码结构：

1、抽象出商城消费策略

package simpleFactoryPattern;
//抽象出收取现金的策略
public interface CashSupper {
	public double acceptCash(double money);
}

2、实现具体的消费策略

package simpleFactoryPattern;
//正常的收费标准
public class CashNormal implements CashSupper{
	@Override
	public double acceptCash(double money) {
		return money;
	}
}

package simpleFactoryPattern;
//打折
public class CashRabete implements CashSupper{
	public double moneyRabete = 1d;
	public CashRabete(double moneyRabete) {
		this.moneyRabete = moneyRabete;
	}
	@Override
	public double acceptCash(double money) {
		return money * moneyRabete;
	}
}

package simpleFactoryPattern;
//返利
public class CashReturn implements CashSupper{
	private double moneyCondition = 0.0d;
	private double moneyReturn = 0.0d;
	public CashReturn(double moneyCondition,double moneyReturn) {
		this.moneyCondition = moneyCondition;
		this.moneyReturn = moneyReturn;
	}
	@Override
	public double acceptCash(double money) {
		return money * Math.floor(moneyReturn/moneyCondition) * money;
	}
}

3、生成具体策略的工厂

package simpleFactoryPattern;

public class CashStrategyFactory {
	public static CashSupper createCashSupper(String type){
		CashSupper cs = null;
		switch(type){
		case "正常消费":
			cs = new CashNormal();
			break;
		case "满300返100":
			cs = new CashReturn(300, 100);
			break;
		case "打8折":
			cs = new CashRabete(0.8);
			break;
		}
		return cs;
	}
}

4、客户端Main

package simpleFactoryPattern;
public class Main {
	public static void main(String[] args) {
		CashSupper cs = CashStrategyFactory.createCashSupper("正常消费");
		double result = cs.acceptCash(100);
		System.out.println("当前消费金额:" + result);
	}
}

使用策略模式

对于类似商城这样的程序，用策略模式来解决比工厂策略模式更优。
策略模式适应于程序内部执行策略需要经常改动的情况。如上面商城程序中对于消费策略的变动的频繁的，甚至不知道商城在什么时候用什么策略。
下面为策略模式的UML类图。

将商城程序用策略模式来实现

将策略抽象，让使用策略的类依赖抽象

package strategyPattern;
public interface SupperStrategy {
	public double acceptCash(double money);
}

使用策略的类

package strategyPattern;
public class StrategyContext {
	private SupperStrategy ss = null;
	public StrategyContext(SupperStrategy ss) {
		this.ss = ss;
	}
	public double acceptCash(double money){
		return ss.acceptCash(money);
	}
}

策略的具体实现类

//正常消费
package strategyPattern;
public class NormalStrategy implements SupperStrategy{
	@Override
	public double acceptCash(double money) {
		return money;
	}
}

//返利消费
package strategyPattern;
public class ReturnStrategy implements SupperStrategy{
	private double moneyCondition = 0.0d;
	private double moneyReturn = 0.0d;
	public ReturnStrategy(double moneyCondition,double moneyReturn) {
		this.moneyCondition = moneyCondition;
		this.moneyReturn = moneyReturn;
	}
	@Override
	public double acceptCash(double money) {
		return money * Math.floor(moneyReturn/moneyCondition) * money;
	}
}

//打折消费
package strategyPattern;
public class RabeteStrategy implements SupperStrategy{
	public double moneyRabete = 1d;
	public RabeteStrategy(double moneyRabete) {
		this.moneyRabete = moneyRabete;
	}
	@Override
	public double acceptCash(double money) {
		return money * moneyRabete;
	}
}

Main客户端

package strategyPattern;
/*
 * 对于经常需要变动的策略，例如超市打折，那么这里可用策略模式
 */
public class Main {
	public static void main(String[] args) {
		SupperStrategy normalStrategy = new NormalStrategy();	//这里可以通过反射机制实现动态调整策略
		StrategyContext context = new StrategyContext(normalStrategy);
		double result = context.acceptCash(100);
		System.out.println("第一种收费策略："+result);
		
		SupperStrategy rabeteStrategy = new RabeteStrategy(0.8);	//这里可以通过反射机制实现动态调整策略
		StrategyContext context2 = new StrategyContext(rabeteStrategy);
		double result2 = context2.acceptCash(100);
		System.out.println("第二种收费策略："+result2);
	}
}