策略模式原理及例子代码

策略模式将行为和环境隔离开来，环境角色类负责维持和查询行为的类，各种类似的逻辑算法都在各个具体的策略类中进行实现，由于环境和行为隔离开来，所以行为的逻辑变更不会影响到环境和客户端。

如果要使用策略类，则必须先抽象出需要包装的逻辑算法，试图从环境中分隔开来。策略模式一般都是将一个系列的逻辑算法包装到一些列的策略类中，来作为一个抽象策略类的子类。

策略模式涉及到三个角色：

• 环境角色
• 抽象策略角色
• 具体策略角色

举一个简单的例子。

假设现在在开发一个养殖管理系统。该系统用来对养殖过程中的整个流程进行管理。其中的一个模块是关于禽类的喂养管理等。一个养殖专业户喂养了多种禽类（如兔子，鸡，猪），养殖人员每天都需要给他们喂食物。由于不同的禽类都吃不一样的东西，在这里，对于喂养（feed）这个动作，这个就是一个策略。这里只是简化说明，其中省略很多的逻辑方法等，只为了说明这个问题.
应用策略模式，对应的三个角色如下:
环境角色： 这里是feeder(饲养员)
抽象策略角色：这里是禽类的喂养 FowlFeed（）
具体策略角色： 针对不同的的宠物的喂养方法或者行为RabbitFeed,HenFeed,PigFeed 等

用代码实现如下：

环境角色类 Feeder：

Java代码

1. packagecom.longweir.strategy;
3. /*
4. 这里是环境角色Feeder
5. */
7. publicclassFeeder
8. {
9. privateFowlFeedfowlfeed;
11. publicvoidsetFowlFeed(FowlFeedfowlfeed){
12. this.fowlfeed=fowlfeed;
13. }
15. publicFowlFeedgetFowlFeed(){
16. returnfowlfeed;
17. }
19. //构造方法1
20. publicFeeder(){}
22. //构造方法2
23. publicFeeder(FowlFeedfowlfeed){
24. this.fowlfeed=fowlfeed;
25. }
27. //策略方法feed()
28. publicvoidfeedInterface(){
29. fowlfeed.feed();
30. }
32. //该类的其他的方法
34. }

