设计模式初探-策略模式(STRATEGY)，别名政策(Policy)

策略模式(STRATEGY)，别名政策(Policy)，通过将一系列的算法封装成一个个的策略对象，使算法可以相互替换，并能独立于使用它们的客户而变化，属于对象行为型模式。软件开发过程中，通常要设计相应的算法，比如电子网站中经常有折扣活动，并且用户等级不同，享受的折扣也不一样。通过使用策略模式将折扣算法封装起来，不仅可以用于网商平台，还可以用于手持设备中折扣活动的实现。封装的特性确保了扩展算法和增加新算法的简便性。

一、使用场景

1、许多相关的类仅仅只是行为有异。通过继承方式也可以解决此问题，但继承方式会将行为硬编码到Context中，不利于Context的理解，扩展和维护。同时，继承方式也不支持动态改变算法。

2、需要定义一系列相关的算法，这些算法可能只是某个算法的不同变体。

3、避免将算法使用的数据和数据结构暴露给客户。

二、UML图

三、Java实现

[java]  view plain copy

1. package study.patterns.strategy;  
2. /** 
3.  * 策略模式：算法的封装与切换艺术 
4.  * @author qbg 
5.  */  
6. public class StrategyPattern {  
7.     public static void main(String[] args) {  
8.         SalaryManager manager = new SalaryManager();  
9.         Level level = new JuniorLevel();  
10.         manager.setLevel(level);  
11.         manager.getSalary();  
12.         System.out.println("=========================");  
13.         level = new IntermediateLevel();  
14.         manager.setLevel(level);  
15.         manager.getSalary();  
16.         System.out.println("=========================");  
17.         level = new SeinorLevel();  
18.         manager.setLevel(level);  
19.         manager.getSalary();  
20.     }  
21. }  
22. /** 
23.  * 环境类Context：薪资管理系统，根据人员资历划分为不同薪资等级，每个薪资等级的计算方式不同。 
24.  */  
25. class SalaryManager{  
26.     private Level level;  
27.   
28.     public Level getLevel() {  
29.         return level;  
30.     }  
31.   
32.     public void setLevel(Level level) {  
33.         this.level = level;  
34.     }  
35.       
36.     public int getSalary(){  
37.         return level.calculate();  
38.     }  
39. }  
40. /** 
41.  * 抽象策略类：薪资等级抽象接口 
42.  */  
43. interface Level{  
44.     public int calculate();  
45. }  
46. /** 
47.  * 具体策略类：初级，12*5000(基本工资)+12*300(餐补) 
48.  */  
49. class JuniorLevel implements Level{  
50.     @Override  
51.     public int calculate() {  
52.         int salary = 12*5000 + 12*300;  
53.         System.out.println("等级：初级 ==== 年薪:"+salary);  
54.         return salary;  
55.     }  
56. }  
57. /** 
58.  * 具体策略类：中级，14*10000(基本工资)+14*300(餐补)+5000(奖金) 
59.  */  
60. class IntermediateLevel implements Level{  
61.     @Override  
62.     public int calculate() {  
63.         int salary = 14*10000 + 14*300 + 5000;  
64.         System.out.println("等级：中级 ==== 年薪:"+salary);  
65.         return salary;  
66.     }  
67. }  
68. /** 
69.  * 具体策略类：高级，16*20000(基本工资)+16*300(餐补)+20000(奖金)  
70.  */  
71. class SeinorLevel implements Level{  
72.     @Override  
73.     public int calculate() {  
74.         int salary = 16*20000 + 16*300 + 20000;  
75.         System.out.println("等级：高级 ==== 年薪:"+salary);  
76.         return salary;  
77.     }  
78. }  

运行结果：

[plain]  view plain copy

1. 等级：初级 ==== 年薪:63600  
2. =========================  
3. 等级：中级 ==== 年薪:149200  
4. =========================  
5. 等级：高级 ==== 年薪:344800  

四、模式优缺点

优点：

1、定义可复用的相关算法系列。Strategy类层次为Context定义了一系列可供重用的算法或行为。

2、提供一个替代继承的方法。继承通过生成Context的子类提供了另一种支持多种算法或行为的方法。但继承方式是通过将算法或行为硬编码到Context，不仅不利于算法的复用或行为的动态切换，还会造成Context难以理解，维护和扩展。而策略模式将算法封装到独立的Strategy类中，这些类可以独立于Context而变化，这样算法更容易切换，系统更容易理解和扩展。

3、消除了一些条件语句。对于复杂的业务逻辑，使用Strategy类代替if-else判断可以使类设计的更清晰，更容易理解。

缺点：

1、客户为选择合适的策略必须了解不同的策略实现。这意味着客户必须知道所有算法或行为的区别。换言之，策略模式适用于客户知道所有算法或行为的情况。

2、Strategy和Context之间的通信开销。Context有时传递的数据对于Strategy是没用的，这样会造成不必要的资源消耗。

3、增加类和对象的数量。策略模式将不同的算法封装到相应的策略类中，这势必会增加类和对象的数量。

转载于：http://blog.csdn.net/qbg19881206/article/details/19244579