策略模式原理及例子代码

 

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

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

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

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

举一个简单的例子。

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

用代码实现如下：

环境角色类 Feeder：

Java代码  

1. package com.longweir.strategy;   
2.   
3. /*  
4.   这里是环境角色 Feeder  
5. */  
6.   
7. public class Feeder   
8. {   
9.     private FowlFeed fowlfeed;   
10.   
11.     public void setFowlFeed(FowlFeed fowlfeed){   
12.        this.fowlfeed=fowlfeed;   
13.     }   
14.   
15.     public FowlFeed getFowlFeed(){   
16.        return fowlfeed;   
17.     }   
18.   
19.     //构造方法1   
20.     public Feeder(){}   
21.   
22.     //构造方法2   
23.     public Feeder(FowlFeed fowlfeed){   
24.         this.fowlfeed=fowlfeed;   
25.     }   
26.        
27.     //策略方法 feed()   
28.     public void feedInterface(){   
29.        fowlfeed.feed();   
30.     }   
31.   
32.     //该类的其他的方法   
33.   
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. package com.longweir.strategy;   
6.   
7. interface FowlFeed   
8. {   
9.     public void feed();   
10. }  

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

interface FowlFeed
{
	public void feed();
}

 

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

Java代码  

1. package com.longweir.strategy;   
2. /*  
3.    具体的策略类--喂养兔子  
4. */  
5.   
6. public class RabbitFeed implements FowlFeed   
7. {   
8.     //构造方法   
9.     public RabbitFeed(){   
10.             
11.     }   
12.   
13.     //喂养兔子的策略方法,实现抽象策略中的方法   
14.     public void feed(){   
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. package com.longweir.strategy;   
2. /*  
3. 具体的策略类--喂养猪的策略方法  
4. */  
5. public class PigFeed implements FowlFeed   
6. {   
7.     public PigFeed(){}   
8.   
9.     //喂养猪的策略方法,实现抽象策略中的方法   
10.     public void feed(){   
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. package com.longweir.strategy;   
2.   
3. //具体的策略角色--喂养母鸡   
4.   
5. public class HenFeed implements FowlFeed   
6. {   
7.     public HenFeed(){           
8.     }   
9.   
10.     //喂养母鸡的策略方法   
11.     public void feed(){   
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. package com.longweir.strategy;   
4.   
5. public class Strategy   
6. {   
7.     public static void main(String[] args){   
8.        
9.     //实例化一个环境角色feeder   
10.     Feeder feeder=new Feeder(new RabbitFeed());   
11.     //喂养兔子   
12.     feeder.feedInterface();   
13.   
14.     //喂养猪   
15.     feeder.setFowlFeed(new PigFeed());   
16.     feeder.feedInterface();   
17.   
18.     //喂养母鸡   
19.     feeder.setFowlFeed(new HenFeed());   
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. 喂兔子吃青菜和萝卜   
2.   
3. 喂猪吃糠和泔水   
4.   
5. 喂母鸡吃谷物和米粒  

喂兔子吃青菜和萝卜

喂猪吃糠和泔水

喂母鸡吃谷物和米粒

 

 

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

则代码日下：

Java代码  

1. package com.longweir.strategy;   
2. /*  
3. 具体的策略角色类--喂养山羊的策略方法  
4. */  
5. public class GoatFeed implements FowlFeed   
6. {   
7.     public GoatFeed(){}   
8.   
9.     //喂养山羊的策略方法,实现抽象策略中的方法   
10.     public void feed(){   
11.         System.out.println("喂山羊吃青草");   
12.     }   
13. }  

package com.longweir.strategy;
/*
具体的策略角色类--喂养山羊的策略方法
*/
public class GoatFeed implements FowlFeed
{
	public GoatFeed(){}

	//喂养山羊的策略方法,实现抽象策略中的方法
	public void feed(){
	    System.out.println("喂山羊吃青草");
	}
}

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