本质：分离算法，选择实现。
策略模式：针对一组算法，将每一个算法封装到具有共同接口的独立的类中，使得它们可以互换。
使用策略模式可以把行为和环境分割开来。环境类Context负责查询要做什么，各种算法则在具体策略类（ConcreteStrategy）中提供。
当出现新的促销折扣或现有的折扣政策出现变化时，只需要实现新的策略类，并在客户端登记即可。
环境（Context）：有一个Strategy类的引用，和具体的策略类交互。
抽象策略（Strategy）角色：一个接口或抽象类，给出规范。
具体策略（ConcreteStrategy）角色：具体算法或行为。
上下文使用具体策略对象，具体策略对象也可以从上下文获取所需要的数据，因此，可以将上下文当做参数传递给具体策略对象。
上下文封装着具体策略对象需要的数据，具体策略对象通过回调上下文的方法来获取这些数据。
这里为了方便理解，我们就拿刚学习Java的时候使用计算方法来说吧。
在使用计算器进行计算的时候，会经常用到加减乘除方法。如果我们想得到两个数字相加的和，我们需要用到“+”符号，得到相减的差，需要用到“-”符号等等。虽然我们可以通过字符串比较使用if/else写成通用方法，但是计算的符号每次增加，我们就不得不加在原先的方法中进行增加相应的代码，如果后续计算方法增加、修改或删除，那么会使后续的维护变得困难。
但是在这些方法中，我们发现其基本方法是固定的，这时我们就可以通过策略模式来进行开发，可以有效避免通过if/else来进行判断，即使后续增加其他的计算规则也可灵活进行调整。
抽象类CashStrategy：定义收银的计算方法
CashContext角色：引用CashStrategy的一个实例
CashNormal是正常收费，CashRebate是打折收费，CashReturn是返利收费，是三个具体策略，客户端判断决定选择使用哪一个。
public abstract class CashStrategy {
public abstract double acceptCash(double money);
}
public class CashContext {
private CashStrategy cs;
public CashContext(CashStrategy cs) {
this.cs = cs;
}
public double getResult(double money) {
return cs.acceptCash(money);
}
}
public class CashNormal extends CashStrategy{
@Override
public double acceptCash(double money) {
// TODO Auto-generated method stub
return money;
}
}
public class CashRebate extends CashStrategy{
private double moneyRebate=0;
public CashRebate(double moneyRebate) {
this.moneyRebate = moneyRebate;
}
@Override
public double acceptCash(double money) {
return money*moneyRebate;
}
}
public class CashRetrun extends CashStrategy{
private double moneyCondition=0.0;
private double moneyReturn=0.0;
public CashRetrun(double moneyCondition, double moneyReturn) {
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
@Override
public double acceptCash(double money) {
double result=money;
if(money>moneyCondition)
result=money-Math.floor(money/moneyCondition)*moneyReturn;
//floor():向下取整
return result;
}
}
import java.util.Scanner;
public class Test {
static double total=0.0;
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
System.out.println("请输入优惠方案：");
String str=cin.next();
CashContext cc=null;
switch(str) {
case "正常收费":
cc=new CashContext(new CashNormal());
break;
case "满300返100":
cc=new CashContext(new CashRetrun(300,100));
break;
case "打8折":
cc=new CashContext(new CashRebate(0.8));
break;
}
System.out.println("请输入消费金额：");
double price=cin.nextInt();
total=cc.getResult(price);
System.out.println("最后共消费："+total);
cin.close();
}
}
同一个算法，有很多不同的实现情况。
一个定义了很多行为的类，通过多个if-else语句来选择这些行为的情况
优点：
缺点：
把分支判断从客户端移动到到环境CashContext类中，此时CashContext相当于一个工厂，选择实例化不同的具体策略类
public class CashContext {
private CashStrategy cs=null;
//简单工厂：将实例化具体策略从客户端放入Context类中
public CashContext(String type) {
switch(type) {
case "正常收费":
CashNormal cs0=new CashNormal();
cs=cs0;
break;
case "满300返100":
CashRetrun cr1=new CashRetrun(300,100);
cs=cr1;
break;
case "打8折":
CashRebate cr2=new CashRebate(0.8);
cs=cr2;
break;
}
}
public double getResult(double money) {
return cs.acceptCash(money);
}
}
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
System.out.println("请输入优惠方案：");
String str=cin.next();
CashContext cc=new CashContext(str);
System.out.println("请输入消费金额：");
double price=cin.nextInt();
double total=cc.getResult(price);
System.out.println("最终消费："+total);
cin.close();
}
}