设计模式(3)-策略模式(Strategy)

最新推荐文章于 2024-09-05 15:24:07 发布
最新推荐文章于 2024-09-05 15:24:07 发布
阅读量2k 收藏
点赞数
分类专栏： 设计模式 设计模式(Qt版) 文章标签： 设计模式 methods uml class 语言 delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tandesir/article/details/7667359
版权

【描述】策略模式本质上利用的是面向对象的多态特性，构建者不必自身包含实现的逻辑，而是根据需要利用其他对象中的算法。

【UML图】

图1 UML图

(1) 定义了一个Methods基类，包含一个策略的接口MethodsInterface。

(2) 定义了MethodsStrategyA、MethodsStrategyB两种策略。

(3) 定义了一个策略构建者Context，包含ContextInterface方法。

 

【示例代码】

methods.h

#ifndef METHODS_H
#define METHODS_H

class Methods
{
public:
    Methods();

public:
    virtual void MethodsInterface();
};

#endif // METHODS_H

methods.cpp

#include <QDebug>
#include "methods.h"

Methods::Methods()
{
    qDebug()<<"construct Methods";
}

void Methods::MethodsInterface()
{
    qDebug()<<"Methods::MethodsInterface";
}

methodstrategya.h

#ifndef METHODSTRATEGYA_H
#define METHODSTRATEGYA_H

#include "methods.h"

class MethodStrategyA : public Methods
{
public:
    MethodStrategyA();

public:
    void MethodsInterface();
};

#endif // METHODSTRATEGYA_H

methodstrategya.cpp

#include <QDebug>
#include "methodstrategya.h"

MethodStrategyA::MethodStrategyA()
{
    qDebug()<<"construct MethodStrategyA";
}

void MethodStrategyA::MethodsInterface()
{
    qDebug()<<"Strategy A";
}

methodstrategyb.h

#ifndef METHODSTRATEGYB_H
#define METHODSTRATEGYB_H

#include "methods.h"

class MethodStrategyB : public Methods
{
public:
    MethodStrategyB();

public:
    void MethodsInterface();
};

#endif // METHODSTRATEGYB_H

methodstrategyb.cpp

#include <QDebug>
#include "methodstrategyb.h"

MethodStrategyB::MethodStrategyB()
{
    qDebug()<<"construct MethodStrategyB";
}

void MethodStrategyB::MethodsInterface()
{
    qDebug()<<"Strategy B";
}

context.h

#ifndef CONTEXT_H
#define CONTEXT_H

#include "methods.h"

class Context
{
public:
    Context(Methods *method);

private:
    Methods *_method;

public:
    void ContextInterface();
};

#endif // CONTEXT_H

context.cpp

#include "context.h"

Context::Context(Methods *method)
{
    _method = method;
}

void Context::ContextInterface()
{
    _method->MethodsInterface();
}

main.cpp

#include <QDebug>
#include "context.h"
#include "methods.h"
#include "methodstrategya.h"
#include "methodstrategyb.h"

int main()
{
    Context *context;

    context = new Context(new MethodStrategyA);
    context->ContextInterface();

    context = new Context(new MethodStrategyB);
    context->ContextInterface();

    return 0;
}

 

【运行结果】

construct Methods 
construct MethodStrategyA 
Strategy A 
construct Methods 
construct MethodStrategyB 
Strategy B


【结果分析】

利用多态特性，实现了不同策略的调用，由于是测试代码，本身很简单，省略了析构函数。

 

【实例剖析】

*本例来源于《重构-改善既有代码的设计》第1章。原例采用Java语言编写，本例利用Qt C++进行了改写。

看下面一个关于电影租赁计价的例子。

movie.h

#ifndef MOVIE_H
#define MOVIE_H

#include <QString>
enum {REGULAR = 0,NEW_RELEASE = 1,DISCOUNT = 2};

class Movie
{
public:
    Movie();
    Movie(QString title, int priceCode);

private:
    QString _title;
    int _priceCode;

public:
    QString getTitle();
    int getPriceCode();
    void setPriceCode(int arg);
};

#endif // MOVIE_H

movie.cpp

#include <QDebug>
#include "movie.h"

