设计模式

策略模式是面向对象行为模式中的一种简单常用的设计模式。
首先看下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. }

2、第二个文件：普通会员价格计算的策略实现类（OrdinaryMemberStrategy.java）

点击(此处)折叠或打开

1. /**
   
2.  * 普通会员价格计算策略实现类
   
3.  */
   
4. public class OrdinaryMemberStrategy implements ICalculationPriceStrategy {
   
5. 
   
6.     @Override
   
7.     public double calculationPrice(double price) {
   
8.         System.out.println("--采用普通会员价格计算策略--");
   
9.         return price;
   
10.     }
    
11. }

3、第三个文件：中级会员价格计算的策略实现类（IntermediateMemberStrategy.java）

点击(此处)折叠或打开

1. /**
   
2.  * 中级会员价格计算策略实现类
   
3.  */
   
4. public class IntermediateMemberStrategy implements ICalculationPriceStrategy {
   
5. 
   
6.     @Override
   
7.     public double calculationPrice(double price) {
   
8.         System.out.println("--采用中级会员价格计算策略--");
   
9.         return price * 0.85;
   
10.     }
    
11. 
    
12. }

4、第四个文件：高级会员价格计算的策略实现类（SeniorMemberStrategy.java）

点击(此处)折叠或打开

1. /**
   
2.  * 高级会员价格计算策略实现类
   
3.  */
   
4. public class SeniorMemberStrategy implements ICalculationPriceStrategy {
   
5. 
   
6.     @Override
   
7.     public double calculationPrice(double price) {
   
8.         System.out.println("--采用高级会员价格计算策略--");
   
9.         return price * 0.75;
   
10.     }
    
11. 
    
12. }

5、第五个文件：环境角色（CalcPriceContext.java）

点击(此处)折叠或打开

1. /**
   
2.  * 价格计算环境角色对象
   
3.  */
   
4. public class CalcPriceContext {
   
5. 
   
6.     private ICalculationPriceStrategy calcPriceStrategy;
   
7.     
   
8.     public CalcPriceContext(ICalculationPriceStrategy calcPriceStrategy){
   
9.         this.calcPriceStrategy = calcPriceStrategy;
   
10.     }
    
11.     
    
12.     public double calculationPrice(double price){
    
13.         double finalPrice = 0;
    
14.         if(calcPriceStrategy != null){
    
15.             finalPrice = calcPriceStrategy.calculationPrice(price);
    
16.         }
    
17.         return finalPrice;
    
18.     }
    
19. }

6、第六个文件：客户端测试方法（TestMain.java）

点击(此处)折叠或打开

1. public class TestMain {
   
2. 
   
3.     public static void main(String [] args){
   
4.         double price = 368;
   
5.         double finalPrice = 0;
   
6.         CalcPriceContext context = null;
   
7.         context = new CalcPriceContext(new OrdinaryMemberStrategy());
   
8.         finalPrice = context.calculationPrice(price);
   
9.         System.out.println("普通会员价格为：" + finalPrice);
   
10.         context = new CalcPriceContext(new IntermediateMemberStrategy());
    
11.         finalPrice = context.calculationPrice(price);
    
12.         System.out.println("中级会员价格为：" + finalPrice);
    
13.         context = new CalcPriceContext(new SeniorMemberStrategy());
    
14.         finalPrice = context.calculationPrice(price);
    
15.         System.out.println("高级会员价格为：" + finalPrice);
    
16.     }
    
17. }

看了上面的策略模式实现，让我们分析下策略模式的优点，首先考虑个问题如果以上功能不用策略模式实现，那我们的代码会是什么样子的呢？

点击(此处)折叠或打开

1. public class CalcPriceMain {
   
2. 
   
3.     public static void main(String [] args){
   
4.         double price = 368;
   
5.         double finalPrice = 0;
   
6.         CalcPriceMain calcPriceMain = new CalcPriceMain();
   
7.         finalPrice = calcPriceMain.calculationPrice("ordinary",price);
   
8.         System.out.println("普通会员价格为：" + finalPrice);
   
9.         finalPrice = calcPriceMain.calculationPrice("intermediate",price);
   
10.         System.out.println("中级会员价格为：" + finalPrice);
    
11.         finalPrice = calcPriceMain.calculationPrice("senior",price);
    
12.         System.out.println("高级会员价格为：" + finalPrice);
    
13.     }
    
14.     
    
15.     /**
    
16.      * 价格计算逻辑处理
    
17.      * @param memberType
    
18.      * @param price
    
19.      * @return
    
20.      */
    
21.     public double calculationPrice(String memberType,double price){
    
22.         if("ordinary".equals(memberType)){
    
23.             return calcPriceForOrdinaryMember(price);
    
24.         }else if("intermediate".equals(memberType)){
    
25.             return calcPriceForIntermediateMember(price);
    
26.         }else if("senior".equals(memberType)){
    
27.             return calcPriceForSeniorMember(price);
    
28.         }
    
29.         return 0;
    
30.     }
    
31.     
    
32.     /**
    
33.      * 普通会员价格计算实现方法
    
34.      * @param price
    
35.      * @return
    
36.      */
    
37.     public double calcPriceForOrdinaryMember(double price){
    
38.         return price;
    
39.     }
    
40.     
    
41.     /**
    
42.      * 中级会员价格计算实现方法
    
43.      * @param price
    
44.      * @return
    
45.      */
    
46.     public double calcPriceForIntermediateMember(double price){
    
47.         return price * 0.85;
    
48.     }
    
49.     
    
50.     /**
    
51.      * 高级会员价格计算实现方法
    
52.      * @param price
    
53.      * @return
    
54.      */
    
55.     public double calcPriceForSeniorMember(double price){
    
56.         return price * 0.75;
    
57.     }
    
58.     
    
59. }

代码对比可以知道传统的实现方式，将各种策略的实现全都耦合在一起非常不利于代码的扩展，如果要额外新增新的策略，则要更改现在的代码结构违背了程序设计的开闭原则。
策略模式的优点如下：
（1）策略模式提供了管理相关的算法族的方法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码移到父类里面，从而避免代码重复。
（2）使用策略模式可以避免使用多重条件Context对象。这本身没有解除客户端需要选择判断的压力，而策略Context来承担，这就最大化的减轻了客户端的压力。