设计模式之7 command模式和state模式，调停者模式，门面模式

1.    Command模式: 简单来说就是每一个请求过来，都有一个事物去处理。

在最初的设计模式书当中，command模式最主要的功能是用来实现undo（撤销）功能的。

 

首先是抽象类Command：

package com.bjsxt.dp.command;

//提供一个抽象类来规定方法的名称为execute和undo

publicabstractclass Command {

    publicabstractvoid execute();

    publicabstractvoid unDo();

}

 

两个具体的类的实现：HugCommand和ShoppingCommand

 

package com.bjsxt.dp.command;

 

publicclass HugCommandextends Command {

 

    //都实现抽象类command当中的两个方法。execute（）和undo（）

    @Override

    publicvoid execute() {

       System.out.println("hug");

    }

 

    @Override

    publicvoid unDo() {

       System.out.println("open yourarms");

    }

 

}

 

package com.bjsxt.dp.command;

 

publicclass ShoppingCommandextends Command {

 

    //都实现抽象类command当中的两个方法。execute（）和undo（）

    @Override

    publicvoid execute() {

       System.out.println("zoo");

    }

 

    @Override

    publicvoid unDo() {

       System.out.println("undozoo");

    }

 

}

 

命令者类：

当有order方法，其中调用了被命令者（boy）的addCommand方法，用来给boy添加任务：各种command。

package com.bjsxt.dp.command;

 

publicclass MM {

    private Stringname;

 

    public String getName() {

       returnname;

    }

 

    publicvoid setName(String name) {

       this.name = name;

    }

   

    //在order当中可以有多个command， c1,c2...

    publicvoid order(Boy b) {

       Command c1 = new ShoppingCommand();

       //调用了boy当中的addCommand方法，把c1，c2都添加到他的arraylist当中去

       b.addCommand(c1);

       Command c2 = new HugCommand();

       b.addCommand(c2);

       b.executeCommands();

    }

}

 

 

被命令者类：

package com.bjsxt.dp.command;

 

import java.util.ArrayList;

import java.util.List;

 

publicclass Boy {

    private Stringname;

    //用一个arraylist来存放命令列表

    private List<Command>commands =new ArrayList<Command>();

 

    public String getName() {

       returnname;

    }

 

    publicvoid setName(String name) {

       this.name = name;

    }

   

    publicvoid pursue(MM mm) {

    }

 

    publicvoid doSomeThing() {

      

    }

    //boy提供一个方法，把命令添加到boy的arraylist当中

    publicvoid addCommand(Command c1) {

       this.commands.add(c1);

    }

   

    //把commands里面所有的命令拿出来，每个都执行。

    publicvoid executeCommands() {

       for(Command c :commands) {

           c.execute();

       }

    }

    //undo的时候，要用另外一个list来记录，boy已经执行了哪些command。

    //在undo的时候，就根据堆栈的方式，一条一条的undo。

    //使用堆栈的理由，就是要先把最后命令undo，然后再返回去。

    publicvoid undoCommands() {

       //

    }

   

}

 

 

思想：

1.      给出一个抽象类或接口，把command需要方法准备好。

2.      给出几个不同的具体实现，各种不同的command。

3.      命令者当中，给被命令者添加command，并可以要求被命令者执行。

4.      被命令者有个arraylist，用来存放需要执行的方法。被命令者提供addCommand方法，和executeCommands，undoCommands方法供命令者使用。

5.      个人感觉有点像，observer模式。被监听者同样提供一个arraylist，来添加监听类。

 

2.    State模式

State模式就是说，一个类的动作可以根据他不同的状态来执行不一样的代码。其实说白了就是把if语句用设计模式来实现了。

首先是抽象类：

package com.bjsxt.dp.state;

//定义抽象类，来规定方法的名称

publicabstractclass MMState {

    publicabstractvoid smile();

    publicabstractvoid cry();

    publicabstractvoid say();

}

 

两个不同的状态： happy和unhappy

package com.bjsxt.dp.state;

 

publicclass MMHappyStateextends MMState{

 

    @Override

    publicvoid cry() {

       //happy

    }

 

    @Override

    publicvoid say() {

       //hou mummy

      

    }

 

    @Override

    publicvoid smile() {

       //:)

      

    }

 

}

 

 

 

package com.bjsxt.dp.state;

 

publicclass MMUnHappyStateextends MMState{

 

    @Override

    publicvoid cry() {

       //unhappy

    }

 

    @Override

    publicvoid say() {

       //hou papa

      

    }

 

    @Override

    publicvoid smile() {

       //:(

      

    }

 

}

 

 

关键在于使用者的时候调用：

 

package com.bjsxt.dp.state;

 

publicclass MM {

    private Stringname;

   

    //mm的state作为一个成员变量,可以有不同的状态MMHappyState，MMUnHappyState

    private MMStatestate1 =newMMHappyState();

    private MMStatestate2 =new MMUnHappyState();

   

    public String getName() {

       returnname;

    }

 

    publicvoid setName(String name) {

       this.name = name;

    }

    //调用了MMHappyState的smile

    publicvoid smile() {

       state1.smile();

    }

    //调用了MMHappyState的cry

    publicvoid cry() {

       state1.cry();

    }

    //调用了MMHappyState的say

    publicvoid say() {

       state1.say();

    }

   

}

 

思想：

1.  首先一个抽象类state来定义方法的名字。

2.      可以有不同的，多个state的子类来表示不同的状态。

3.      具体是使用什么状态，是由使用者来指定。如果使用者选择的是happy，所有的方法都是happy的状态。如果使用者选择的是unhappy，所有的方法都是unhappy的状态。

4.      其实质就是一个if语句（面向过程的编程）:

if （MM.state==happy）。。。。。。。。

If（MM.state==unhappy）。。。。。。。。

5.      其实质就是一个多态的引用。给出一个抽象类state的引用，去指向不同的状态：

private MMStatestate1 =newMMHappyState();

private MMStatestate2 =new MMUnHappyState();

 

 

3.    Mediator 调停者（中介者）模式

通过一个mediator来调停不同的类之间的关系，所有的类都不需要互相交互，他们都和mediator打交道。所有的类都不直接和其他的类打交道。 Mediator是在系统的内部。

 

4.    Façade模式（大管家模式）

Façade模式和mediator模式思想一样，但是façade是面向系统外部的，而不是在系统内部的。使用者不和系统当中除了门面接口以外的所有的类打交道，而是通过这个门面接口类来调度和处理系统内部的复杂逻辑，使用者不需要知道这个系统内部的细节，由这个façade门面接口来执行统一的调配和处理。