JAVA设计模式之策略模式的使用分析

  策略模 式是面向对象行为模式中的一种简单常用的设计模式。

首先看下GOF对策略模式的定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
策略模式的应用场景描述：
（1）实现某特定功能在不同的情况下采用不同的策略即算法，程序在运行时动态选择所要采用的策略。
（2）对客户端完全隐藏算法的具体实现细节。
（3）不同种算法之间可以彼此替换且完全独立。
策略模式的三种角色：
（1）抽象策略角色：通常由一个接口或者抽象类实现。
（2）具体策略角色：即包含具体策略的实现算法的类，程序中可能不止一个具体策略的角色，多个角色彼此独立。具体策略角色实现了抽象策略角色接口。
（3）环境角色：包含一个抽象策略角色的引用，通过set方法或构造方法完成策略对象的赋值，并提供给客户端一个策略调用的方法。

下面以超市打折促销的例子为大家描述下策略模式的具体使用方法。
超市打折促销有以下几种方式：
（1）对普通会员是商品原价。
（2）对中级会员是商品原价的85折。
（3）对高级会员是商品原价的75折。

了解了功能需求之后，用策略模式如何实现功能呢？下面给大家贴上范例代码。
 
1、第一个文件：价格计算抽象策略接口（ICalculationPriceStrategy.java）

1. /**
   
2.  * 价格计算策略接口 
   
3.  *
   
4.  */
   
5. public interface ICalculationPriceStrategy {
   
6. 
   
7.     /**
   
8.      * 价格计算方法
   
9.      * @return
   
10.      */
    
11.     public double calculationPrice(double price);
    
12. }
13. 2、第二个文件：普通会员价格计算的策略实现类（OrdinaryMemberStrategy.java）
14. /**
    
15.  * 普通会员价格计算策略实现类
    
16.  */
    
17. public class OrdinaryMemberStrategy implements ICalculationPriceStrategy {
    
18. 
    
19.     @Override
    
20.     public double calculationPrice(double price) {
    
21.         System.out.println("--采用普通会员价格计算策略--");
    
22.         return price;
    
23.     }
    
24. }
25. 3、第三个文件：中级会员价格计算的策略实现类（IntermediateMemberStrategy.java）
26. /**
    
27.  * 中级会员价格计算策略实现类
    
28.  */
    
29. public class IntermediateMemberStrategy implements ICalculationPriceStrategy {
    
30. 
    
31.     @Override
    
32.     public double calculationPrice(double price) {
    
33.         System.out.println("--采用中级会员价格计算策略--");
    
34.         return price * 0.85;
    
35.     }
    
36. 
    
37. }
38. 4、第四个文件：高级会员价格计算的策略实现类（SeniorMemberStrategy.java）
39. /**
    
40.  * 高级会员价格计算策略实现类
    
41.  */
    
42. public class SeniorMemberStrategy implements ICalculationPriceStrategy {
    
43. 
    
44.     @Override
    
45.     public double calculationPrice(double price) {
    
46.         System.out.println("--采用高级会员价格计算策略--");
    
47.         return price * 0.75;
    
48.     }
    
49. 
    
50. }
51. 5、第五个文件：环境角色（CalcPriceContext.java） 
52.  
53. /**
    
54.  * 价格计算环境角色对象
    
55.  */
    