Movie::Movie()
{
    qDebug()<<"construct Movie::Movie()";
}

Movie::Movie(QString title, int priceCode)
{
    qDebug()<<QString("construct Movie::Movie(%1,%2)").arg(title).arg(priceCode);
    _title = title;
    _priceCode = priceCode;
}

QString Movie::getTitle()
{
    return _title;
}

int Movie::getPriceCode()
{
    return _priceCode;
}

void Movie::setPriceCode(int arg)
{
    _priceCode = arg;
}

rental.h

#ifndef RENTAL_H
#define RENTAL_H

#include "movie.h"

class Rental
{
public:
    Rental(Movie movie, int daysRented);

private:
    Movie _movie;
    int _daysRented;

public:
    Movie getMovie();
    int getDaysRented();
    double getCharge(int daysRented);
};

#endif // RENTAL_H

rental.cpp

#include <QDebug>
#include "rental.h"

Rental::Rental(Movie movie, int daysRented)
{
    qDebug()<<"construct Rental";
    _movie = movie;
    _daysRented = daysRented;
}

Movie Rental::getMovie()
{
    return _movie;
}

int Rental::getDaysRented()
{
    return _daysRented;
}

double Rental::getCharge(int daysRented)
{
    double result = 0;
    qDebug()<<getMovie().getPriceCode();
    switch(getMovie().getPriceCode())
    {
    case REGULAR:
        result +=2;
        if(daysRented>2)
        {
            result += (daysRented-2)*1.5;
        }
        break;
    case NEW_RELEASE:
        result += daysRented*3;
        break;
    case DISCOUNT:
        result +=2;
        if(daysRented>2)
        {
            result += (daysRented-2)*1;
        }
        break;
    }
    qDebug()<<result;
    return result;
}


main.cpp

#include "movie.h"
#include "rental.h"

int main()
{
    int daysRented = 30;
    Movie movie("Book1",NEW_RELEASE);
    Rental rental(movie,daysRented);
    movie.setPriceCode(NEW_RELEASE);
    rental.getCharge(daysRented);
    return 0;
}


运行结果如下：

"construct Movie::Movie(Book1,1)" 
construct Movie::Movie() 
construct Rental 
1 
90

示例调用了getCharge，并返回了priceCode相应的计价。相对于《重构》一书最原始代码，这段代码经过了一定的重构处理。

先看下述代码，

double Rental::getCharge(int daysRented)
{
    double result = 0;
    qDebug()<<getMovie().getPriceCode();
    switch(getMovie().getPriceCode())
    {
    case REGULAR:
        result +=2;
        if(daysRented>2)
        {
            result += (daysRented-2)*1.5;
        }
        break;
    case NEW_RELEASE:
        result += daysRented*3;
        break;
    case DISCOUNT:
        result +=2;
        if(daysRented>2)
        {
            result += (daysRented-2)*1;
        }
        break;
    }
    qDebug()<<result;
    return result;
}

这段代码，有一些不好的地方：

(1) 这段代码通过priceCode判断电影的租金，采用了switch-case语言，实质上还是面向过程的范畴，代码可重用性很低；

(2) 如果情形较多，switch-case会变得十分庞大。

 

有什么办法能去掉switch-case吗？下面通过引入策略模式实现这一目的。

先看UML图，

图2

(1) 引入了一个Price基类，提供了getCharge()接口供子类实现；

(2) 将switch-case语句中的3种情形抽取为3个Price子类；

(3) Movie调用了Price提供的接口。

 

【代码清单】

price.h

#ifndef PRICE_H
#define PRICE_H

class Price
{
public:
    Price();

private:
    int _priceCode;

public:
    int getPriceCode();
    void setPriceCode(int arg);
    virtual double getCharge(int daysRented);
};

#endif // PRICE_H

price.cpp

#include <QDebug>
#include "price.h"

Price::Price()
{
    qDebug()<<"construct Price";
    _priceCode = 0;
}

int Price::getPriceCode()
{
    qDebug()<<_priceCode;
    return _priceCode;
}

void Price::setPriceCode(int arg)
{
    _priceCode = arg;
}

