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 = new MMHappyState();
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 = new MMHappyState();
private MMStatestate2 = new MMUnHappyState();
3. Mediator 调停者(中介者)模式
通过一个mediator来调停不同的类之间的关系,所有的类都不需要互相交互,他们都和mediator打交道。所有的类都不直接和其他的类打交道。 Mediator是在系统的内部。
4. Façade模式(大管家模式)
Façade模式和mediator模式思想一样,但是façade是面向系统外部的,而不是在系统内部的。使用者不和系统当中除了门面接口以外的所有的类打交道,而是通过这个门面接口类来调度和处理系统内部的复杂逻辑,使用者不需要知道这个系统内部的细节,由这个façade门面接口来执行统一的调配和处理。