策略模式
在策略模式（Strategy Pattern）中一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。
介绍
意图
将每个算法封装起来，使它们可以互换使用。
主要解决的问题
- 解决在多种相似算法存在时，使用条件语句（如if...else）导致的复杂性和难以维护的问题。
使用场景
- 当一个系统中有许多类，它们之间的区别仅在于它们的行为时。
实现方式
- 定义策略接口：所有策略类都将实现这个统一的接口。
- 创建具体策略类：每个策略类封装一个具体的算法或行为。
- 上下文类：包含一个策略对象的引用，并通过该引用调用策略。
关键代码
- 策略接口：规定了所有策略类必须实现的方法。
- 具体策略类：实现了策略接口，包含具体的算法实现。
应用实例
- 锦囊妙计：每个锦囊代表一个策略，包含不同的计策。
- 旅行方式选择：骑自行车、坐汽车等，每种方式都是一个可替换的策略。
- Java AWT的LayoutManager：不同的布局管理器实现了相同的接口，但提供了不同的布局算法。
优点
- 算法切换自由：可以在运行时根据需要切换算法。
- 避免多重条件判断：消除了复杂的条件语句。
- 扩展性好：新增算法只需新增一个策略类，无需修改现有代码。
缺点
- 策略类数量增多：每增加一个算法，就需要增加一个策略类。
- 所有策略类都需要暴露：策略类需要对外公开，以便可以被选择和使用。
使用建议
- 当系统中有多种算法或行为，且它们之间可以相互替换时，使用策略模式。
- 当系统需要动态选择算法时，策略模式是一个合适的选择。
注意事项
- 如果系统中策略类数量过多，考虑使用其他模式或设计技巧来解决类膨胀问题。
结构
策略模式包含以下几个核心角色：
- 环境（Context）：维护一个对策略对象的引用，负责将客户端请求委派给具体的策略对象执行。环境类可以通过依赖注入、简单工厂等方式来获取具体策略对象。
- 抽象策略（Abstract Strategy）：定义了策略对象的公共接口或抽象类，规定了具体策略类必须实现的方法。
- 具体策略（Concrete Strategy）：实现了抽象策略定义的接口或抽象类，包含了具体的算法实现。
策略模式通过将算法与使用算法的代码解耦，提供了一种动态选择不同算法的方法。客户端代码不需要知道具体的算法细节，而是通过调用环境类来使用所选择的策略。
实现
我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。
StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。
步骤 1
创建一个接口。
Strategy.java
public interface Strategy {
public int doOperation(int num1, int num2);
}
步骤 2
创建实现接口的实体类。
OperationAdd.java
public class OperationAdd implements Strategy{
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
OperationSubtract.java
public class OperationSubtract implements Strategy{
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
OperationMultiply.java
public class OperationMultiply implements Strategy{
@Override
public int doOperation(int num1, int num2) {
return num1 * num2;
}
}
步骤 3
创建 Context 类。
Context.java
public class Context {
private Strategy strategy;
public Context(Strategy strategy){
this.strategy = strategy;
}
public int executeStrategy(int num1, int num2){
return strategy.doOperation(num1, num2);
}
}
步骤 4
使用 Context 来查看当它改变策略 Strategy 时的行为变化。
StrategyPatternDemo.java
public class StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationSubtract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationMultiply());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
步骤 5
执行程序，输出结果：
10 + 5 = 15 10 - 5 = 5 10 * 5 = 50
xiaoxc
xia***@126.com
状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
xiaoxc
xia***@126.com
bruce
597***[email protected]
Context.java 文件改为：
public class Context { private Strategy strategy; public Context(){ } public SetStrategy(Strategy strategy){ this.strategy = strategy; } public int executeStrategy(int num1, int num2){ return strategy.doOperation(num1, num2); } }调用改为：
public static void main(String[] args) { Context context = new Context(); context.SetStrategy(new OperationAdd()); System.out.println("10 + 5 = " + context.executeStrategy(10, 5)); context.SetStrategy(new OperationSubtract()); System.out.println("10 - 5 = " + context.executeStrategy(10, 5)); context.SetStrategy(new OperationMultiply()); System.out.println("10 * 5 = " + context.executeStrategy(10, 5)); }这样就不用重复的 new Context 了。
bruce
597***[email protected]
Siskin.xu
sis***@sohu.com
Python 代码：
# Strategy Pattern with Python Code from abc import abstractmethod,ABCMeta # 创建一个接口 class Strategy(metaclass=ABCMeta): @abstractmethod def doOperation(self,inNum1,inNum2): pass # 创建实现接口的实体类 class OperationAdd(Strategy): def doOperation(self,inNum1,inMum2): return inNum1 + inMum2 class OperationSubtract(Strategy): def doOperation(self,inNum1,inNum2): return inNum1 - inNum2 class OperationMultiply(Strategy): def doOperation(self,inNum1,inNum2): return inNum1*inNum2 # 创建Context类 class Context(): _strategy = None def __init__(self,inStrategy): self._strategy = inStrategy def executeStrategy(self,inNum1,inNum2): return self._strategy.doOperation(inNum1,inNum2) # 调用输出 if __name__ == '__main__': aContext = Context(OperationAdd()) print("10 + 5 = {0}".format(aContext.executeStrategy(10,5))) aContext = Context(OperationSubtract()) print("10 - 5 = {0}".format(aContext.executeStrategy(10, 5))) aContext = Context(OperationMultiply()) print("10 * 5 = {0}".format(aContext.executeStrategy(10, 5)))Siskin.xu
sis***@sohu.com
泡水鱼干
626***[email protected]
// 策略 interface Strategy{ public function doOperation(int $num1,int $num2):int ; } // 加法 class OperationAdd implements Strategy{ public function doOperation(int $num1, int $num2): int { // TODO: Implement doOperation() method. return $num1 + $num2; } } // 减法 class OperationSubtract implements Strategy{ public function doOperation(int $num1, int $num2): int { // TODO: Implement doOperation() method. return $num1-$num2; } } // 乘法 class OperationMultiply implements Strategy{ public function doOperation(int $num1, int $num2): int { // TODO: Implement doOperation() method. return $num1 * $num2; } } class Context{ private $_strategy; public function set_strategy($_strategy) { $this->_strategy = $_strategy; } public function executeStrategy(int $num1,int $num2){ return $this->_strategy->doOperation($num1,$num2); } } class Demo{ public static function main(){ $context = new Context(); $context->set_strategy(new OperationAdd()); echo "10 + 5 = ".$context->executeStrategy(10,5).PHP_EOL; $context->set_strategy(new OperationSubtract()); echo "10 - 5 = ".$context->executeStrategy(10,5).PHP_EOL; $context->set_strategy(new OperationMultiply()); echo "10 * 5 = ".$context->executeStrategy(10,5).PHP_EOL; } } Demo::main();泡水鱼干
626***[email protected]
RUNOOB
429***[email protected]
通过使用策略模式，我们可以将排序算法的实现与使用算法的代码解耦。这样，当需要添加新的排序算法时，只需实现新的具体策略类，并在客户端代码中设置相应的策略即可，无需修改原有的排序代码。
策略模式可以提高代码的灵活性和可维护性，允许在运行时根据需要切换不同的算法。它还可以避免使用大量的条件语句，提高代码的可读性和可测试性。
下面是一个简单的策略模式示例，假设我们有一个排序算法的应用，根据用户的选择来选择不同的排序策略：
// 抽象策略 - 排序算法 interface SortingStrategy { void sort(int[] arr); } // 具体策略 - 快速排序 class QuickSort implements SortingStrategy { public void sort(int[] arr) { System.out.println("Using QuickSort"); // 快速排序的具体实现 } } // 具体策略 - 归并排序 class MergeSort implements SortingStrategy { public void sort(int[] arr) { System.out.println("Using MergeSort"); // 归并排序的具体实现 } } // 环境类 class SortingContext { private SortingStrategy strategy; public void setStrategy(SortingStrategy strategy) { this.strategy = strategy; } public void sortArray(int[] arr) { strategy.sort(arr); } } // 客户端代码 public class Main { public static void main(String[] args) { int[] arr = {5, 2, 8, 1, 9}; SortingContext context = new SortingContext(); context.setStrategy(new QuickSort()); context.sortArray(arr); // Output: Using QuickSort context.setStrategy(new MergeSort()); context.sortArray(arr); // Output: Using MergeSort } }在上面的示例中，我们定义了抽象策略接口 SortingStrategy，具体策略类 QuickSort 和 MergeSort，以及环境类 SortingContext。通过设置不同的排序策略，可以在运行时选择使用不同的排序算法。
RUNOOB
429***[email protected]