1、策略模式（Strategy）的定义
策略模式（Strategy）定义了不同的算法，分别分装起来，让他们可以互相替换，即使算法变化了，也不会影响到使用算法的用户。策略模式让算法独立于使用它的客户而独立变化。
策略模式本质是：分离算法，选择实现。
通俗来讲：策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。
2、模式（Strategy）优缺点
策略模式是一种行为型设计模式。其主要优缺点如下：
优点：
- 可以动态的改变对象的行为。
- 上下文和具体策略是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。
- 策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。
缺点：
- 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
- 策略模式将造成产生很多策略类。
3、模式（Strategy）适用环境
- JAVASE中GUI编程中，布局管理。
- Spring框架中，Resource接口，资源访问策略。
- javax.servlet.http.HttpServlet#service()。
- 针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。
- 需要安全的封装多种同一类型的操作时。
- 出现同一抽象多个子类，而又需要使用if-else 或者 switch-case来选择时。
- 可以和工厂模式结合使用。
4、模式（Strategy）的结构
策略模式涉及到三个角色：
- 环境角色（Context） ：用于连接上下文，持有一个策略Strategy的引用。
- 抽象策略角色（Strategy） ：这是一个抽象角色，通常由一个接口或抽象类实现，此角色给出所有具体策略类所需的接口。
- 具体策略角色（Concrete Strategy） ：包装了相关算法或行为。
5、模式（Strategy）的应用实例
5.1 实例一：报价策略
某个市场人员接到单后的报价策略(CRM系统中常见问题)。报价策略很复杂，可以简单作如下分类：
- 普通客户小批量报价
- 普通客户大批量报价
- 老客户小批量报价
- 老客户大批量报价
- 具体选用哪个报价策略，这需要根据实际情况来确定。这时候，如果我们用普通的方式来实现如下：
public double getPrice(String type, double price) {
if (type.equals("普通客户小批量")) {
System.out.println("不打折,原价");
return price;
} else if (type.equals("普通客户大批量")) {
System.out.println("打九折");
return price * 0.9;
} else if (type.equals("老客户小批量")) {
System.out.println("打八五折");
return price * 0.85;
} else if (type.equals("老客户大批量")) {
System.out.println("打八折");
return price * 0.8;
}
return price;
}
这种通过条件判断的方式来实现比较符合普通程序员的思维习惯，但是算法比较复杂时，整个条件控制代码会变得很长，难于维护。
使用策略模式
上面的案例就非常适合使用策略模式。策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。我们通过案例来说明。
// Strategy接口
public interface Strategy {
public double getPrice(double standardPrice);
}
// 四种算法实现
public class NewCustomerFewStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("不打折，原价");
return standardPrice;
}
}
public class NewCustomerManyStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("打九折");
return standardPrice*0.9;
}
}
public class OldCustomerFewStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("打八五折");
return standardPrice*0.85;
}
}
public class OldCustomerManyStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("打八折");
return standardPrice*0.8;
}
}
// 对外统一出口
/**
* 负责和具体的策略类交互
* 这样的话，具体的算法和直接的客户端调用分离了，使得算法可以独立于客户端独立的变化。
* 如果使用spring的依赖注入功能，还可以通过配置文件，动态的注入不同策略对象，动态的切换不同的算法.
* @author Administrator
*
*/
public class Context {
//当前采用的算法对象
private Strategy strategy;
//可以通过构造器来注入
public Context(Strategy strategy) {
super();
this.strategy = strategy;
}
//可以通过set方法来注入
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void pringPrice(double s){
System.out.println("您该报价："+strategy.getPrice(s));
}
}
// 测试
public static void main(String[] args) {
Strategy s1 = new OldCustomerManyStrategy();
Context ctx = new Context(s1);
ctx.pringPrice(998);
}
5.2 实例二：数学运算
// 抽象策略类
public interface Strategy {
public int doOperation(int num1, int num2);
}
// 具体策略类
public class OperationAdd implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
public class OperationMultiply implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 * num2;
}
}
public class OperationSubstract implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
// 应用场景类(上下文)
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int num1, int num2) {
return strategy.doOperation(num1, num2);
}
}
// 测试类
public class StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationSubstract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationMultiply());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
5.3 和简单工厂模式结合
// 上下文
public class Context2 {
private Strategy strategy;
public Context2(String type) {
switch (type) {
case "+":
strategy = new OperationAdd();
break;
case "-":
strategy = new OperationSubstract();
break;
case "*":
strategy = new OperationMultiply();
break;
}
}
public int executeStrategy(int num1, int num2) {
return strategy.doOperation(num1, num2);
}
}
// 测试类
public class StrategyPatternDemo {
public static void main(String[] args) {
System.out.println("-----使用简单工厂模式-----");
Context2 context2 = new Context2("+");
System.out.println("10 + 5 = " + context2.executeStrategy(10, 5));
// 使用Lambda表达式，不需要实现策略类
System.out.println("-----使用Lambda表达式，不需要实现策略类-----");
Context context3 = new Context((num1, num2) -> num1 + num2);
System.out.println("10 + 5 = " + context3.executeStrategy(10, 5));
context3 = new Context((num1, num2) -> num1 - num2);
System.out.println("10 - 5 = " + context3.executeStrategy(10, 5));
context3 = new Context((num1, num2) -> num1 * num2);
System.out.println("10 * 5 = " + context3.executeStrategy(10, 5));
}
}
评论区