java设计模式——策略模式(Strategy Pattern)

原创 2016年08月31日 15:15:53
概述:
       在策略模式中,我们可以定义一些独立的类来封装不同的算法,每一个类封装一种具体的算法,在这里,每一个封装算法的类我们都可以称之为一种策略(Strategy),为了保证这些策略在使用时具有一致性,一般会提供一个抽象的策略类来做规则的定义,而每种算法则对应于一个具体策略类。
       策略模式的主要目的是将算法的定义与使用分开,也就是将算法的行为和环境分开,将算法的定义放在专门的策略类中,每一个策略类封装了一种实现算法,使用算法的环境类针对抽象策略类进行编程,符合“依赖倒转原则”。在出现新的算法时,只需要增加一个新的实现了抽象策略类的具体策略类即可。

定义:
       定义一系列算法,将每一个算法封装起来,并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化,也称为政策模式(Policy)。

结构:
  • Context(环境类):环境类是使用算法的角色,它在解决某个问题(即实现某个方法)时可以采用多种策略。在环境类中维持一个对抽象策略类的引用实例,用于定义所采用的策略。
  • Strategy(抽象策略类):它为所支持的算法声明了抽象方法,是所有策略类的父类,它可以是抽象类或具体类,也可以是接口。环境类通过抽象策略类中声明的方法在运行时调用具体策略类中实现的算法。
  • ConcreteStrategy(具体策略类):它实现了在抽象策略类中声明的算法,在运行时,具体策略类将覆盖在环境类中定义的抽象策略类对象,使用一种具体的算法实现某个业务处理。

UML图:

场景:做一个飞机模拟系统,该系统模拟各种飞机的起飞特征和飞行特征。

代码分析:
/**
 * Created by **
 * 飞机:相当于抽象策略类
 */
public abstract class Airplane {
    /**
     * 起飞特征
     */
    protected abstract void takeOffFeature();

    /**
     * 飞行特征
     */
    protected abstract void flightFeature();
}

/**
 * Created by **
 * 直升机:相当于一个具体的策略类,包含具体算法
 */
public class Helicopter extends Airplane {
    @Override
    protected void takeOffFeature() {
        LogFactory.log("直升机起飞特征:垂直起飞");
    }

    @Override
    protected void flightFeature() {
        LogFactory.log("直升机飞行特征:亚音速飞行");
    }
}

/**
 * Created by **
 * 客机:相当于一个具体的策略类,包含具体算法
 */
public class AirLiner extends Airplane {
    @Override
    protected void takeOffFeature() {
        LogFactory.log("客机起飞特征:长距离起飞");
    }

    @Override
    protected void flightFeature() {
        LogFactory.log("客机飞行特征:亚音速飞行");
    }
}

/**
 * Created by **
 * 歼击机:相当于一个具体的策略类,包含具体算法
 */
public class Fighter extends Airplane{
    @Override
    protected void takeOffFeature() {
        LogFactory.log("歼击机起飞特征:长距离起飞");
    }

    @Override
    protected void flightFeature() {
        LogFactory.log("歼击机飞行特征:超音速飞行");
    }
}

/**
 * Created by **
 * 定义一个环境类
 */
public class Context {
    // 持有一个飞机抽象类的引用
    private Airplane airplane;

    public void setAirplane(Airplane airplane) {
        this.airplane = airplane;
    }

    /**
     * 飞机起飞特征:相当于一个算法
     */
    public void takeOffFeature(){
        this.airplane.takeOffFeature();
    }

    /**
     * 飞机飞行特征:相当于一个算法
     */
    public void flightFeature(){
        this.airplane.flightFeature();
    }

}

客户端调用:
Context context = new Context();
context.setAirplane(new Helicopter());
context.takeOffFeature();
context.flightFeature();

context.setAirplane(new Fighter());
context.takeOffFeature();
context.flightFeature();

context.setAirplane(new AirLiner());
context.takeOffFeature();
context.flightFeature();

log输出:
08-26 11:04:58.100 5020-5020/? D/test: 直升机起飞特征:垂直起飞
08-26 11:04:58.100 5020-5020/? D/test: 直升机飞行特征:亚音速飞行
08-26 11:04:58.100 5020-5020/? D/test: 歼击机起飞特征:长距离起飞
08-26 11:04:58.100 5020-5020/? D/test: 歼击机飞行特征:超音速飞行
08-26 11:04:58.100 5020-5020/? D/test: 客机起飞特征:长距离起飞
08-26 11:04:58.100 5020-5020/? D/test: 客机飞行特征:亚音速飞行

        从上述代码可以看出来,策略模式中客户端必须知道具体的策略类,才能够正确调用需要的方法,该模式跟状态模式很相似,但还是有区别的,状态模式中,状态类会持有环境类的引用。详细分析,请看扩展。