double Price::getCharge(int daysRented)
{
    qDebug()<<"Price::getCharge";
    return daysRented;
}

regularprice.h

#ifndef REGULARPRICE_H
#define REGULARPRICE_H

#include "price.h"

class RegularPrice : public Price
{
public:
    RegularPrice();

public:
    double getCharge(int daysRented);
};

#endif // REGULARPRICE_H

regularprice.cpp

#include <QDebug>
#include "regularprice.h"

RegularPrice::RegularPrice()
{
    qDebug()<<"construct RegularPrice";
}

double RegularPrice::getCharge(int daysRented)
{
    qDebug()<<"RegularPrice::getCharge";
    double result = 2;
    if(daysRented>2)
    {
        result += (daysRented-2)*1.5;
    }
    return result;
}

newreleaseprice.h

#ifndef NEWRELEASEPRICE_H
#define NEWRELEASEPRICE_H

#include "price.h"

class NewReleasePrice : public Price
{
public:
    NewReleasePrice();

public:
    double getCharge(int daysRented);
};

#endif // NEWRELEASEPRICE_H

newreleaseprice.cpp

#include <QDebug>
#include "newreleaseprice.h"

NewReleasePrice::NewReleasePrice()
{
    qDebug()<<"construct NewReleasePrice";
}

double NewReleasePrice::getCharge(int daysRented)
{
    qDebug()<<"NewReleasePrice::getCharge";
    return daysRented*3;;
}

discountprice.h

#ifndef DISCOUNTPRICE_H
#define DISCOUNTPRICE_H

#include "price.h"

class DiscountPrice : public Price
{
public:
    DiscountPrice();

public:
    double getCharge(int daysRented);
};

#endif // DISCOUNTPRICE_H

discountprice.cpp

#include <QDebug>
#include "discountprice.h"

DiscountPrice::DiscountPrice()
{
    qDebug()<<"construct DiscountPrice";
}

double DiscountPrice::getCharge(int daysRented)
{
    qDebug()<<"DiscountPrice::getCharge";
    double result = 2;
    if(daysRented>2)
    {
        result += daysRented;
    }

    return result;
}

movie.h

#ifndef MOVIE_H
#define MOVIE_H

#include <QString>
#include "price.h"
enum {REGULAR = 0,NEW_RELEASE = 1,DISCOUNT = 2};

class Movie
{
public:
    Movie();
    Movie(QString title, int priceCode);
    ~Movie();

private:
    QString _title;
    int _priceCode;
    Price *_price;

public:
    QString getTitle();
    int getPriceCode();
    void setPriceCode(int arg, Price *_price);
    double getCharge(int daysRented);
};

#endif // MOVIE_H

movie.cpp

#include <QDebug>
#include "movie.h"
#include "regularprice.h"
#include "newreleaseprice.h"
#include "discountprice.h"

Movie::Movie()
{
    qDebug()<<"construct Movie::Movie()";

}

Movie::Movie(QString title, int priceCode)
{
    qDebug()<<QString("construct Movie::Movie(%1,%2)").arg(title).arg(priceCode);
    _price = new Price;
    _title = title;
    _priceCode = priceCode;
}

Movie::~Movie()
{
    delete _price;
}

QString Movie::getTitle()
{
    return _title;
}

int Movie::getPriceCode()
{
    return _price->getPriceCode();
}

void Movie::setPriceCode(int arg, Price *price)
{
    _price = price;
    _price->setPriceCode(arg);
}

double Movie::getCharge(int daysRented)
{
    return _price->getCharge(daysRented);
}

rental.h

#ifndef RENTAL_H
#define RENTAL_H

#include "movie.h"

class Rental
{
public:
    Rental(Movie movie, int daysRented);

private:
    Movie _movie;
    int _daysRented;

public:
    Movie getMovie();
    int getDaysRented();
    double getCharge(int daysRented);
};

#endif // RENTAL_H

rental.cpp

#include <QDebug>
#include "rental.h"

Rental::Rental(Movie movie, int daysRented)
{
    qDebug()<<"construct Rental";
    _movie = movie;
    _daysRented = daysRented;
}

Movie Rental::getMovie()
{
    return _movie;
}

