软件设计 策略模式 Strategy Pattern

作者：@kuaiquxie
作者的github：https://github.com/bitebita
本文为作者原创，如需转载，请注明出处：https://www.cnblogs.com/dzwj/p/17111702.html

---

准备一组算法，并将每一个算法封装起来，使得它们可以互换

代码实现：

生活中会面临很多抉择，每一个抉择会导向不同的结果，这时就会出现策略的选择。

程序中也是一样，而且更加复杂，生活中的抉择一般只有几个，但程序中可能有十多个甚至数十个，也就是我们常用的 if-else 或者 switch。当只有少量选择时，用这些没有问题，但一旦量比较大，代码的可读性和维护难度会迅速上升，这时候就建议使用策略模式了。

选择出行方式策略，代码实现：

1.接口
public interface TravelStrategy {
    void travel();
}
​
2.接口实现类
public class AirplaneStrategy implements TravelStrategy{
    @Override
    public void travel() {
        System.out.println("乘坐飞机旅游");
    }
}
​
public class BicycleStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("骑自行车旅游");
    }
}
​
public class TrainStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("坐火车旅游");
    }
}
​
3.选择策略类
public class Traveler {
    private TravelStrategy travelStrategy;
​
    public void setTravelStrategy(TravelStrategy travelStrategy) {
        this.travelStrategy = travelStrategy;
    }
​
    public void travel(){
        travelStrategy.travel();
    }
}
​
public class Client {
    public static void main(String[] args) {
        Traveler traveler = new Traveler();
​
        System.out.println("第一种策略：旅游开始！");
        TravelStrategy travelStrategy = new TrainStrategy();
        traveler.setTravelStrategy(travelStrategy);
        traveler.travel();
        System.out.println("**************************************************");
        
        System.out.println("第二种策略：旅游开始！");
        travelStrategy = new AirplaneStrategy();
        traveler.setTravelStrategy(travelStrategy);
        traveler.travel();
        System.out.println("**************************************************");
        
        System.out.println("第三种策略：旅游开始！");
        travelStrategy = new BicycleStrategy();
        traveler.setTravelStrategy(travelStrategy);
        traveler.travel();
        System.out.println("**************************************************");
    }
}

 

相加相减策略：

这里以相加相减策略来介绍策略模式：
​
1、定义策略
​
/**
 * 策略
 */
public interface Strategy {
    /**
     * 运行策略
     * @param num1 数字1
     * @param num2 数字2
     * @return 结果
     */
    int doStrategy(int num1, int num2);
}
2、定义相加策略
​
/**
 * 相加策略
 */
public class Add implements Strategy {
    @Override
    public int doStrategy(int num1, int num2) {
        return num1 + num2;
    }
}
3、定义相减策略
​
/**
 * 相减策略
 */
public class Subtract implements Strategy {
    @Override
    public int doStrategy(int num1, int num2) {
        return num1 - num2;
    }
}
4、定义上下文
​
/**
 * 上下文
 */
public class Context {
    private Strategy strategy;
    /**
     * 指定策略
     * @param strategy 策略
     */
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    /**
     * 执行策略
     * @param num1 数字1
     * @param num2 数字2
     * @return 结果
     */
    public int executeStrategy(int num1, int num2) {
        return this.strategy.doStrategy(num1, num2);
    }
}
5、调用
​
// 定义上下文
Context context = new Context();
// 设置相加策略
context.setStrategy(new Add());
System.out.println(context.executeStrategy(2, 1));
// 设置相减策略
context.setStrategy(new Subtract());
System.out.println(context.executeStrategy(2, 1));
​
输出结果为：
​
3
1
    
    
可以发现，按照对应的策略执行了运算，这就是策略模式的基本实现。

 

优缺点：

优点

1、算法可以自由切换。

2、避免使用多重条件判断。

3、扩展性良好。

缺点

1、策略类会增多。

2、所有策略类都需要对外暴露。

 

使用场景：

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

2、一个系统需要动态地在几种算法中选择一种。

3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

 

注意：

如果一个系统的策略多于 4 个，就需要考虑使用混合模式，解决策略类膨胀的问题。

 

策略模式 与 状态模式 的区别：

可以看出，策略模式的实现方式与前面讲的状态模式非常相似，但它们是有本质区别的。

主要体现在 转换是主动还是被动的。状态模式是由状态自动触发的，是被动的；策略模式是指定策略再执行的，是主动的。

状态模式：状态变（温度），行为就变（水的状态）      双向关联关系  
​
策略模式：状态自己指定（坐高铁），行为（回家，去学校）  单向关联关系