56. public class CalcPriceContext {
    
57. 
    
58.     private ICalculationPriceStrategy calcPriceStrategy;
    
59.     
    
60.     public CalcPriceContext(ICalculationPriceStrategy calcPriceStrategy){
    
61.         this.calcPriceStrategy = calcPriceStrategy;
    
62.     }
    
63.     
    
64.     public double calculationPrice(double price){
    
65.         double finalPrice = 0;
    
66.         if(calcPriceStrategy != null){
    
67.             finalPrice = calcPriceStrategy.calculationPrice(price);
    
68.         }
    
69.         return finalPrice;
    
70.     }
    
71. }
72. 6、第六个文件：客户端测试方法（TestMain.java）
73. public class TestMain {
    
74. 
    
75.     public static void main(String [] args){
    
76.         double price = 368;
    
77.         double finalPrice = 0;
    
78.         CalcPriceContext context = null;
    
79.         context = new CalcPriceContext(new OrdinaryMemberStrategy());
    
80.         finalPrice = context.calculationPrice(price);
    
81.         System.out.println("普通会员价格为：" + finalPrice);
    
82.         context = new CalcPriceContext(new IntermediateMemberStrategy());
    
83.         finalPrice = context.calculationPrice(price);
    
84.         System.out.println("中级会员价格为：" + finalPrice);
    
85.         context = new CalcPriceContext(new SeniorMemberStrategy());
    
86.         finalPrice = context.calculationPrice(price);
    
87.         System.out.println("高级会员价格为：" + finalPrice);
    
88.     }
    
89. }
90.  
91.  看了上面的策略模式实现，让我们分析下策略模式的优点，首先考虑个问题如果以上功能不用策略模式实现，那我们的代码会是什么样子的呢？
92. public class CalcPriceMain {
    
93. 
    
94.     public static void main(String [] args){
    
95.         double price = 368;
    
96.         double finalPrice = 0;
    
97.         CalcPriceMain calcPriceMain = new CalcPriceMain();
    
98.         finalPrice = calcPriceMain.calculationPrice("ordinary",price);
    
99.         System.out.println("普通会员价格为：" + finalPrice);
    
100.         finalPrice = calcPriceMain.calculationPrice("intermediate",price);
     
101.         System.out.println("中级会员价格为：" + finalPrice);
     
102.         finalPrice = calcPriceMain.calculationPrice("senior",price);
     
103.         System.out.println("高级会员价格为：" + finalPrice);
     
104.     }
     
105.     
     
106.     /**
     
107.      * 价格计算逻辑处理
     
108.      * @param memberType
     
109.      * @param price
     
110.      * @return
     
111.      */
     
112.     public double calculationPrice(String memberType,double price){
     
113.         if("ordinary".equals(memberType)){
     
114.             return calcPriceForOrdinaryMember(price);
     
115.         }else if("intermediate".equals(memberType)){
     
116.             return calcPriceForIntermediateMember(price);
     
117.         }else if("senior".equals(memberType)){
     
118.             return calcPriceForSeniorMember(price);
     
119.         }
     
120.         return 0;
     
121.     }
     
122.     
     
123.     /**
     
124.      * 普通会员价格计算实现方法
     
125.      * @param price
     
126.      * @return
     
127.      */
     
128.     public double calcPriceForOrdinaryMember(double price){
     
129.         return price;
     
130.     }
     
131.     
     
132.     /**
     
133.      * 中级会员价格计算实现方法
     
134.      * @param price
     
135.      * @return
     
136.      */
     
137.     public double calcPriceForIntermediateMember(double price){
     
138.         return price * 0.85;
     
139.     }
     
140.     
     
141.     /**
     
142.      * 高级会员价格计算实现方法
     
143.      * @param price
     
144.      * @return
     
145.      */
     
146.     public double calcPriceForSeniorMember(double price){
     
147.         return price * 0.75;
     
148.     }
     
149.     
     
150. }
151. 代码对比可以知道传统的实现方式，将各种策略的实现全都耦合在一起非常不利于代码的扩展，如果要额外新增新的策略，则要更改现在的代码结构违背了程序设计的开闭原则。
     策略模式的优点如下：
     （1）策略模式提供了管理相关的算法族的方法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码移到父类里面，从而避免代码重复。
     （2）使用策略模式可以避免使用多重条件(if-else)语句。多重条件语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重条件语句里面不利于代码的扩展。
     （3）修改具体策略不影响客户端的调用。
     策略模式的缺点如下：
     （1）客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道算法或行为的情况。
     （2）由于策略模式把每个具体的策略实现都单独封装成为类，所以会增加系统需要维护的类的数量。
     （3）在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。这本身没有解除客户端需要选择判断的压力，而策略 模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化的减轻了客户端的压力。