package com.longweir.strategy; /* 这里是环境角色 Feeder */ public class Feeder { private FowlFeed fowlfeed; public void setFowlFeed(FowlFeed fowlfeed){ this.fowlfeed=fowlfeed; } public FowlFeed getFowlFeed(){ return fowlfeed; } //构造方法1 public Feeder(){} //构造方法2 public Feeder(FowlFeed fowlfeed){ this.fowlfeed=fowlfeed; } //策略方法 feed() public void feedInterface(){ fowlfeed.feed(); } //该类的其他的方法 }

抽象策略角色FowlFeed,这里使用接口代替，也可以使用抽象类

Java代码

1. /*
2. FowlFeed为抽象的策略类这里使用接口来描述
3. 其他的具体策略类必须实现这个接口中的feed()方法
4. */
5. packagecom.longweir.strategy;
7. interfaceFowlFeed
8. {
9. publicvoidfeed();
10. }

/* FowlFeed 为抽象的策略类 这里使用接口来描述 其他的具体策略类 必须实现这个接口中的feed() 方法 */ package com.longweir.strategy; interface FowlFeed { public void feed(); }

具体策略类，关于喂养兔子 RabbitFeed:

Java代码

1. packagecom.longweir.strategy;
2. /*
3. 具体的策略类--喂养兔子
4. */
6. publicclassRabbitFeedimplementsFowlFeed
7. {
8. //构造方法
9. publicRabbitFeed(){
11. }
13. //喂养兔子的策略方法,实现抽象策略中的方法
14. publicvoidfeed(){
15. System.out.println("喂兔子吃青菜和萝卜");
16. }
17. }

package com.longweir.strategy; /* 具体的策略类--喂养兔子 */ public class RabbitFeed implements FowlFeed { //构造方法 public RabbitFeed(){ } //喂养兔子的策略方法,实现抽象策略中的方法 public void feed(){ System.out.println("喂兔子吃青菜和萝卜"); } }

具体的策略类，关于喂养猪 PigFeed:

Java代码

1. packagecom.longweir.strategy;
2. /*
3. 具体的策略类--喂养猪的策略方法
4. */
5. publicclassPigFeedimplementsFowlFeed
6. {
7. publicPigFeed(){}
9. //喂养猪的策略方法,实现抽象策略中的方法
10. publicvoidfeed(){
11. System.out.println("喂猪吃糠和泔水");
12. }
13. }

package com.longweir.strategy; /* 具体的策略类--喂养猪的策略方法 */ public class PigFeed implements FowlFeed { public PigFeed(){} //喂养猪的策略方法,实现抽象策略中的方法 public void feed(){ System.out.println("喂猪吃糠和泔水"); } }

具体的策略类，关于喂养母鸡的策略方法 HenFeed

Java代码

1. packagecom.longweir.strategy;
3. //具体的策略角色--喂养母鸡
5. publicclassHenFeedimplementsFowlFeed
6. {
7. publicHenFeed(){
8. }
10. //喂养母鸡的策略方法
11. publicvoidfeed(){
12. System.out.println("喂母鸡吃谷物和米粒");
13. }
14. }

package com.longweir.strategy; //具体的策略角色--喂养母鸡 public class HenFeed implements FowlFeed { public HenFeed(){ } //喂养母鸡的策略方法 public void feed(){ System.out.println("喂母鸡吃谷物和米粒"); } }

以上都实现了三个角色的代码，我们编写一个客户端代码来测试下：

Java代码

1. /*------------------------------------------------------------------------------------*/
2. //客户端的调用示例
3. packagecom.longweir.strategy;
5. publicclassStrategy
6. {
7. publicstaticvoidmain(String[]args){
9. //实例化一个环境角色feeder
10. Feederfeeder=newFeeder(newRabbitFeed());
11. //喂养兔子
12. feeder.feedInterface();
14. //喂养猪
15. feeder.setFowlFeed(newPigFeed());
16. feeder.feedInterface();
18. //喂养母鸡
19. feeder.setFowlFeed(newHenFeed());
20. feeder.feedInterface();
21. }
22. }

/*------------------------------------------------------------------------------------*/ //客户端的调用示例 package com.longweir.strategy; public class Strategy { public static void main(String[] args){ //实例化一个环境角色feeder Feeder feeder=new Feeder(new RabbitFeed()); //喂养兔子 feeder.feedInterface(); //喂养猪 feeder.setFowlFeed(new PigFeed()); feeder.feedInterface(); //喂养母鸡 feeder.setFowlFeed(new HenFeed()); feeder.feedInterface(); } }

执行结果是：

Java代码

1. 喂兔子吃青菜和萝卜
3. 喂猪吃糠和泔水
5. 喂母鸡吃谷物和米粒

喂兔子吃青菜和萝卜 喂猪吃糠和泔水 喂母鸡吃谷物和米粒

在客户端中，针对不同的具体策略类，环境角色执行了不同的策略方法。 当我们日后需要增加新的策略时，我们只需要新建一个具体的策略类来实现抽象策略接口即可。例如系统中，饲养员新饲养了禽类为山羊(Goat)

则代码日下：

Java代码

1. packagecom.longweir.strategy;
2. /*
3. 具体的策略角色类--喂养山羊的策略方法
4. */
5. publicclassGoatFeedimplementsFowlFeed
6. {
7. publicGoatFeed(){}
9. //喂养山羊的策略方法,实现抽象策略中的方法
10. publicvoidfeed(){
11. System.out.println("喂山羊吃青草");
12. }
13. }

package com.longweir.strategy; /* 具体的策略角色类--喂养山羊的策略方法 */ public class GoatFeed implements FowlFeed { public GoatFeed(){} //喂养山羊的策略方法,实现抽象策略中的方法 public void feed(){ System.out.println("喂山羊吃青草"); } }

然后我们的客户端中就可以很方便的调用，这样一来实现了系统的扩展。但是，很明显的是，如果重复使用策略，则不可行。重复的使用，我们可以使用装饰器模式来解决.