优点:
  • 策略模式提供了对“开闭原则”的完美支持,用户可以在不修改原有系统的基础上选择算法或行为,也可以灵活地增加新的算法或行为。
  • 策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族,恰当使用继承可以把公共的代码移到抽象策略类中,从而避免重复的代码。
  • 策略模式提供了一种可以替换继承关系的办法。如果不使用策略模式,那么使用算法的环境类就可能会有一些子类,每一个子类提供一种不同的算法。但是,这样一来算法的使用就和算法本身混在一起,不符合“单一职责原则”,决定使用哪一种算法的逻辑和该算法本身混合在一起,从而不可能再独立演化;而且使用继承无法实现算法或行为在程序运行时的动态切换。
  • 使用策略模式可以避免多重条件选择语句。多重条件选择语句不易维护,它把采取哪一种算法或行为的逻辑与算法或行为本身的实现逻辑混合在一起,将它们全部硬编码(Hard Coding)在一个庞大的多重条件选择语句中,比直接继承环境类的办法还要原始和落后。
  • 策略模式提供了一种算法的复用机制,由于将算法单独提取出来封装在策略类中,因此不同的环境类可以方便地复用这些策略类。

缺点:
  • 客户端必须知道所有的策略类,并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别,以便适时选择恰当的算法。换言之,策略模式只适用于客户端知道所有的算法或行为的情况。
  • 策略模式将造成系统产生很多具体策略类,任何细小的变化都将导致系统要增加一个新的具体策略类。
  • 无法同时在客户端使用多个策略类,也就是说,在使用策略模式时,客户端每次只能使用一个策略类,不支持使用一个策略类完成部分功能后再使用另一个策略类来完成剩余功能的情况。

使用场景:
  • 一个系统需要动态地在几种算法中选择一种,那么可以将这些算法封装到一个个的具体算法类中,而这些具体算法类都是一个抽象算法类的子类。换言之,这些具体算法类均有统一的接口,根据“里氏代换原则”和面向对象的多态性,客户端可以选择使用任何一个具体算法类,并只需要维持一个数据类型是抽象算法类的对象。
  • 一个对象有很多的行为,如果不用恰当的模式,这些行为就只好使用多重条件选择语句来实现。此时,使用策略模式,把这些行为转移到相应的具体策略类里面,就可以避免使用难以维护的多重条件选择语句。
  • 不希望客户端知道复杂的、与算法相关的数据结构,在具体策略类中封装算法与相关的数据结构,可以提高算法的保密性与安全性。

扩展:
策略模式与状态模式
  • 可以通过环境类状态的个数来决定是使用策略模式还是状态模式。
  • 策略模式的环境类自己选择一个具体策略类,具体策略类无须关心环境类;而状态模式的环境类由于外在因素需要放进一个具体状态中,以便通过其方法实现状态的切换,因此环境类和状态类之间存在一种双向的关联关系。
  • 使用策略模式时,客户端需要知道所选的具体策略是哪一个,而使用状态模式时,客户端无须关心具体状态,环境类的状态会根据用户的操作自动转换。
  • 如果系统中某个类的对象存在多种状态,不同状态下行为有差异,而且这些状态之间可以发生转换时使用状态模式;如果系统中某个类的某一行为存在多种实现方式,而且这些实现方式可以互换时使用策略模式。


Java设计模式——策略模式【Strategy Pattern】

摘自:Java设计模式经典搞笑版 刘备要到江东娶老婆了,走之前诸葛亮给赵云(伴郎)三个锦囊妙计,说是按天机拆开解决棘手问题, 嘿,还别说,真是解决了大问题,搞到最后是周瑜陪了夫人又折兵呀,那咱们先...

Java设计模式——策略模式[Strategy Pattern]

策略模式,定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。  策略模式组成:1.策略类,通常由一个接口或者抽象类实现;2.具...

Head First 设计模式——策略模式(Strategy Pattern)

策略模式(Strategy Pattern)  定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户 设计原则1:找出应用中可能需要变化之处,把它们独...

设计模式初探1——策略模式(Strategy Pattern)

策略模式:定义算法族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。...

大话设计模式c++实现2——策略模式 Strategy Pattern

1.问题 商场收银软件,根据客户所购买的单价和数量,显示总价。会有打折、返利等活动,使得计算方式不同。界面设计如下: 2.分析 面向对象的编程,并不是类越多越好,类的划分是为了封装,但分类的基础是...

我所理解的设计模式(C++实现)——策略模式(Strategy Pattern)

每个人都要“交个人所得税”,但是“在美国交个人所得税”和“在中国交个人所得税”就有不同的算税方法。 而策略模式就是对算法进行包装,是把使用算法的责任和算法本身分割开来,委派给不同的对象管理。策略模式通...
  • LCL_data
  • LCL_data
  • 2013年08月24日 10:59
  • 12363

软件设计模式——策略模式(Strategy pattern)

策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。策略模式主要分为以下三个角色: 1. 环境角色(Context):...

如何让孩子爱上设计模式 ——14.策略模式(Strategy Pattern)

如何让孩子爱上设计模式 ——14.策略模式(Strategy Pattern)标签: 设计模式初涉描述性文字本节讲解的是行为型设计模式中的第一个模式: 策略模式, 这个模式非常简单,也很好理解。 ...

设计模式(7)——策略模式(Strategy Pattern)

现在需要封装一个算法,但是该算法有很多种不同的实现,比如,一个排序算法,可能有插入排序,冒泡排序,快速排序等不同的实现,而且要求这些算法由使用者来决定具体使用的是哪个算法,如何来设计呢?   ...

设计模式——策略模式(Strategy Pattern)

概念 在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。 在策略模式中,我们创建表示各种策略的对象和一个行为随着策略对象...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java设计模式——策略模式(Strategy Pattern)
举报原因:
原因补充:

(最多只允许输入30个字)