行为型模式
1、不仅仅关注类和对象结构、而且关注他们之间的相互作用。
2、注重对象之间的协同。
对象行为模式:使用对象的聚合关联关系来分配行为。对合成复用原则、尽量使用关联关系来替代继承关系。
命令模式:行为型模式中的一种。
定义:将一个请求封装为对象,从而使我们用不同请求对客户发出不同行为。
发送者和接受者之间解耦。
从图1 可以看出是一种调用者到命令、命令抽象化,根据具体命令执行具体动作,然后到客户端的接受者。
从图2 可以看出 通过命令的参数化,完成不同行为的动作。
关键角色:
发令者->抽象命令->具体命令 <--接受对象<-客户端。
demo1
#include <iostream>
#include "ConcreteCommand.h"
#include "Invoker.h"
#include "Receiver.h"
using namespace std;
int main (int argc, char *argv[])
{
//接受者
Receiver* pReceiver = new Receiver();
//具体命令到达接受者
ConcreateCommand* pCommand = new ConcreateCommand(pReceiver);
//调用者调用命令,这里可以做分化,不同的具体命令发给不同的接收者。
Invoker * pInvoker = new Invoker(pCommand);
//行为发起 调用具体命令。
pInvoker->call();
delete pReceiver();
delete pCommand();
delete PInvoker();
return 0;
}
//Receiver.h
#ifndef __RECEIVER___H_
#define __RECEIVER___H_
class Receiver{
public:
Receiver();
virtual ~Receiver();
void action();
private:
};
#endif
//Receiver.cpp
#include "Receiver.h"
#include <iostream>
using namespace std;
Receiver::Receiver(){
}
Receiver:: ~Receiver(){
}
void Receiver::action(){
cout << "receiver action" <<endl;
}
//抽象命令Command.h
#ifndef _COMMAND_H_
#define _COMMAND_H_
class Command {
public:
//构造函数引入接收者
Command(Receiver* pReceiver);
//在具体命令实现中,可以通过具体命令不同发送给不同接收者,完成解耦
virtual ~Command();
virtual void execute();
private:
//引入接受者,
Receiver* m_Receiver;
};
#endif
//Command.cpp
Command::Command(Receiver * pRecevier){
//可实现,也可以子类重写
}
Command::~Command(){}
Command::execute(){}
//进入具体命令阶段 具体命令可以有多类,此处写一类。
//具体命令 ConcreateCommand.h
#ifndef _Concreate_Command_H_
#define _Concreate_Command_H_
class ConcreateCommand : public Command(){
public:
ConcreateCommand(Receiver* pReceiver);
~ConcreateCommand();
void execute();
private:
Receiver * m_Receiver;
}
#endif
//子类具体命令实现
//具体命令ConcreateCommand.cpp
#include ConcreateCommand.h
#include <iostream>
using namespace std;
ConcreateCommand::ConcreateCommand(Receiver* pReceiver){
m_Receiver = pReceiver;
}
ConcreateCommand:: ~ConcreateCommand(){
}
//完成具体命令的发送给接收者
void ConcreateCommand::execute(){
cout<< "ConcreateCommand:: execute"<<endl;
//完成接收者创建和执行
m_pReceiver->action();
}
//调用者 命令发起者 调用命令对象 这这里可以调用不同的具体命令,完成解耦。
//Invoker.h
#ifndef _INVOKER_H_
#define _INVOKER_H_
#include "Command.h"
class Invoker{
public:
Invoker(Command * pCommand);
virtual ~Invoker();
void call();
private:
Command* m_pCommand;
}
#endif
//Invoker.cpp
#include Invoker.h
#include <iostream>
using namespace std;
Invoker::Invoker(Command* pCommand){
m_pCommand = pCommand;
}
Invoker::~Invoker(){
}
void Invoker::call(){
cout << "invoker calling" <<endl;
m_pCommand->execute();
}
优点缺点
优点:降低耦合、新的命令易加入。
缺点:每一个动作都需要一个具体命令、可能导致系统复杂、存在大量具体命令。