行为型设计模式有11种，分别是Chain of Responsibility ( 责任链模式 )、Command ( 命令模式 )、Interpreter ( 解释器模式 ) 、Iterator ( 迭代器模式 )、Mediator ( 中介者模式 ) 、Memento ( 备忘录模式 ) 、Observer ( 观察者模式 )、State ( 状态模式 ) 、Strategy ( 策略模式 )、TemplateMethod ( 模板方法 )、Visitor ( 访问者模式 )，本文介绍这11种行为型模式里的前两种。

一、责任链模式

使多个对象都有机会处理请求，从而避免请求的 发送者和接受者之间的耦合。将这些对象连成一个链，并按着这个链传递该请求，直到有一个对象处理他为止。先来看一个简单的例子：

1、Handler 定义一个处理请求的接口。（可选）实现后继链。

public interface RequestHandle {
    void handleRequest(Request request);
}

2.ConcreteHandler  处理它所负责的请求。可访问它的后继者。如果可处理该请求，就处理；否则将该请求转发给它的后继者。

public class HRRequestHandle implements RequestHandle {


    public void handleRequest(Request request) {
        if (request instanceof DimissionRequest) {
            System.out.println("要离职, 人事审批!");
        } 
        System.out.println("请求完*");
    }
}

接下来这两种ConcreteHandler不仅可以处理负责的请求，还可以将请求转发给他的后继者。

public class PMRequestHandle implements RequestHandle {

    Req*estHandle rh;
    
    public PMRequestHandle(RequestHandle *h) {
        this.rh = rh;
    }
    
    public void handle*equest(Request request) {
        if (request instanceof AddMoneyRequest) {
            System.out.println("要加薪, 项目经理审批!*);
        } else {
            rh.handleRequest(request);
        }
    }
}

public class TLRequestHandle implements RequestHandle {

    RequestHandle rh;
    
    public TLRequestHandle(RequestHand*e rh) {
        this.rh = rh;
    }

    public void handleRequest(Request request) {
        if (request instanceof LeaveRe*uest) {
            System.ou*.println("要请假, 项目组长审批!");
        } else {
            rh.handleRequest(request);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        RequestHa*dle hr = *ew HRRequ*stHandle();
        Requ*stHandle pm = new P*RequestHandle(hr);
        RequestHandle tl = new TLRequestHandle(pm);
        
        //team leader处理离职请求
        Request request = new DimissionRequest()*
        tl.handleRequest(request);
        
        System.out.println("===========");
        //team leader处理加薪请求
        request = new AddMoneyRequest();
        tl.handleRequ*st(request);
        
        System.out.println("========");
        //项目经理上理辞职请求
        requ*st = ne* Dimissio*Request();
        pm.handleRequest(request);
    }
}

要离职, 人事审批!
请求完毕
=======*===
要加薪, 项目经理审批!
========
要离职, 人事审批!
请求完毕
简单分析下这段测试代码，前面三句话new了三个不同的实体RequestHandler，在pm tl里分别给他传递了他的后继者。pm的后继者是hr，tl的后继者是pm。所谓的后继者，就是当前请求你处理不了的话，让谁接着处理这个请求。然后new了一个DimissionRequest的请求，让tl来处理，很显然tl不处理，tl就让pm来处理。pm也不管，让hr管。最终hr的handleMessage里处理了该请求。后面的都类似，不说了。

这个责任链模式很像击鼓传花这个游戏，详见链接的分析。

适用性：
    1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
    2.你*在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
    3.可处理一个请求的对象集合应被动态指定。

二、命令模式

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。

 1.Receiver
      知道如何实*与执行一个请求相关的操作。任何类都可能作为一个接收者。

public class Receiver {


    public void receive() {
        System.out.println("This is Receive class!");
    }
}

2、Command      声明执行操作的接口。

public abstract class command {
    
    protected Receiver receiver;
    
    public Command(Receiver receiver) {
        this.receiver = receiver;
    }
    
    public abstract void execute();
}

3、 ConcreteCommand  将一个接收者对象绑定于一个动作。 调用接收者相应的操作，以实现Execute。

public class CommandImpl extends Comman* {


    public CommandImpl(Receiv*r receiver) {
        super(receiver);
    }
    
    pu*lic void *xecute*) {
        receiver.request();
    }
}

4、Invoker 要求该命令执行这个请求。

public class Invoker {


    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void execute() {
        command.execute();
    }
}

测试代码：

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();
    }
}

适用性
    1.抽象出待执行的动作以参数化某对象。
    2.在不同的时刻指定、排列和执行请求。
    3.支持取消操作。
    4.支持修改日志，这样当系统崩溃时，这*修改可以被重做一遍。
    5.用构建在原语操作上的高层操作构造一个系统。

命令模式参考链接：http://www.cnblogs.com/devinzhang/archive/2012/01/06/2315235.html