[Java 策略模式详解]
1、什么是策略模式？
策略模式（Strategy Pattern）：定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。
2、策略模式定义
①、Context封装角色
它也叫做上下文角色， 起承上启下封装作用， 屏蔽高层模块对策略、 算法的直接访问，封装可能存在的变化。
②、Strategy 抽象策略角色
策略、 算法家族的抽象， 通常为接口， 定义每个策略或算法必须具有的方法和属性。
③、ConcreteStrategy 具体策略角色
实现抽象策略中的操作， 该类含有具体的算法。
策略模式体现了面向对象程序设计中非常重要的两个原则：
- 封装变化的概念。
- 编程中使用接口，而不是使用的是具体的实现类(面向接口编程)。
3、策略模式通用代码
public class Context {
// 抽象策略
private Strategy strategy = null;
// 构造函数设置具体策略
public Context(Strategy strategy) {
this.strategy = strategy;
}
// 封装后的策略方法
public void doAnything(){
this.strategy.doSomething();
}
}
public interface Strategy {
// 策略模式的运算法则
public void doSomething();
}
public class ConcreteStrategy1 implements Strategy{
@Override
public void doSomething() {
System.out.println("ConcreteStrategy1");
}
}
public class ConcreteStrategy2 implements Strategy{
@Override
public void doSomething() {
System.out.println("ConcreteStrategy2");
}
}
测试：
public class StrategyClient {
public static void main(String[] args) {
// 声明一个具体的策略
Strategy strategy = new ConcreteStrategy1();
// 声明上下文对象
Context context = new Context(strategy);
// 执行封装后的方法
context.doAnything();
}
}
4、用策略模式改写if-else
去买衣服
- 新客户小批量：原价，不打折
- 新客户大批量：打九折
- 老客户小批量：打八五折
- 老客户大批量：打8折
4.1 常规写法
/**
* 实现起来比较容易，符合一般开发人员的思路
* 假如，类型特别多，算法比较复杂时，整个条件语句的代码就变得很长，难于维护。
* 如果有新增类型，就需要频繁的修改此处的代码！
* 不符合开闭原则！
*/
public class TestStrategy {
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;
}
}
4.2 策略模式改写
下面用策略模式来实现去买衣服打折的问题：
第一步：定义抽象策略角色，通常情况下使用接口或者抽象类去实现
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 NewCustomerFewStrategy implements Strategy {
@Override
public double getPrice(double standardPrice) {
System.out.println("不打折，原价");
return standardPrice;
}
}
/**
* 老客户小批量
*/
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的依赖注入功能，还可以通过配置文件，动态的注入不同策略对象，动态的切换不同的算法.
*/
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 class Client {
public static void main(String[] args) {
Strategy s1 = new OldCustomerManyStrategy();
Context ctx = new Context(s1);
ctx.pringPrice(500);
}
}
运行此类，控制台打印效果如图：
5、策略模式优点
①、算法可以自由切换
这是策略模式本身定义的， 只要实现抽象策略， 它就成为策略家族的一个成员， 通过封装角色对其进行封装， 保证对外提供“可自由切换”的策略。
②、避免使用多重条件判断
简化多重if-else，或多个switch-case分支。
③、扩展性良好
增加一个策略，只需要实现一个接口即可。
- 开闭原则；
- 避免使用多重条件转移语句；
- 提高了算法的保密性和安全性：可使用策略模式以避免暴露复杂的，与算法相关的数据结构。
6、策略模式应用场景
- JAVASE中GUI编程中，布局管理 ；
- Spring框架中，Resource接口，资源访问；
- javax.servlet.http.HttpServlet#service()；
- 如果一个方法有大量if else语句，可通过策略模式来消除掉；
- 一个系统，需要动态地在几个算法中选择一种，可用策略模式实现；
- 系统有很多类，而他们的区别仅仅在于他们的行为不同