西北狼

-- 学而时习之,不亦乐乎!
  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

策略模式-2

Posted on 2010-07-01 21:36  西北老狼  阅读(143)  评论(0编辑  收藏  举报

作者: 云飞龙行 发表于 2010-06-23 21:07 原文链接 阅读: 877 评论: 5

2  解决方案

2.1  策略模式来解决

        用来解决上述问题的一个合理的解决方案就是策略模式。那么什么是策略模式呢?

(1)策略模式定义
         定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

(2)应用策略模式来解决的思路
        仔细分析上面的问题,先来把它抽象一下,各种计算报价的计算方式就好比是具体的算法,而使用这些计算方式来计算报价的程序,就相当于是使用算法的客户。
        再分析上面的实现方式,为什么会造成那些问题,根本原因,就在于算法和使用算法的客户是耦合的,甚至是密不可分的,在上面实现中,具体的算法和使用算法的客户是同一个类里面的不同方法。
        现在要解决那些问题,按照策略模式的方式,应该先把所有的计算方式独立出来,每个计算方式做成一个单独的算法类,从而形成一系列的算法,并且为这一系列算法定义一个公共的接口,这些算法实现是同一接口的不同实现,地位是平等的,可以相互替换。这样一来,要扩展新的算法就变成了增加一个新的算法实现类,要维护某个算法,也只是修改某个具体的算法实现即可,不会对其它代码造成影响。也就是说这样就解决了可维护、可扩展的问题。
        为了实现让算法能独立于使用它的客户,策略模式引入了一个上下文的对象,这个对象负责持有算法,但是不负责决定具体选用哪个算法,把选择算法的功能交给了客户,由客户选择好具体的算法后,设置到上下文对象里面,让上下文对象持有客户选择的算法,当客户通知上下文对象执行功能的时候,上下文对象会去转调具体的算法。这样一来,具体的算法和直接使用算法的客户是分离的。
        具体的算法和使用它的客户分离过后,使得算法可独立于使用它的客户而变化,并且能够动态的切换需要使用的算法,只要客户端动态的选择使用不同的算法,然后设置到上下文对象中去,实际调用的时候,就可以调用到不同的算法。


2.2  模式结构和说明

        策略模式的结构示意图如图1所示:


 

图1  策略模式结构示意图


Strategy:
        策略接口,用来约束一系列具体的策略算法。Context使用这个接口来调用具体的策略实现定义的算法。
ConcreteStrategy:
        具体的策略实现,也就是具体的算法实现。
Context:
        上下文,负责和具体的策略类交互,通常上下文会持有一个真正的策略实现,上下文还可以让具体的策略类来获取上下文的数据,甚至让具体的策略类来回调上下文的方法。


2.3  策略模式示例代码

(1)首先来看策略,也就是定义算法的接口,示例代码如下: 

/**

 * 策略,定义算法的接口

 */

public interface Strategy {

    /**

     * 某个算法的接口,可以有传入参数,也可以有返回值

     */

    public void algorithmInterface();

}

 

(2)该来看看具体的算法实现了,定义了三个,分别是ConcreteStrategyA、ConcreteStrategyB、ConcreteStrategyC,示例非常简单,由于没有具体算法的实现,三者也就是名称不同,示例代码如下: 

/**

 * 实现具体的算法

 */

public class ConcreteStrategyA implements Strategy {

    public void algorithmInterface() {

       //具体的算法实现   

    }

}

/**

 * 实现具体的算法

 */

public class ConcreteStrategyB implements Strategy {

    public void algorithmInterface() {

       //具体的算法实现   

    }

}

/**

 * 实现具体的算法

 */

public class ConcreteStrategyC implements Strategy {

    public void algorithmInterface() {

       //具体的算法实现   

    }

}

 

(3)再来看看上下文的实现,示例代码如下: 

/**

 * 上下文对象,通常会持有一个具体的策略对象

 */

public class Context {

    /**

     * 持有一个具体的策略对象

     */

    private Strategy strategy;

    /**

     * 构造方法,传入一个具体的策略对象

     * @param aStrategy 具体的策略对象

     */

    public Context(Strategy aStrategy) {

       this.strategy = aStrategy;

    }

    /**

     * 上下文对客户端提供的操作接口,可以有参数和返回值

     */

    public void contextInterface() {

       //通常会转调具体的策略对象进行算法运算

       strategy.algorithmInterface();

    }

}

 

 2.4  使用策略模式重写示例

        要使用策略模式来重写前面报价的示例,大致有如下改变:

  • 首先需要定义出算法的接口。
  • 然后把各种报价的计算方式单独出来,形成算法类。
  • 对于Price这个类,把它当做上下文,在计算报价的时候,不再需要判断,直接使用持有的具体算法进行运算即可。选择使用哪一个算法的功能挪出去,放到外部使用的客户端去。

        这个时候,程序的结构如图2所示:

 图2  使用策略模式实现示例的结构示意图

(1)先看策略接口,示例代码如下: 

/**

 * 策略,定义计算报价算法的接口

 */

public interface Strategy {

    /**

     * 计算应报的价格

     * @param goodsPrice 商品销售原价

     * @return 计算出来的,应该给客户报的价格

     */

    public double calcPrice(double goodsPrice);

}

 

(2)接下来看看具体的算法实现,不同的算法,实现也不一样,先看为新客户或者是普通客户计算应报的价格的实现,示例代码如下: 

/**

 * 具体算法实现,为新客户或者是普通客户计算应报的价格

 */

public class NormalCustomerStrategy implements Strategy{

    public double calcPrice(double goodsPrice) {

       System.out.println("对于新客户或者是普通客户,没有折扣");

       return goodsPrice;

    }

}

 

再看看为老客户计算应报的价格的实现,示例代码如下: 

/**

 * 具体算法实现,为老客户计算应报的价格

 */

public class OldCustomerStrategy implements Strategy{

    public double calcPrice(double goodsPrice) {

       System.out.println("对于老客户,统一折扣5%");

       return goodsPrice*(1-0.05);

    }

}

再看看为大客户计算应报的价格的实现,示例代码如下:  

/**

 * 具体算法实现,为大客户计算应报的价格

 */

public class LargeCustomerStrategy implements Strategy{

    public double calcPrice(double goodsPrice) {

       System.out.println("对于大客户,统一折扣10%");

       return goodsPrice*(1-0.1);

    }

}

 

(3)接下来看看上下文的实现,也就是原来的价格类,它的变化比较大,主要有:

  • 原来那些私有的,用来做不同计算的方法,已经去掉了,独立出去做成了算法类
  • 原来报价方法里面,对具体计算方式的判断,去掉了,让客户端来完成选择具体算法的功能
  • 新添加持有一个具体的算法实现,通过构造方法传入
  • 原来报价方法的实现,变化成了转调具体算法来实现

示例代码如下: 

/**

 * 价格管理,主要完成计算向客户所报价格的功能

 */

public class Price {

    /**

     * 持有一个具体的策略对象

     */

    private Strategy strategy = null;

    /**

     * 构造方法,传入一个具体的策略对象

     * @param aStrategy 具体的策略对象

     */

    public Price(Strategy aStrategy){

       this.strategy = aStrategy;

    }  

    /**

     * 报价,计算对客户的报价

     * @param goodsPrice 商品销售原价

     * @return 计算出来的,应该给客户报的价格

     */

    public double quote(double goodsPrice){

       return this.strategy.calcPrice(goodsPrice);

    }

}

(4)写个客户端来测试运行一下,好加深体会,示例代码如下:  

public class Client {

    public static void main(String[] args) {

       //1:选择并创建需要使用的策略对象

       Strategy strategy = new LargeCustomerStrategy ();

       //2:创建上下文

       Price ctx = new Price(strategy);

      

       //3:计算报价

       double quote = ctx.quote(1000);

       System.out.println("向客户报价:"+quote);

    }

}

       

        运行一下,看看效果。
        你可以修改使用不同的策略算法具体实现,现在用的是LargeCustomerStrategy,你可以尝试修改成其它两种实现,试试看,体会一下切换算法的容易性。

 

 

未完待续......

评论: 5 查看评论 发表评论

软件研发团队管理年会(上海,7.10-7.11)


最新新闻:
· WM机皇再发威 HD2运行Ubuntu视频展示(2010-07-01 21:12)
· 苹果推出手机广告平台iAds 获6000万美元订单(2010-07-01 21:09)
· Web 设计师的 50 个超便利工具(下)(2010-07-01 20:26)
· 市调公司:IE浏览器全球市占率终于开始回升(2010-07-01 20:24)
· 思科承诺将推出支持WiFi功能的Flip摄像头和可支持FaceTime的视频客户端软件(2010-07-01 20:23)

编辑推荐:领域驱动设计实践

网站导航:博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库