策略模式属于行为型模式,是使用最多的设计模式之一；其作用是针对一组算法，将每一个算法封装到具体共同接口的独立的类种，从而使得他们可以相互转化。策略模式使得算法可以在不影响到客户端得情况下发生变化。

在开发过程中，经常会遇到某种业务存在多种策略可供选择的情况，比如超市促销打折，旅游出行方案等。对于这一类的业务，按照传统的方法，主要有以下两种方案：

1. 所有的业务逻辑都放在客户端里面。客户端利用条件选择语句决定使用哪一个算法。这样一来，客户端代码会变得复杂和难以维护。
2. 客户端可以利用继承的办法在子类里面实现不同的行为，但是这样会使得环境和行为紧密耦合在一起。强耦合会使两者不能单独演化。

其实使用策略模式正是解决这个问题的系统化方法。当出现新的业务策略时，只需要实现新的策略类，并在客户端登记即可。策略模式相当于“可插入式(Pluggable）的算法”。策略模式就是把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略类(ConcreteStrategy)中提供。由于算法和环境独立开来，算法的增减、修改都不会影响环境和客户端。

当准备在一个系统里使用策略模式时，首先必须找到需要包装的算法，看看算法是否可以从环境中分割开来，最后再考察这些算法是否会在以后发生变化。

策略模式的UML类图如下：

由上图可以看出，策略模式主要涉及到抽象策略角色、具体策略角色、环境角色三种角色：

• 抽象策略角色：通常由一个接口或抽象类实现，次角色给出所有的具体策略类所需的接口
• 具体策略角色：包装了相关的算法或行为
• 环境角色：持有一个策略类的引用

图书折扣的例子

在一个购买图书的系统中，主要由一些几种不同的折扣：

折扣一（NoDiscountStrategy）：对有些图书没有折扣。折扣算法对象返还0作为折扣值。

折扣二（FlatRateStrategy）：对有些图书提供一个固定量值为1元的折扣。

折扣三（PercentageStrategy）：对有些图书提供一个百分比的折扣，比如本书价格为 20元，折扣百分比为7%，那么折扣值就是20×7%=1.4（元)。

例子的UML类图：

抽象策略角色：

package com.charon.strategy;

/**
 * @className: DiscountStrategy
 * @description:
 * @author: charon
 * @create: 2022-04-10 11:48
 */
public abstract class DiscountStrategy {

    /**
     * 价格
     */
    private double price = 0;

    /**
     * 数量
     */
    private int copies;

    public DiscountStrategy() {
    }

    public DiscountStrategy(double price, int copies) {
        this.price = price;
        this.copies = copies;
    }

    /**
     * 计算价格的策略方法
     * @return
     */
    abstract double calcDiscount();

    /**
     * Gets the value of price
     *
     * @return the value of price
     */
    public double getPrice() {
        return price;
    }

    /**
     * Gets the value of copies
     *
     * @return the value of copies
     */
    public int getCopies() {
        return copies;
    }
}

具体策略角色：

package com.charon.strategy;

/**
 * @className: NoDiscountStrategy
 * @description:
 * @author: charon
 * @create: 2022-04-10 11:48
 */
public class NoDiscountStrategy extends DiscountStrategy{
    @Override
    double calcDiscount() {
        return 0;
    }
}

package com.charon.strategy;

/**
 * @className: FlatRateStrategy
 * @description:
 * @author: charon
 * @create: 2022-04-10 11:48
 */
public class FlatRateStrategy extends DiscountStrategy{

    /**
     * 折扣金额
     */
    private int discountPrice;

    public FlatRateStrategy(double price, int copies) {
        super(price,copies);
    }

    /**
     * Sets the discountPrice
     *
     * @param discountPrice discountPrice
     */
    public void setDiscountPrice(int discountPrice) {
        this.discountPrice = discountPrice;
    }

    @Override
    double calcDiscount() {
        return discountPrice * getCopies();
    }
}

package com.charon.strategy;

/**
 * @className: PercentageStrategy
 * @description:
 * @author: charon
 * @create: 2022-04-10 11:49
 */
public class PercentageStrategy extends DiscountStrategy{

    /**
     * 折扣百分比
     */
    private double discountPercent;

    public PercentageStrategy(double price, int copies) {
        super(price, copies);
    }

    /**
     * Sets the discountPercent
     *
     * @param discountPercent discountPercent
     */
    public void setDiscountPercent(double discountPercent) {
        this.discountPercent = discountPercent;
    }

    @Override
    double calcDiscount() {
        return getCopies() * getPrice() * discountPercent;
    }
}

环境角色类：

package com.charon.strategy;

/**
 * @className: Book
 * @description:
 * @author: charon
 * @create: 2022-04-10 12:15
 */
public class Book {

    /**
     * 图书名称
     */
    private String name;

    /**
     * 折扣类型
     */
    private DiscountStrategy strategy;

    public Book(String name, DiscountStrategy strategy) {
        this.name = name;
        this.strategy = strategy;
    }

    /**
     * Sets the strategy
     *
     * @param strategy strategy
     */
    public void setStrategy(DiscountStrategy strategy) {
        this.strategy = strategy;
    }

    public void getDiscount(){
        System.out.println("图书名称：《" + name + "》，折扣算法为："+ strategy.getClass() +"，折扣价格为：" + strategy.calcDiscount());
    }
}

客户端角色：

package com.charon.strategy;

/**
 * @className: Client
 * @description:
 * @author: charon
 * @create: 2022-04-10 12:14
 */
public class Client {

    public static void main(String[] args) {
        Book book1 = new Book("java设计模式", new NoDiscountStrategy());
        book1.getDiscount();

        FlatRateStrategy rateStrategy = new FlatRateStrategy(23.0, 5);
        rateStrategy.setDiscountPrice(1);
        Book book2 = new Book("java与模式",rateStrategy);
        book2.getDiscount();

        System.out.println("修改《java与模式》的折扣算法：");
        PercentageStrategy percentageStrategy = new PercentageStrategy(23, 5);
        percentageStrategy.setDiscountPercent(0.07);
        book2.setStrategy(percentageStrategy);
        book2.getDiscount();
    }
}

打印：
    图书名称：《java设计模式》，折扣算法为：class com.charon.strategy.NoDiscountStrategy，折扣价格为：0.0
    图书名称：《java与模式》，折扣算法为：class com.charon.strategy.FlatRateStrategy，折扣价格为：5.0
    修改《java与模式》的折扣算法：
    图书名称：《java与模式》，折扣算法为：class com.charon.strategy.PercentageStrategy，折扣价格为：8.05

策略模式的主要优点如下：

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

策略模式的主要缺点如下：

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

策略模式的应用场景

策略模式在很多地方用到，如 Java SE 中的容器布局管理就是一个典型的实例，Java SE 中的每个容器都存在多种布局供用户选择。在程序设计中，通常在以下几种情况中使用策略模式较多。

1. 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
2. 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
3. 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
4. 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
5. 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。