策略模式（Strategy Pattern）

Posted 2021-07-23 顧棟

文章目录

• 策略模式（Strategy Pattern）
• • 策略模式的定义
  • 策略模式的优点
  • 策略模式的缺点
  • 策略模式的结构
  • 策略模式的实现
  • • 简单策略方式
    • 枚举策略方式
  • 策略模式的场景

策略模式（Strategy Pattern）

策略模式的定义

也叫做政策模式，定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。

策略模式的优点

1. 多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句，如 if…else 语句、switch…case 语句。
2. 策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
3. 策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
4. 策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
5. 策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。

策略模式的缺点

1. 客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
2. 策略模式造成很多的策略类，增加维护难度。

策略模式的结构

策略模式的主要角色如下。

1. 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
2. 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
3. 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

策略模式的实现

简单策略方式

public interface Strategy {
    /**
     * 策略模式的运算法则
     */
    public void doSomething();
}

public class ConcreteStrategy1 implements Strategy{
    @Override
    public void doSomething() {
        System.out.println("具体策略1的运算法则");
    }
}

public class ConcreteStrategy2 implements Strategy{
    @Override
    public void doSomething() {
        System.out.println("具体策略2的运算法则");
    }
}

public class Context {
    //抽象策略
    private Strategy strategy = null;

    /**
     * 构造函数设置具体策略
     */
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 封装后的策略方法
     */
    public void doAnythinig() {
        this.strategy.doSomething();
    }
}

public static void main(String[] args) {
    //声明一个具体的策略
    Strategy strategy = new ConcreteStrategy1();
    //声明上下文对象
    Context context = new Context(strategy);
    //执行封装后的方法
    context.doAnythinig();

    //声明一个具体的策略
    Strategy strategy2 = new ConcreteStrategy1();
    //声明上下文对象
    context = new Context(strategy2);
    //执行封装后的方法
    context.doAnythinig();
}

枚举策略方式

public enum Calculator {
    //加法运算
    ADD("+") {
        @Override
        public int exec(int a, int b) {
            return a + b;
        }
    },
    //减法运算
    SUB("-") {
        @Override
        public int exec(int a, int b) {
            return a - b;
        }
    };
    String value = "";

    /**
     * 定义成员值类型
     */
    private Calculator(String value) {
        this.value = value;
    }

    /**
     * 获得枚举成员的值
     */
    public String getValue() {
        return this.value;
    }

    /**
     * 声明一个抽象函数
     */
    public abstract int exec(int a, int b);
}

public static void main(String[] args) {
    //输入的两个参数是数字
    int a = Integer.parseInt(args[0]);
    int b = Integer.parseInt(args[2]);
    //符号
    String symbol = args[1];
    System.out.println("输入的参数为：" + Arrays.toString(args));
    System.out.println("运行结果为：" + a + symbol + b + "=" + Calculator.ADD.exec(a, b));
}

策略模式的场景

• 多个类只有在算法或行为上稍有不同的场景。
• 算法需要自由切换的场景。
• 需要屏蔽算法规则的场景。

---

本文主要参考：

1. 小傅哥的《重学Java模式》
2. 《C语言中文网》设计模式的相关内容
3. 《设计模式之禅》第二版 秦小波