int Rental::getDaysRented()
{
    return _daysRented;
}

double Rental::getCharge(int daysRented)
{
    return _movie.getCharge(daysRented);
}

main.cpp

#include <QDebug>
#include "movie.h"
#include "rental.h"
#include "regularprice.h"
#include "newreleaseprice.h"
#include "discountprice.h"

int main()
{
    int daysRented = 30;
    Movie movie("Book1",NEW_RELEASE);
    Rental rental(movie,daysRented);
    movie.setPriceCode(NEW_RELEASE, new NewReleasePrice);
    rental.getCharge(daysRented);
    return 0;
}


【运行结果】

"construct Movie::Movie(Book1,1)" 
construct Price 
construct Movie::Movie() 
construct Rental 
construct Price 
construct NewReleasePrice 
NewReleasePrice::getCharge


【结果分析】

movie.setPriceCode(NEW_RELEASE, new NewReleasePrice);

传入priceCode和Price子对象作为参数，从运行结果可以看出，调用了NewReleasePrice的getCharge方法。

应用策略模式后，Rental::getCharge中仅有一行代码。

double Rental::getCharge(int daysRented)
{
    return _movie.getCharge(daysRented);
}

将原来的getCharge做了搬移处理，而Movie::getCharge也很简短：

double Movie::getCharge(int daysRented)
{
    return _price->getCharge(daysRented);
}


 

*应用策略模式后，消除了switch-case语句，函数更为简洁。将Price单独抽出，成为一个类组，提高了代码的可重用性。

 

【学习参考】

(1) 设计模式之三 --- 策略模式(Strategy Pattern)

 

【源码下载】

Qt设计模式1-8测试源码：http://download.csdn.net/detail/tandesir/4984275
 声明：该源码仅供学习交流，勿用于商业目的。


 

转载请标明出处，仅供学习交流，勿用于商业目的

Copyright @ http://blog.csdn.net/tandesir





 


 

 

