策略模式(Strategy Pattern)

定义

策略模式定义了一系列性质相同的算法,并将每一个算法封装起来,而且使它们还可以相互替换。

使用场景

  • 针对同一类型问题的多种处理方式,仅仅是具体行为上有所差别时。

  • 需要安全地封装多种同一类型的操作时。

  • 出现同一抽象类有多个子类,而又需要使用if-else或switch-case来选择具体子类时。

优缺点

优点:

  • 结构清晰明了、使用简单直观。

  • 耦合度相对而言较低,扩展维护方便。

  • 操作封装更为彻底,数据更为安全。

缺点:

  • 随着策略的增加,子类会变得繁多。

UML类图

策略模式

  • Context:用来操作策略的上下文环境。

  • Strategy:策略的抽象基类。

  • ConcreteStrategyA、ConcreteStrategyB:具体的策略实现。

策略模式的常见实现

策略模式的常见实现方式有:

  • 将所有算法封装在一个统一的方法中,通过if-else或switch-case等条件判断来选择具体的算法。调用者传入指定的策略类型来最终执行对应的算法。

  • 将所有算法封装在一个类中,每一个方法对应一个具体的算法。调用者根据策略类型来调用对应的方法。

  • 规范的策略模式,一个策略抽象基类,每个算法有其单独的策略实现类。调用者通过注入不同的策略实现类对象来实现策略的动态替换。

前两种方式被称为硬编码方式,其违反了OCP、单一职责等设计模式原则,而且会越来越臃肿,导致维护成本很高。而第三种方式符合设计模式思想,其可扩展性、可维护性很高。

示例:利用前两种方式实现的“计算乘坐不同交通工具的成本”。

public class PriceCalculator {
    
    public static final int BUS = 1;
    public static final int SUBWAY = 2;
    
    private int busPrice(int km) {
        return 2;
    }
    
    private int subwayPrice(int km) {
        if(km < 6) {
            return 3;
        } else if(km > 6 && km < 12) {
            return 4;
        } else {
            return 5;
        }
    }
    
    public int calculatePrice(int km, int type) {
        if(type == BUS) {
            return busPrice(km);
        } else if(type == SUBWAY) {
            return subwayPrice(km);
        }
        return 0;
    }
}
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
27
28
PriceCalculator calculator = new PriceCalculator();
// 巴士
calculator.calculatePrice(20, PriceCalculator.BUS);
// 地铁
calculator.calculatePrice(20, PriceCalculator.SUBWAY);
1
2
3
4
5

示例:利用规范的策略模式实现的“计算乘坐不同交通工具的成本”。

public interface CalculateStrategy {
    int calculatePrice(int km);
}
1
2
3
public class BusStrategy implements CalculateStrategy {
    
    @Override
    public int calculatePrice(int km) {
        return 2;
    }
}
1
2
3
4
5
6
7
public class SubwayStrategy implements CalculateStrategy {
    
    @Override
    public int calculatePrice(int km) {
        if(km < 6) {
            return 3;
        } else if(km > 6 && km < 12) {
            return 4;
        } else {
            return 5;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class PriceCalculator {
    
    CalculateStrategy mStrategy;
    
    public void setStrategy(CalculateStrategy strategy) {
        mStrategy = strategy;
    }
    
    public int calculatePrice(int km) {
        if(mStrategy != null) {
            return mStrategy.calculatePrice(km);
        }
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

PriceCalculator calculator = new PriceCalculator();
// 巴士
calculator.setStrategy(new BusStrategy()); 
int priceBus = calculator.calculatePrice(20);
// 地铁
calculator.setStrategy(new SubwayStrategy()); 
int priceSubway = calculator.calculatePrice(20);
1
2
3
4
5
6
7
8