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

最新推荐文章于 2023-06-20 22:08:01 发布
最新推荐文章于 2023-06-20 22:08:01 发布
阅读量1.9k 收藏
点赞数
分类专栏： 设计模式 设计模式(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 2587
参考：http://blog.csdn.net/lovelion/article/details/17517213    //电影票类：环境类 class MovieTicket { private double price; private Discount discount; //维持一个对抽象折扣类的引用 public voi...
设计模式系列(二) ——策略模式
羽凌薇的博客
03-22 779
策略模式策略模式概要策略模式定义策略模式结构鸭子模型引入提出需求解决方案之——使用继承解决方案之——使用接口解决方案之——策略模式总结策略模式涉及的设计原则策略模式优缺点 策略模式概要 策略模式定义 什么是策略模式？先看下《 Head First 》一书中的定义: 从定义来看，说的过于抽象，可能会一头雾水，不明白策略模式到底是个啥东西，实际上"策略"二字古已有之，在古代中又称“计策”，“计谋”，简单点说就是指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法，说白了就是解决同一问题的不同解决办法。
设计模式_16 策略模式（含 UML图 和 C++代码）
alpc17RuimeError的博客
02-22 1185
设计模式_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 结构 抽象策略类：通常由一个接口或抽象类来实现。此角色
Java设计模式之策略模式(UML类图分析+代码详解)
m0_51750419的博客
10-26 6346
策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体 设定行为对象。1) 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以 互相替换，此模式让算法的变化独立于使用算法的客户。2) 上面说的1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改 动，会影响其他部分。1) 其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。1) 应用实例要求 编写程序完成前面的鸭子项目，要求使用策略模式。
策略模式类图和代码实例
03-16
NULL 博文链接：https://xuningxiaoni.iteye.com/blog/415879
人人都会设计模式---策略模式--Strategy
01-27
【策略模式】是一种设计模式，它的核心思想是将不同的算法或行为封装成独立的类，这些类具有统一的接口，从而使客户端可以灵活地选择并使用其中的任何一种算法，而无需关心具体实现的细节。这种模式可以有效地避免...
设计模式-策略模式（Strategy）
最新发布
09-20
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。这种模式允许你使用算法族，而无需在代码中硬编码这些算法。通过将算法封装到具有共同接口的独立对象中，策略模式使得你可以根据需要灵活地切换算法，...
c++设计模式-行为型模式-策略模式
06-19
c++设计模式-行为型模式-策略模式；qt工程；c++简单源码； 策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于...
Java设计模式教程-策略模式Java开发Java经验技
12-01
策略模式的主要组成部分包括环境(Context)角色、策略(Strategy)角色以及具体策略 ConcreteStrategy 角色。环境角色维护一个对策略对象的引用，客户通过环境角色来调用策略对象的算法；策略角色定义了算法族的公共...
策略模式--收银软件实现代码及UML图
Woo~
03-23 830
策略模式 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 使用策略模式可以把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略类( ConcreteStrategy) 中提供。 由于算法和环境独立开来，算法的增减、修改都不会影响环境和客户端。当出现新的促销折扣或现有的折扣政策出现变化时，只需要实现新的策略类，并在客户端登记即可。策略模式相当于"可插入式(Pluggable)的算法"。
策略模式 Strategy
HuangGang_clown的博客
02-11 180
策略模式 策略模式是将算法族抽象为接口，再将此接口与业务对象组合起来，实现不同策略功能的设计模式，该模式要求所有的策略具体类都实现一个顶层接口，该顶层接口包含一个抽象的策略方法 策略模式UML类图如下 实例为比较器的一个策略模式实现 ...
策略模式实例与UML
拼搏的小船长
11-29 1016
<?php interface FlyBehavior{ public function fly(); } class FlyWithWings implements FlyBehavior{ public function fly(){ echo "Fly With Wings ".PHP_EOL; } } class FlyWithNo implem
设计模式：UML类图、策略模式、单例模式、工厂模式、观察者模式
ehuangdan5864的博客
08-01 2738
一、UML类图： 类与类之间存在6个关系： 1）依赖：类A用到了类B，不是成员变量中用到，而是在成员函数中用到了 2）关联：类A使用了类B，并且是在成员变量中用到的 3）聚合：和关联类似，也是使用实例化来关联，一个是整体，一个是部分 4）组合：相比聚合具有更强的耦合度。部分没有单独存在的意义，整体负责单独的生命周期。 5）继承： 6）实现：纯虚函数 二、策略模式： strategy中的算法经常变化。所以将strategy中的算法作为虚函数，在派生类中进行重写。Context中包含了一个stra
设计模式之策略模式
wang0907的博客
01-27 8037
java程序的设计原则 6大原则： 单一职责：一个类和方法只做一件事。 开闭：对修改关闭，对扩展开发。 里氏替换：子类可扩展新方法，但不可修改父类已有方法（父类已提供了具体实现的方法）。 依赖倒置：依赖于抽象，而非具体实现，即面向接口编程（如方法参数，类属性使用接口声明，这样可接收任何子类）。 接口隔离：使用多个隔离的接口定义抽象，降低耦合。 最少知道/迪米特：降低类之间的依赖，聚合，组合等。 1：策略设计模式 策略设计模式一般使用的场景是，多种可互相替代的同类行为，在具体运行过程中根据不同情况，选择其中
Java设计模式——策略模式
xiaoshitou_2015的博客
06-20 2081
策略模式: 策略模式是一种行为型模式, 它将对象和行为分开, 将行为定义为一个行为接口和具体行为的实现 策略模式最大的特点是行为的变化, 行为之间可以相互替换 每个if判断都可以理解为一个策略. 本模式是的算法可独立于使用它的用户而变化。
《大话设计模式》之策略模式
刘一儿(嵌入式)
04-03 332
大话设计模式之策略模式商场促销UML类图客户端实现方式策略模式解析 商场促销 先上一张图，用Qt/C++实现大话设计模式中第二章的商场促销 UML类图 <策略模式> <简单的工厂模式> 客户端实现方式 简单工厂模式 CashSuper *cs = CashFactory::createCashAccept(m_comboxIndex); double to...
设计模式:（策略模式）
qq_51447436的博客
04-07 8489
设计模式:（策略模式）
23种设计模式——UML类图+简要分析+例题
热门推荐
jiyuzzz的博客
07-08 1万+
23种设计模式——UML类图+简要分析+例题
设计模式总结一（UML类图、简单工厂模式、策略模式和单一职责原则）
My Struggle
01-04 981
前言 我写这篇博文，是对我研一这一学期到现在，学习设计模式的总结。我自己使用的是程杰写的《大话设计模式》这本书，我会跟据这本书，对自己这么多天学习到的知识做一个总结。 目前，第一篇先总结前三章。涉及到的只是有：第一章讲述的UML类图和简单工厂模式，第二章的策略模式和第三章的单一职责原则。首先，先来看第一章地1.11节的UML类图。 UML类图 类图 类图分为三层，第一层是类名；第二层是类特性，即类成员；第三层则是列操作，即类的成员函数。其中，+表示public，-表示private...
C#面向对象设计模式：Strategy策略模式解析
"C#面向对象设计模式纵横谈 - (行为型模式) Strategy 策略模式" 策略模式（Strategy Pattern）是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，有时一个对象需要使用多种算法，当这些算法频繁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值