tandesir
关注
专栏目录
策略模式UML图形及代码
bug_yun的博客
07-06 2605
参考：http://blog.csdn.net/lovelion/article/details/17517213    //电影票类：环境类 class MovieTicket { private double price; private Discount discount; //维持一个对抽象折扣类的引用 public voi...
设计模式系列(二) ——策略模式
羽凌薇的博客
03-22 806
策略模式策略模式概要策略模式定义策略模式结构鸭子模型引入提出需求解决方案之——使用继承解决方案之——使用接口解决方案之——策略模式总结策略模式涉及的设计原则策略模式优缺点 策略模式概要 策略模式定义 什么是策略模式？先看下《 Head First 》一书中的定义: 从定义来看，说的过于抽象，可能会一头雾水，不明白策略模式到底是个啥东西，实际上"策略"二字古已有之，在古代中又称“计策”，“计谋”，简单点说就是指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法，说白了就是解决同一问题的不同解决办法。
Java设计模式教程-策略模式Java开发Java经验技
12-01
Java设计模式教程——策略模式Java开发Java经验技巧共13页.pdf.zip
【软件设计】常用设计模式--策略模式
最新发布
分享自己学习过程获得的一些知识
09-05 1643
策略模式是一种行为型设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以互换。策略模式让算法独立于使用它的客户而变化。通过策略模式，我们可以将不同的算法封装到独立的类中，并通过客户端在运行时选择具体的策略类。这种模式的优点是提高了代码的灵活性和可扩展性。
设计模式_16 策略模式（含 UML图 和 C++代码）
alpc17RuimeError的博客
02-22 1259
设计模式_16 策略模式16 策略模式16.1 概念16.2 结构16.3 实现16.3.1 UML图16.3.2 代码16.4 优缺点16.4.1 优点16.4.2 缺点16.5 使用场景 16 策略模式 16.1 概念 该模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同对象对这些算法进行管理。 16.2 结构 抽象策略类：通常由一个接口或抽象类来实现。此角色
策略模式
whm2300的专栏
11-08 713
策略模式： 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 组成： —抽象策略角色： 策略类，通常由一个接口或者抽象类实现。 —具体策略角色：包装了相关的算法和行为。 —环境角色：持有一个策略类的引用，最终给客户端调用。 应用场景： 1、 多个类只区别在表现行为不同，可以使用Str
Java设计模式之策略模式(UML类图分析+代码详解)
m0_51750419的博客
10-26 6569
策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体 设定行为对象。1) 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以 互相替换，此模式让算法的变化独立于使用算法的客户。2) 上面说的1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改 动，会影响其他部分。1) 其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。1) 应用实例要求 编写程序完成前面的鸭子项目，要求使用策略模式。
C/C++设计模式(十五) 策略模式
码之有道
09-08 221
概念 策略模式（Strategy模式）是行为模式之一，它对一系列的算法加以封装，为所有算法定义一个抽象的算法接口，并通过继承该抽象算法接口对所有的算法加以封装和实现，具体的算法选择交由客户端决定（策略）。Strategy模式主要用来平滑地处理算法的切换 。 角色和职责 这里的关键就是将算法的逻辑抽象接口(DoAction) 封装到一个类中(Context)， 再通过委托的方式将具体的算法实现委托给具体的Strategy 类来实现(ConcreteStrategeA类)。 Strategy: 策略
策略模式实例与UML
拼搏的小船长
11-29 1032
<?php interface FlyBehavior{ public function fly(); } class FlyWithWings implements FlyBehavior{ public function fly(){ echo "Fly With Wings ".PHP_EOL; } } class FlyWithNo implem
人人都会设计模式---策略模式--Strategy
01-27
【策略模式】是一种设计模式，它的核心思想是将不同的算法或行为封装成独立的类，这些类具有统一的接口，从而使客户端可以灵活地选择并使用其中的任何一种算法，而无需关心具体实现的细节。这种模式可以有效地避免...
设计模式-策略模式（Strategy）
09-20
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。这种模式允许你使用算法族，而无需在代码中硬编码这些算法。通过将算法封装到具有共同接口的独立对象中，策略模式使得你可以根据需要灵活地切换算法，...
策略模式类图和代码实例
03-16
NULL 博文链接：https://xuningxiaoni.iteye.com/blog/415879
c++设计模式-行为型模式-策略模式
06-19
c++设计模式-行为型模式-策略模式；qt工程；c++简单源码； 策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于...
策略模式--收银软件实现代码及UML图
Woo~
03-23 864
策略模式 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 使用策略模式可以把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略类( ConcreteStrategy) 中提供。 由于算法和环境独立开来，算法的增减、修改都不会影响环境和客户端。当出现新的促销折扣或现有的折扣政策出现变化时，只需要实现新的策略类，并在客户端登记即可。策略模式相当于"可插入式(Pluggable)的算法"。
设计模型之策略模式含UML完整实例)
atu1111的博客
04-15 1849
设计模型之策略模式 1. 策略模式 1.1 定义与特点 1.2 模式的结构 1.3 问题由来 1.4 解决思路 1.5 UML类图 1.6 解决方案
用代码和UML图化解设计模式之《策略模式》
wintree的专栏
10-18 3349
什么是策略模式，用我个人的定义就是利用了面向对象的多态等特性，通过一个类来管理实体类的一种编程技巧。 这种模式在项目中是经常用到的。   通过建模大家可以清晰的看到这些类层次关系。下面就用代码来实现一下。 我使用的是VS2005的，大家可以根据需要修改部分代码。   #include "stdafx.h" #include using namespace std; clas
设计模式之策略模式
wang0907的博客
01-27 8125
java程序的设计原则 6大原则： 单一职责：一个类和方法只做一件事。 开闭：对修改关闭，对扩展开发。 里氏替换：子类可扩展新方法，但不可修改父类已有方法（父类已提供了具体实现的方法）。 依赖倒置：依赖于抽象，而非具体实现，即面向接口编程（如方法参数，类属性使用接口声明，这样可接收任何子类）。 接口隔离：使用多个隔离的接口定义抽象，降低耦合。 最少知道/迪米特：降低类之间的依赖，聚合，组合等。 1：策略设计模式 策略设计模式一般使用的场景是，多种可互相替代的同类行为，在具体运行过程中根据不同情况，选择其中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值