行为型模式-状态(state)

状态

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类.

实例

main.cc:

#include 
#include "slow_run.h"
#include "middle_run.h"
#include "context.h"

/*
design_pattern:"state"
In order to improve the performance of running a lot of people will choose intermittent running:
slow speed run(6km/minute)--->middle speed run(5km/minute)--->fast speed run(4km/minute)
--->slow speed run(6km/minute)--->middle speed run(5km/minute)--->fast speed run(4km/minute).
*/
int main(){
    Run *slow = new SlowRun();
    Context *context = new Context(slow);

    context->Training();
    context->Training();
    context->Training();
    context->Training();
    context->Training();
    context->Training();

    //clear,need to delete object which created in Handle method!
    delete context;
    system("Pause");
    return 0;
}

Context:

//context.h
#ifndef HELENDP_SOURCE_CONTEXT_H_
#define HELENDP_SOURCE_CONTEXT_H_
#include "run.h"

class Context{
public:
    Context(Run *run);
    ~Context();
    void Training();
    void SetRun(Run *run);
private:
    Run *run_;
    Run *old_run_;//Each process generates an object in the next state, so the old object needs to be deleted
};
#endif


//context.cc
#include "context.h"

Context::Context(Run * run){
    run_ = run;
}

Context::~Context(){
    delete run_;
}

void Context::SetRun(Run * run){
    run_ = run;
}

void Context::Training(){
    old_run_ = run_;
    run_->Handle(this);
    delete old_run_;
}

Run:

//run.h
#ifndef HELENDP_SOURCE_RUN_H_
#define HELENDP_SOURCE_RUN_H_

class Context;
class Run{
public:
    Run();
    virtual ~Run();

    virtual void Handle(Context *context);
};
#endif


//run.cc
#include "run.h"
#include "context.h"
Run::Run(){

}

Run::~Run(){

}

void Run::Handle(Context *context){

}

FastRun:

//fast_run.h
#ifndef HELENDP_SOURCE_FAST_RUN_H_
#define HELENDP_SOURCE_FAST_RUN_H_
#include "run.h"
#include "context.h"

class FastRun : public Run{
public:
    FastRun();
    ~FastRun();
    void Handle(Context *context);
};
#endif        


//fast_run.cc
#include "slow_run.h"
#include "fast_run.h"
#include 
using namespace std;
FastRun::FastRun(){

}

FastRun::~FastRun(){

}

void FastRun::Handle(Context *context){
    cout << "Fast run:4KM/M!" << endl;
    context->SetRun(new SlowRun());
}

MiddleRun:

//middle_run.h
#ifndef HELENDP_SOURCE_MIDDLE_RUN_H_
#define HELENDP_SOURCE_MIDDLE_RUN_H_
#include "run.h"
#include "context.h"

class MiddleRun : public Run{
public:
    MiddleRun();
    ~MiddleRun();
    void Handle(Context *context);
};
#endif                                                                                                                                                     


//middle_run.cc
#include "fast_run.h"
#include "middle_run.h"
#include 
using namespace std;
MiddleRun::MiddleRun(){

}

MiddleRun::~MiddleRun(){

}

void MiddleRun::Handle(Context *context){
    cout << "middle run:5KM/M!" << endl;
    context->SetRun(new FastRun());
}

SlowRun:

//slow_run.h
#ifndef HELENDP_SOURCE_SLOW_RUN_H_
#define HELENDP_SOURCE_SLOW_RUN_H_
#include "run.h"
#include "context.h"

class SlowRun : public Run{
public:
    SlowRun();
    ~SlowRun();
    void Handle(Context *context);
};
#endif


//slow_run.cc
#include "slow_run.h"
#include "middle_run.h"
#include 
using namespace std;
SlowRun::SlowRun(){

}

SlowRun::~SlowRun(){

}

void SlowRun::Handle(Context *context){
    cout << "slow run:6KM/M!" << endl;
    context->SetRun(new MiddleRun());
}

代码和UML图(EA)工程文件,最后会整理打包上传.

UML类图

结构

• Context(Context):环境类.
• State(Run):状态抽象类.
• ConcreteState(FastRun,MiddleRun,SlowRun):各状态子类.

优点

• 封装了转换规则.
• 枚举可能的状态，在枚举状态之前需要确定状态种类.
• 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为.
• 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块.
• 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数.

缺点

• 状态模式的使用必然会增加系统类和对象的个数.
• 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱.
• 状态模式对“开闭原则”的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码.