设计模式-行为型模式-命令模式
基础
以一个MIS系统为栗子
MIS 管理信息系统（Management Information System，MIS）是一个以人为主导的，利用计算机硬件、软件和网络设备，进行信息的收集、传递、存储、加工、整理的系统，以提高组织的经营效率。
代码如下
public abstract class Group{
// 甲乙双方公开办公，如果要和某个组讨论，要先找到这个组
public abstract void find();
// 要求增加功能
public abstract void add();
// 删除功能
public abstract void delete();
// 被要求修改功能
public abstract void change();
// 被要求给出变更计划
public abstract void plan();
}抽象类中的都是命令方式。
进行需求组
public class RequirementGroup extends Group{
// 客户要求需求进行更改
public void find(){
}
// 客户要求增加需求
public void add(){
}
// 客户要求修改需求
public void change(){
}
// 客户要求删除需求
public void delete(){
}
// 客户要求给出变更计划
public void plan(){
}
}// 美工组
public class PageGroup extends Group{
// 找到美工组
public void find(){
}
// 客户要求增加页面
public void add(){
}
// 客户要求对现有界面修改
public void change(){
}
// 客户要求删除页面
public void delete(){
}
// 给出计划
public void plan(){
}
}// 代码组
public class CodeGroup extends Group {
// 客户要求过去谈
public void find(){
}
// 客户要求增加功能
public void add(){
}
// 客户要求修改功能
public void change(){
}
// 客户要求删除功能
public void delete(){
}
// 客户要求变更计划
public void plan(){
}
}最后书写场景类
// 场景类
public class Client{
public static void main(String[] args){
// 客户找到需求要求谈需求进行修改
Grop rg = new RequirementGroup();
// 找到需求组
rg.find();
// 增加需求组
rg.add();
// 变更计划
rg.plan();
}
}此时客户要求多一个界面
public class Client {
public static void main(String[] args){
Group pg = new PangeGroup();
// 找到需求组
pg.find();
// 删除需求组
pg.delete();
// 需求变更
pg.plan();
}
}变更
客户每次都要单独找一个，非常复杂，设置一个负责人，负责和客户和需求，美工之间的连接。
// 抽象出命令类
public abstract class Command{
// 定义三个组，确保子类可以直接使用
protected RequirementGroup rg = new RequirementGroup(); // 需求组
protected PageGroup pg = new PageGroup(); // 美工组
protected CodeGroup cg = new CodeGroup(); // 代码组
public abstract void execute(); // 做什么事情
}增加需求的命令
public class AddRequirementCommand extends Command{
// 增加一项需求命令
public void execute(){
// 找到需求组
super.rg.find();
// 增加一份需求
super.rg.add();
// 给出计划
super.rg.plan();
}
}增加删除页面的命令
public class DeletePageCommand extends Command{
public void execute(){
// 找到页面组
super.pg.find();
// 删除页面
super.rg.delete();
// 给出计划
super.rg.plan();
}
}最后再将这也命令封装，成一个负责人
public class invoker {
// 命令
private Command command;
// 客户发出命令
public void setCommand(Command command){
this.command = command;
}
// 客户自行命令
public void action(){
this.command.execute();
}
}最后场景类如下
public class Client{
public static void main(String[] args){
// 定义接头人
invoker xiaoSan = new Invoker(); // 接头人
// 客户增加需求
// 客户下命令
Command command = new AddRequirementCommand();
// 街头人收到命令
xiaoSan.setCommand(command);
// 街头人执行命令
xiaoSan.action();
}
}继续更改
由于负责人的抽象类中声明了所有的，所以可以分离
代码如下
public abstract class Command {
// 定义子类全局共享变量
protected final Receiver receiver;
// 实现类名需要接收
public Command(Receiver _receiver){
this.receiver = _receiver;
}
// 每个命令需要有执行
public abstract void execute();
}然后在Command中声明接收者。
通过构造函数指定
public class ConcreteCommand1 extends Command{
// 声明自己默认接收者
public ConcreteCommand1(){
super(new ConcreteReciver1());
}
// 设置新的接受
public ConcreteCommand1(Receiver _receiver){
super(_receiver);
}
// 处理
public void execute(){
super.receiver.doSomething();
}
}// 声明场景
public class Client{
public static void main(String[] args){
invoker invoker = new invoker();
// 定义要发送的命令
Command command = new ConcreteCommand1();
invoker.setCommand(command);
invoker.action();
}
}总结
将需求封装成命令，然后再负责人当中封装，最后，需要的时候，直接调用负责人，将命令传入进去即可。
