Java设计模式（疯狂Java联盟版）
Strategy ( 策略模式 ) TemplateMethod ( 模板方法 ) Vis*tor ( 访问者模式 )
1.3.1 责任链模式
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，
这条链传递该请求，直到有一个对象处理它为止。
这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者.
适用性
1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。 2.你在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3.可处理一个请求的对象集合应被动态指定。
参与者
1.Handler
定义一个处理请求的接口。 （可选）实现后继链。 2.ConcreteHandler
处理它所负责的请求。 可访问它的后继者。
如果可处理该请求，就处理；否则将该请求转发给它的后继者。 3.Client
向链上的具体处理者(ConcreteHandler)对象提交请求。
类图 例子 Hand*er
public interface RequestHandle {
void handleRequest(Request request); }
ConcreteHandler
public class HRRequestHandle implements RequestHandle { public void handleRequest(Request request) { if (request instanceof DimissionRequest) { System.out.println(\要离职, 人事审批!\ }
System.out.println(\请求完成\ } }
public class PMRequestHandle implements RequestHandle { RequestHandle rh;
public PMRequestHandle(RequestHandle rh) { this.rh = rh; }
25
Java设计模式（疯狂Java联盟版）
public void handleRequest(Request request) { if (request instanceof AddMoneyRequest) {
System.out.println(\要加薪, 项目经理审批!\ } else {
rh.handleRequest(request); } } }
public class TLRequestHandle implements RequestHandle { RequestHandle rh;
public TLRequestHandle(RequestHandle rh) { this.rh = rh; }
public void handleRequest(Request request) { if (request instanceof LeaveRequest) {
System.out.println(\要请假, 项目组长审批!\ } else {
rh.handleRequest(request); } } }
Client
public class Test {
public static void main(String[] args) { RequestHandle hr =new HRRequestHandle(); RequestHandle pm = new PMRequestHandle(hr); RequestHandle tl = new TLRequestHandle(pm); //team leader处理离职请求
Request request = new DimissionRequest(); tl.handleRequest(request);
System.out.println(\ //team leader处理加薪请求
request = new AddMoneyRequest(); tl.handleRequest(request);
System.out.println(\ //项目经理上理辞职请求
request = new DimissionRequest(); pm.handleRequest(request); } }
result
要离职, 人事审批! 请求完毕 =======*===
要加薪, 项目经理审批!
26
Java设计模式（疯狂Java联盟版）
========
要离职, 人事审批! 请求完毕
1.3.2 命令模式
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。
适用性
1.抽象出待执行的动作以参数化某对象。 2.在不同的时刻指定、排列和执行请求。 3.支持取消操作。
4.支持修改日志，这样当系统崩溃时，这修改可以被重做一遍。 5.用构建在原语操作上的高层操作构造一个系统。
参与者
1.Command
声明执行操作的接口。 2.ConcreteCommand
将一个接收者对象绑定于一个动作。
调用接收者相应的操作，以实现Execute。 3.Client
创建一个具体命令对象并设定它的接收者。 4.Invoker
要求该命令执行这个请求。 5.Receiver
知道如何实现与执行一个请求相关的操作。任何类都可能作为一个接收者。
类图 例子
Command声明执行操作的接口
public abstract class Command { protected Receiver receiver;
public Command(Receiver receiver) { this.receiver = receiver; }
public abstract void execute(); }
ConcreteCommand将一个接收者对象绑定于一个动作。 调用接收者相应的操作，以实现Execute。
public class CommandImpl extends Command { public CommandImpl(Receiver receiver) { super(receiver); }
public void execute() {
27
Java设计模式（疯狂Java联盟版）
receiver. receive (); } }
Invoker要求该命令执行这个请求。 public class Invoker {
private Command command;
public void setCommand(Command command) { this.command = command; }
public void execute() { command.execute(); } }
Receiver知道如何实现与执行一个请求相关的操作。任何类都可能作为一个接收者。 public class Receiver { public void receive() {
System.out.println(\ } }
Test
public class Test {
public static void main(String[] args) { Receiver rec = new Receiver();
Command cmd = new CommandImpl(rec); Invoker i = new Invoker(); i.setCommand(cmd); i.execute(); } }
result
This is Receive class!
1.3.3 解释器模式
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
适用性
当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使 用解释器模式。而当存在以下情况时该模式效果最好：
1.该文法简单对于复杂的文法,文法的层次变得庞大而无法管理。
2.效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。
参与者
1.AbstractExpression(抽象表达式)
28
Java设计模式（疯狂Java联盟版）
声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。 2.TerminalExpression(终结符表达式)
实现与文法中的终结符相关联的解释操作。 一个句子中的每个终结符需要该类的一个实例。 3.N*nterminalExpression(非终结符表达式)
为文法中的非终结符实现解释(Interpret)操作。 4.Context（上下文）
包含解释器之外的一些全局信息。 5.Client（客户）
构建(或被给定)表示该文法定义的语言中*个特定的句子的抽象*法树。
该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。 调用解*操作。
类图 例子
AbstractExpression声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
public abstract class Expression {
abstract void interpret(Context ctx); }
Expression
public class AdvanceExpression extends Expression { void interprot(Context ctx) {
System.out.println(\这是高级解析器!\ } }
public class SimpleExpression extends Expression { void interpret(Context ctx) {
System.out.println(\这是普通解析器!\ } }
Context
public class Context {
private String content;
private List list = new ArrayList(); public void setContent(String content) { this.content = content; }
public String getContent() { return this.content; }
public void add(Expression eps) { list.add(eps); }
public List getList() { return list; } }
29