第3章 策略模式
策略模式详解
策略模式详解
策略模式是一种行为型设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以相互替换。
策略模式使得算法可以独立于使用它的客户端而变化。
策略模式适用于那些需要使用多种算法的问题。
由于每种算法都有其特殊的用途，因此客户端需要根据当前的情况选择最合适的算法。
在这种情况下，策略模式提供了一个灵活且可扩展的框架，使得算法的选择和使用变得简单且易于维护。
在策略模式中，有三个主要的参与者：
1. Strategy：策略接口定义了所有算法的公共接口，客户端通过这个接口来调用算法。
这样，客户端就不需要关心具体的算法实现，只需要根据需要选择相应的策略即可。
2. ConcreteStrategy：具体策略类实现了策略接口，并提供了具体的算法实现。
每个具体策略类都代表了一种特定的算法。
3. Context：上下文对象负责维护策略对象的实例，并根据需要切换不同的策略。
上下文对象通常会根据客户端的请求选择合适的策略对象，并将这个策略对象传递给客户端。
策略模式的优点在于它能够提供一种灵活且可扩展的解决方案，使得算法的选择和使用变得简单且易于维护。
由于策略对象是独立的，因此可以很容易地添加新的策略，而不需要修改现有的代码。
此外，策略模式还可以提供一种替换算法的方式，使得系统能够根据需要进
行动态的调整。
总之，策略模式是一种非常有用的行为型设计模式，它能够提供一种灵活且可扩展的解决方案来解决那些需要使用多种算法的问题。
Java的策略模式
策略模式的最佳 实践
谨慎选择使用场景
策略模式适用于复杂多变的业务场景 策略模式可以降低代码的耦合度，提高代码的可维护性和可扩展性 策略模式可以避免使用大量的if-else语句，使代码更加清晰和简洁 策略模式可以方便地添加新的策略，而不需要修改原有的代码
合理设计策略接口和具体策略类
策略接口：定义策略的公共方法，以 便于具体策略类实现
策略模式需要为每个 策略创建一个单独的 对象，这可能会导致 资源消耗增加。
策略模式需要客户端 了解所有的策略，以 便选择合适的策略， 这可能会导致客户端 代码复杂化。
策略模式可能会导致 类爆炸，因为每个策 略都需要一个单独的 类来实现。
需要谨慎处理线程安全问题
策略模式可能会导致线程安全问题 策略模式中的策略对象可能会被多个线程共享 如果策略对象不是线程安全的，可的线程安全
调用上下文类中的方法，实现策略模式的功能
测试和验证策略模式的正确性
编写测试用例：根 据策略模式的特点 ，设计相应的测试 用例
运行测试：执行测 试用例，观察程序 运行结果
分析测试结果：根 据测试结果，分析 策略模式的实现是 否正确
调整和优化：根据 测试结果，对策略 模式的实现进行优 化和调整，以提高 程序的性能和稳定 性
Java的策略模式
作者：
目录
添加目录标题 01 策略模式概述 02 策略模式的优点 03
策略模式的缺点 04 策略模式的实现示例 05 策略模式的最佳实践 06
添加章节标题
策略模式概述
定义和用途
策略模式将算法封装 在单独的类中，使得 算法可以独立于使用 它的对象
策略模式是一种设计 模式，用于解决对象 行为变化问题
策略模式可以减少代码之间的耦合度，使得代码更加灵活和易于维护。 策略模式可以方便地添加新的策略，而不需要修改原有的代码。 策略模式可以提高代码的可读性和可维护性，使得代码更加清晰和易于理解。
策略模式及优化
策略模式及优化（本⽂参考了《设计模式之禅》⼀书）何时应该使⽤策略模式？当我们的程序中某些算法需要⾃由切换时⾮常适合使⽤策略模式。
⽐如我们写⼀个计算机程序，⾥⾯必然有加减乘除等等算法，并且这些算法还应该根据客户点击什么运算符号来⾃由切换。
我们就以加减算法的实现为例说明如何使⽤策略模式来优化代码，以及如何优化策略模式。
我们实现计算机的加减算法，最简单的写法应该是这样算法类public class Calculator {public final static String ADD = "+";public final static String SUB = "-";//算法加private static int add(int a,int b){return a + b;}//算法减private static int sub(int a,int b){return a - b;}//计算public static int exe(int a,int b,String exeMethod){switch (exeMethod) {case ADD:return add(a,b);case SUB:return sub(a,b);default:return0;}}}场景类public class Context {public static void main(String[] args) {int a = Calculator.exe(3, 4, Calculator.ADD); //加法运算int b = Calculator.exe(3, 4, Calculator.SUB); //减法运算System.out.println(a+""+b);}}现在我们引⼊策略模式先定义⼀个抽象接⼝public interface Strategy {int exe(int a,int b);}再实现加和减算法//加法public class CalculatorAdd implements Strategy{@Overridepublic int exe(int a, int b) {return a + b;}}//减法public class CalculatorSub implements Strategy{@Overridepublic int exe(int a, int b) {return a - b;}}可以看到，我们每个算法都继承了Strategy接⼝，并且实现的exe（）⽅法。
策略模式
策略模式（Strategy）●策略模式（Strategy Pattern）中体现了两个非常基本的面向对象设计的原则------------封装变化的概念------------变成中使用接口，而不是对接口的实现●面向接口的编程1.策略模式的定义1）定义一组算法，将每个算法都封装起来，并且使它们之间可以互换2）策略模式是这些算法在客户端调用它们的时候能够互不影响的变化2.策略模式的意义1）策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各个部分之间是弱连接的关系2）弱连接的特性使软件具有更强的可扩展性，易于维护；更重要的是：它大大提高了软件的可重用性3.策略模式的组成1）抽象策略角色：策略类，通常由一个接口或者抽象类实现，比如：Comparator 2）具体策略角色：包装了相关的算法和行为，比如接口的多个实现类3）环境角色：持有一个策略类的引用，最终给客户端调用的，比如：TreeSet，TreeMap4.策略模式的实现1）策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换2）策略模式使得算法可以在不影响到客户端的情况下发生变化。
使用策略模式可以把行为和环境分割开来3）环境类负责维持和查询行为类，各种算法则在具体策略中提供。
由于算法和环境独立开来，算法的修改都不会影响环境和客户端5.策略模式的编写步骤1）对策略对象定义一个公共接口（抽象策略角色）2）编写具体策略类，该类实现了上面的公共接口3）在使用具体策略对象的类中保存一个对抽象策略对象的引用（环境角色）4）在使用策略对象的类中，实现对策略对象的set和get方法（注入）或者使用构造方法完成赋值（客户端）6.参看JDK Collections类的源代码7.策略模式的缺点1）客户端必须知道所有的策略类，并自行决定使用哪一个策略类2）造成很多的策略类8.解决方法采用工厂方法（一种设计模式）。
策略模式以及策略模式与模板方法的结合
策略模式以及策略模式与模板⽅法的结合
在上⼀篇中我提到了⽤模板⽅法模式来重构以前写过的代码，在看到的留⾔后，我重新审视了⼀下⾃⼰的代码，到底⽤策略模式呢，还是模板⽅法呢？她们之间有没有共性可以抽取出来？
从策略模式的定义中可以看出，策略模式是对⼀组相似算法的包装，使得算法的实现与算法使⽤环境相隔离，在⽗类中提供算法的统⼀接⼝以供环境对象Context调⽤，以最瘦⼩的策略模式实现来说实际上是不满⾜我的需求的，因为我的算法中还包含更多的⼦操作、⼦流程，⽽这些流程⼜很相象，她们的调⽤逻辑框架也是相象的，怎么办？把这些逻辑直接写在Common接⼝中？重构逻辑？将⼦逻辑独⽴出来给出统⼀定义并由⼦类实现？呵呵！越说越象Template Pattern了。
那么我们就把中的代码重新构造⼀下：
实际上从代码中可以看出，从整体结构上讲应该算是策略模式的应⽤，实现了策略实现与环境的分离，由环境决定采⽤什么策略（当然这也是策略模式的⼀个缺点，环境必须知道所有的策略，并知道应该⽤什么策略），但从策略的统⼀接⼝来说⼜可以说是⼀个模板⽅法，不知道把这个运⽤说成是策略模式和模板⽅法的结合是否牵强？
其实归根结底，在这两种模式的运⽤中最原始的东西是什么？正如在他的中所讲的⼀样，是多态的运⽤。
策略模式的实际应用
策略模式的实际应用策略模式是一种常用的设计模式，它可以帮助我们实现在不同情况下选择不同的策略来完成相同的任务。
在实际应用中，策略模式有着广泛的应用场景，例如在电商平台的促销活动中、交通运输系统中的路径规划、游戏中的角色选择等等。
在电商平台的促销活动中，策略模式可以帮助商家根据不同的促销策略来吸引消费者。
例如，商家可以根据消费者的购买历史、购买频率以及消费金额等信息，制定不同的促销策略。
对于新用户，可以提供首次购物的优惠券；对于老用户，可以根据其购买金额给予不同程度的折扣。
通过使用策略模式，商家可以根据不同的情况来选择合适的促销策略，以提高销售额和用户满意度。
在交通运输系统中的路径规划中，策略模式可以帮助用户选择最佳的出行方式。
例如，在一个城市中，用户想要从A地到达B地，可以有多种出行方式，如步行、公交、地铁、出租车等。
不同的出行方式有着不同的时间花费、费用和舒适度等因素。
通过使用策略模式，系统可以根据用户的出行需求和偏好，选择最佳的出行方式并提供最佳的路径规划。
在游戏中的角色选择中，策略模式可以帮助玩家根据不同的游戏情况选择最适合的角色。
例如，在一款多人在线游戏中，不同的角色具有不同的技能、属性和特点，玩家可以根据自己的游戏风格和战术选择合适的角色。
某些角色可能适合近战战斗，某些角色可能适合远程攻击，而某些角色则可能适合辅助和治疗。
通过使用策略模式，玩家可以根据游戏情况和自己的游戏风格选择最佳的角色，以提高游戏体验和胜率。
除了以上应用场景，策略模式还可以应用于许多其他领域，如金融投资中的资产配置、机器人控制中的路径规划、智能家居中的节能调控等等。
通过使用策略模式，我们可以根据不同的情况和需求选择最佳的策略，从而提高系统的灵活性、可扩展性和可维护性。
总结起来，策略模式是一种非常实用的设计模式，它可以帮助我们在不同情况下选择最佳的策略来完成相同的任务。
在电商平台的促销活动、交通运输系统的路径规划、游戏中的角色选择等实际应用场景中，策略模式都发挥了重要的作用。
策略模式之两型--动态策略模式和静态策略模式
策略模式之两型--动态策略模式和静态策略模式策略模式⼀般是反应⾯向对象语⾔的多态特性，即可在运⾏时更改或选择不同的策略，典型的使⽤⽅式如下：class Strategy{public:Strategy() {}virtual ~Strategy() {}virtual int stopTask() = 0;};//策略Aclass Strategy_A : public Strategy{public:Strategy_A(): Strategy() {}~Strategy_A() {}//virtualint stopTask(){//do your strategy-A}};//策略Bclass Strategy_B : public Strategy{public:Strategy_B(): Strategy() {}~Strategy_B() {}//virtualint stopTask(){//do your strategy-B}};//使⽤时，你可以根据情况或条件（变量），让⽗对象指针指向⼀个实际构造的⼦对象Strategy* pOptionChose = new Strategy_B(); //遇到其他情况，你也可以指向⼀个new Strategy_A()-------------------------------------------------以上就是⼀般的策略模式的⽤法，可以称之为动态策略模式；实际上C++也可以⽤模板来实现，或称之为静态策略模式，这样实现的策略模式有编译期特性，即⼀经编译即固化了策略，特别适⽤于⾯向不同的客户做定制化⽅案的情形。
其⽤法如下：class StrategyA{public:void fun_1(){//do your strategy-A's fun_1}//....void fun_n(){//do your strategy-A's fun_n}};class StrategyB{public:void fun_1(){//do your strategy-B's fun_1}//...void fun_n(){//do your strategy-B's fun_n}};template<class T>class Context{public:void fun_1(){strategy.fun_1();}//...void fun_n(){strategy.fun_n();}private:T strategy;};如上所⽰，类StrategyA和StrategyB除了有同样的fun_1()到fun_n()这n个同名的⽅法外，并没有其他关系；模板类Context<T>中也有上述n个同名⽅法，实际使⽤时，只有根据情况具象化⼀个⾃⼰想要的⼀个策略实例即可，⽐如Context<StrategyA> intance;然后让实例intance调⽤任何想要的⽅法就可以了，⽐如intance.fun_1();就是执⾏类StrategyA中的fun_1()⽅法。
策略模式与简单工厂模式的结合使用
策略模式与简单⼯⼚模式的结合使⽤ Java设计模式中的策略模式（Strategy Patten）定义了⼀组算法，将每个算法都封装起来，并且可使它们之间可以相互替换，在客户端调⽤它们时可以互不影响。
策略模式主要由三个⾓⾊组成1、抽象策略⾓⾊：通常是⼀个接⼝或抽象类实现，我们的具体策略类就是继承或实现这个抽象⾓⾊。
2、具体策略⾓⾊：我们在这些类中写策略和算法，继承或实现抽象策略⾓⾊。
3、环境⾓⾊：环境⾓⾊中拥有⼀个抽象策略⾓⾊的引⽤，供客户端调⽤，该⾓⾊把客户端跟策略类的实现分离。
从上⾯的三个策略模式的⾓⾊中，我们就⼤概可以知道策略模式的编写步骤,这⾥以实现简单的四则运算为例。
1、定义抽象策略⾓⾊，也就是定义⼀个公共的抽象类（也可以是接⼝）1package strategy;2/**3 *4 * @author CIACs5 *定义抽象策略⾓⾊6*/7public abstract class Strategy {8//定义抽象策略的⽅法9public abstract int strategy(int a,int b);1011 }2、编写策略类，该类实现上⾯定义的抽象类1package strategy;2/**3 *4 * @author CIACs5 * AddStrategy6*/7public class AddStrategy extends Strategy {8//定义实现加法的策略⽅法9public int strategy(int a, int b)10 {11return a+b;12 }1314 }1package strategy;2/**3 *4 * @author CIACs5 * SubStrategy6*/7public class SubStrategy extends Strategy {8//定义减法的策略⽅法9public int strategy(int a, int b)10 {11return a-b;12 }1314 }1package strategy;2/**3 *4 * @author CIACs5 * MultiplyStrategy6*/7public class MultiplyStrategy extends Strategy {8//定义乘法的策略⽅法9public int strategy(int a,int b)10 {11return a*b;12 }13 }1package strategy;2/**3 *4 * @author CIACs5 * DivStrategy6*/7public class DivStrategy extends Strategy {8//定义除法的策略⽅法，这⾥为了简单就不考虑除数为零的情况了 9public int strategy(int a,int b)10 {11return a/b;12 }13 }3、编写环境⾓⾊，其中持有⼀个抽象策略类的引⽤1package strategy;2/**3 *4 * @author CIACs5 * Context6*/7public class Context {8//持有抽象策略⾓⾊的引⽤，⽤于客户端调⽤9private Strategy strategy;10//获得策略类11public Strategy getStrategy() {12return strategy;13 }14//设置所需策略15public void setStrategy(Strategy strategy) {16this.strategy = strategy;1718 }19//根据设置的策略类返回对应的结果20public int getResult(int a,int b)21 {22return strategy.strategy(a, b);23 }2425 }4、编写客户端1package strategy;2/**3 *4 * @author CIACs5 * Client6*/7public class Client {8public static void main(String[] args) {910 Context context = new Context();1112int result;1314 context.setStrategy(new SubStrategy());1516 result = context.getResult(9, 3);1718 System.out.println("sub: "+result);1920 context.setStrategy(new AddStrategy());2122 result =context.getResult(9, 3);2324 System.out.println("add: "+result);2526 context.setStrategy(new DivStrategy());2728 result = context.getResult(9, 3);2930 System.out.println("div: "+result);3132 context.setStrategy(new MultiplyStrategy());3334 result = context.getResult(9, 3);3536 System.out.println("mul: "+result);37 }38 }输出结果：上⾯只是⽤到策略模式，下⾯加上简单⼯⼚模式⼯⼚类1package strategy;2/**3 *4 * @author CIACs5 * Factory6*/7public class Factory {8public Strategy createStrategy(String str)9 {10if("AddStrategy".equalsIgnoreCase(str))11 {12return new AddStrategy();13 }14else15if("SubStrategy".equalsIgnoreCase(str))16 {17return new SubStrategy();18 }19else20if("DivStrategy".equalsIgnoreCase(str))21 {22return new DivStrategy();23 }24else25if("MultiplyStrategy".equalsIgnoreCase(str))26 {27return new MultiplyStrategy();28 }29else30return null;31 }3233 }客户端类1package strategy;2/**3 *4 * @author CIACs5 * Client6*/7public class Client {8public static void main(String[] args) {910 Context context = new Context();11int result;12 Strategy strategy;13 Factory fac = new Factory();14 strategy = fac.createStrategy("AddStrategy");15 context.setStrategy(strategy);16 result = context.getResult(9, 3);17 System.out.println(result);18 }19 }输出结果：当然这⾥的⼯⼚类中的if-else的使⽤是不太好的，简单⼯⼚模式把⽣成策略类与客户端分离。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
策略模式
模式动机
除了提供专门的查找算法类之外，还可以在客户端程序中直接包含 算法代码，这种做法更不可取，将导致客户端程序庞大而且难以维 护，如果存在大量可供选择的算法时问题将变得更加严重。 为了解决这些问题，可以定义一些独立的类来封装不同的算法，每 一个类封装一个具体的算法，在这里，每一个封装算法的类我们都 可以称之为策略(Strategy)，为了保证这些策略的一致性，一般会 用一个抽象的策略类来做算法的定义，而具体每种算法则对应于一 个具体策略类。
MyEllipse
-PI:float=3.14f -aLong:int -bShort:int -x:int -y:int +MyEllipse(aLong:in t,bShort:int,x:int,y:int ) +area():float +perimeter():float +draw(g:Graphics):v oid +toString():String
策略模式
模式分析
不使用策略模式的代码：
public class Context { …… public void algorithm(String type) { ...... if(type == "strategyA") { //算法A } else if(type == "strategyB") { //算法B } else if(type == "strategyC") { //算法C } ...... } …… }
MyCircle
-PI:float=3.14f -radius:int -x:int -y:int +MyCircle(x:int,y: int,radius:int) +area():float +perimeter():float +draw(g:Graphics) :void +toString():String
策略模式
策略模式实例与解析
实例二：排序策略
ArrayHandler - sortObj : Sort + setSort (Sort sortObj) : void + sort (int arr[]) : int[] ... Sort
sortObj
+ sort (int arr[]) : int[] ...
策略模式
策略模式实例与解析<MyShape> +DrawShape() +addShape(shape:MyShap e):void +paintComponent(g:Gr aphics):void
MyShape +area():float +perimeter():float +draw(g:Graphics): void
策略模式
模式优缺点
策略模式的优点
• 策略模式提供了对“开闭原则”的完美支持，用户可以在不修 改原有系统的基础上选择算法或行为，也可以灵活地增加新的 算法或行为。 • 策略模式提供了管理相关的算法族的办法。
策略模式实例与解析
实例三：旅游出行策略
Person - strategy : TravelStrategy + setStrategy (TravelStrategy strategy) : void + travel () : void ... TravelStrategy
strategy
策略模式
模式结构
Context - strategy : Strategy + algorithm () ...
...... strategy.algorithm(); ...... strategy
Strategy {abstract} + algorithm () ...
ConcreteStrategyA + algorithm () ...
策略模式
策略模式实例与解析
实例一：折扣策略
假设现在要设计一个贩卖各类书籍的电子商务网站的购物车系统。 一个最简单的情况就是把所有货品的单价乘上数量，但是实际情况 肯定比这要复杂。比如，本网站可能对所有的高级会员提供每本 20%的促销折扣；对中级会员提供每本10%的促销折扣；对初级 会员没有折扣。 • 根据描述，折扣是根据以下的几个算法中的一个进行的： • 算法一：对初级会员没有折扣。 • 算法二：对中级会员提供10%的促销折扣。 • 算法三：对高级会员提供20%的促销折扣。
策略模式
策略模式实例与解析
实例四：绘制图形策略 • 请使用策略模式实现下列编程要求：已知几何形状家族有圆形、 矩形、椭圆形、三角形等形状。请用Java语言定义一个抽象类 MyShape表示形状这样概念， • MyShape抽象类中提供了计算面积、周长、显示形状信息的抽 象方法，然后分别 • 定义它的子类MyCircle（圆形）、MyRectangle（矩形）、 MyEllipse（椭圆形）、 • MyTriangle（三角形）等特定几何形状。并绘制这些定义的几 何家族的所有形状。
策略模式
模式动机
策略模式
模式动机
在软件系统中，有许多算法可以实现某一功能，如查找、排序等， 一种常用的方法是硬编码(Hard Coding)在一个类中，如需要提供 多种查找算法，可以将这些算法写到一个类中，在该类中提供多个 方法，每一个方法对应一个具体的查找算法；当然也可以将这些查 找算法封装在一个统一的方法中，通过if…else…等条件判断语句 来进行选择。这两种实现方法我们都可以称之为硬编码，如果需要 增加一种新的查找算法，需要修改封装算法类的源代码；更换查找 算法，也需要修改客户端调用代码。在这个算法类中封装了大量查 找算法，该类代码将较复杂，维护较为困难。
策略模式
模式分析
在策略模式中，应当由客户端自己决定在什么情况下使用什么 具体策略角色。
策略模式仅仅封装算法，提供新算法插入到已有系统中，以及 老算法从系统中“退休”的方便，策略模式并不决定在何时使 用何种算法，算法的选择由客户端来决定。这在一定程度上提 高了系统的灵活性，但是客户端需要理解所有具体策略类之间 的区别，以便选择合适的算法，这也是策略模式的缺点之一， 在一定程度上增加了客户端的使用难度。
策略模式
模式分析
客户端代码片段：
……
Context context = new Context();
AbstractStrategy strategy; strategy = new ConcreteStrategyA(); context.setStrategy(strategy); context.algorithm(); ……
BubbleSort + sort (int arr[]) : int[] ... SelectionSort + sort (int arr[]) : int[] ...
InsertionSort + sort (int arr[]) : int[] ...
策略模式
策略模式实例与解析
实例二：排序策略
第 3章
策略模式
本章教学内容
策略模式
模式动机与定义 模式结构与分析 模式实例与解析 模式效果与应用
策略模式
模式动机
完成一项任务，往往可以有多种不同的方式，每一种方 式称为一个策略，我们可以根据环境或者条件的不同选 择不同的策略来完成该项任务。 在软件开发中也常常遇到类似的情况，实现某一个功能 有多个途径，此时可以使用一种设计模式来使得系统可 以灵活地选择解决途径，也能够方便地增加新的解决途 径。
ConcreteStrategyB + algorithm () ...
策略模式
模式结构
策略模式包含如下角色： • Context: 环境类 • Strategy: 抽象策略类 • ConcreteStrategy: 具体策略类
策略模式
模式分析
策略模式是一个比较容易理解和使用的设计模式，策 略模式是对算法的封装，它把算法的责任和算法本身 分割开，委派给不同的对象管理。策略模式通常把一 个系列的算法封装到一系列的策略类里面，作为一个 抽象策略类的子类。用一句话来说，就是“准备一组 算法，并将每一个算法封装起来，使得它们可以互 换”。
策略模式
模式定义
策略模式(Strategy Pattern)：定义一系列算法，将每 一个算法封装起来，并让它们可以相互替换。策略模式 让算法独立于使用它的客户而变化，也称为政策模式 (Policy)。策略模式是一种对象行为型模式。
策略模式
模式定义
Strategy Pattern: Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it. Frequency of use: medium high
策略模式
策略模式实例与解析
策略模式
策略模式实例与解析
实例二：排序策略 • 某系统提供了一个用于对数组数据进行操作的类，该 类封装了对数组的常见操作，如查找数组元素、对数 组元素进行排序等。现以排序操作为例，使用策略模 式设计该数组操作类，使得客户端可以动态地更换排 序算法，可以根据需要选择冒泡排序或选择排序或插 入排序，也能够灵活地增加新的排序算法。
+ travel () : void ...
strategy.travel();