策略模式
1.定义
一个类的行为或其算法可以在运行时进行更改。
策略模式通常有3种角色。
AbstractStrategy：抽象策略角色。策略，算法的抽象。
public interface AbstractStrategy { /** * 策略的行为，算法 */ void operate();}Strategy：具体策略角色。实现抽象策略中定义的行为或算法。
public class StrategyOne implements AbstractStrategy { @Override public void operate() { System.out.println("策略模式1的具体行为"); }}public class StrategyTwo implements AbstractStrategy { @Override public void operate() { System.out.println("策略模式2的具体行为"); }}Context：上下文角色。封装具体的策略，屏蔽高层模块对策略，算法的直接访问。
public class Context { /** 抽象策略 **/ private AbstractStrategy strategy; /** * 设置具体的策略 * @param strategy */ public void setStrategy(AbstractStrategy strategy) { this.strategy = strategy; } /** * 封装策略方法 */ public void run() { this.strategy.operate(); }}场景类
public class Client { public static void main(String[] args) { Context context = new Context(); /** 设置第一个策略 **/ context.setStrategy(new StrategyOne()); /** 执行第一个策略 **/ context.run(); /** 设置第二个策略 **/ context.setStrategy(new StrategyTwo()); /** 执行第二个策略 **/ context.run(); }}2.应用
2.1 优点
- 策略，算法可以自由的切换。
- 扩展性良好，只需要实现抽象策略即可。
2.2 缺点
- 当策略过多时，策略类的数量也会增加。
- 所有的策略类都需要对外暴露。高层模块必须知道有哪些策略才可以进行调用。
2.3 注意事项
当一个策略家族中策略类的数量超过4个时，需要考虑结合其它模式使用，解决策略类膨胀和对外暴露的问题。
3.扩展
输入三个参数（int, int, String），进行加减法运算，不考虑参数校验。
3.1 直接加减法
public class DirectCalculator { private final static String ADD = "+"; private final static String SUB = "-"; public int calculate(int a, int b, String symbol) { int result = 0; if (ADD.equals(symbol)) { result = this.add(a, b); } else if (SUB.equals(symbol)) { result = this.sub(a, b); } return result; } /** * 加法 a + b * @param a * @param b * @return */ private int add(int a, int b) { return a + b; } /** * 减法 a - b * @param a * @param b * @return */ private int sub(int a, int b) { return a - b; }}3.2 策略模式
public interface Calculator { /** * 抽象计算方法 * @param a * @param b * @return */ int calculate(int a, int b);}public class AddCalculator implements Calculator { /** * 加法 a + b * @param a * @param b * @return */ @Override public int calculate(int a, int b) { return a + b; }}public class SubCalculator implements Calculator { /** * 减法 a - b * @param a * @param b * @return */ @Override public int calculate(int a, int b) { return a - b; }}public class CalculatorContext { private Calculator calculator; public CalculatorContext(Calculator calculator) { this.calculator = calculator; } public void setCalculator(Calculator calculator) { this.calculator = calculator; } public int calculate(int a, int b) { return this.calculator.calculate(a, b); }}3.3 策略枚举
public enum CalculatorStrategyEnum { /** 加法运算 **/ ADD("+") { @Override public int calculate(int a, int b) { return a + b; } }, /** 减法运算 **/ SUB("-") { @Override public int calculate(int a, int b) { return a - b; } }; private String symbol = ""; CalculatorStrategyEnum(String symbol) { this.symbol = symbol; } public String getSymbol() { return this.symbol; } /** * 声明一个计算的抽象方法 * @param a * @param b * @return */ public abstract int calculate(int a, int b);}public class Client { public static void main(String[] args) { System.out.println(CalculatorStrategyEnum.ADD.calculate(1, 2)); System.out.println(CalculatorStrategyEnum.SUB.calculate(5, 1)); }}
没有评论:
发表评论