设计模式行为型模式
策略模式, 设计模式

策略模式

当实现某一个功能存在多种算法或者策略，可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。

如果使用多重条件转移语句实现即硬编码，不但使条件语句变得很复杂，而且增加、删除或更换算法要修改原代码，不易维护，违背开闭原则。采用策略模式就能很好解决该问题。

定义

定义一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。

实现

策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性。

Strategy抽象策略类定义一个公共接口，各种不同算法以不同方式实现该接口，环境角色使用该接口调用不同的算法

1
2
3
public interface Strategy {
    void strategy();
}

ConcreteStrategy具体策略类，实现了抽象策略定义的接口，提供具体的算法实现

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ConcreteStrategyA implements Strategy {
    @Override
    public void strategy() {
        System.out.println("具体策略A的策略方法被访问！");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void strategy() {
        System.out.println("具体策略B的策略方法被访问！");
    }
}

Context环境类，持有一个策略类的引用，最终给客户端调用

1
2
3
4
5
6
7
8
9
10
11
public class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void strategy() {
        this.strategy.strategy();
    }
}

客户端使用

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    Context c = new Context();
    Strategy strategyA = new ConcreteStrategyA();
    c.setStrategy(strategyA);
    c.strategy();
    Strategy strategyB = new ConcreteStrategyB();
    c.setStrategy(strategyB);
    c.strategy();
}

如果一个策略家族的具体策略数量超过4个，则需要考虑使用混合模式，解决策略类膨胀和对外暴露的问题。

优点

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

缺点

  • 会造成很多的策略类，增加维护难度
  • 所有策略类都需要对外暴露，上层模块必须知道有哪些策略，才能决定使用哪个策略，与迪米特法则相违
    背

应用

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

扩展

策略枚举，把原有定义在抽象策略中的方法移植到枚举中，每个枚举成员就成为一个具体策略 。略枚举是一个非常优秀和方便的模式，但是它受枚举类型的限制，每个枚举项都是public、final、static的，扩展性受到了一定的约束，因此在系统开发中，策略枚举一般担当不经常发生变化的角色。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public enum StrategyEnum {
    ADD("+"){
        public int exec(int a,int b){
            return a + b;
        }
    },
    SUB("-"){
        public int exec(int a,int b){
            return a - b;
        }
    };
    String value;
    private StrategyEnum(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]);
    System.out.println("运行结果为： " + StrategyEnum.ADD.exec(a, b));
}