三、行为型模式

行为型模式是使用较为频繁也是相对有些理解难度的模式。主要针对不同的业务需求对对象的行为进行优化和改进，使之更加合理，让业务更加流畅稳定，同时也更便于代码阅读理解。
行为型模式主要包括观察者模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、状态模式、策略模式、访问者模式。以下详细介绍。

观察者模式

这种模式主要用于监听对象的行为或状态变化，当被观察对象的状态发生改变时，迅速通知到观察者，因此通常是一对多的关系，即一个被观察者多个观察者。比如警察常常要接听报警电话，观察者就是警察，观察对象就是每一个报警求助的人，观察途径就是电话。另外求助者可能向警察求助，也有可能想亲朋好友求助，所以可能会有多个观察者。如下图：

image.png

报警电话为一个接口，警察和求助者都持有，这是他们互通信息的一个通道。

public interface DangerListener {
    void somethingHappen(String event);
}

求助者拥有一个电话本，只要有人告诉他号码他就会存下来，和他断交就会删掉这个号码，因此他有一个电话集合。当他遇到危险，就会把这个信息向电话集合中的人群发扩散以获得帮助。

public class HelperSeeker {

    private List<DangerListener> listeners = new ArrayList<>();
    private static HelperSeeker seeker;

    public static HelperSeeker getInstance(){
        if (seeker == null){
            seeker = new HelperSeeker();
        }
        return seeker;
    }

    public void registerDanger(DangerListener listener){
        listeners.add(listener);
    }

    public void unRegisterDanger(DangerListener listener){
        listeners.remove(listener);
    }

    public void help(){
        for (DangerListener listener:listeners){
            listener.somethingHappen("help");
        }
    }

}

警察拥有这个求助者的信息，并告诉他自己的联系方式，当收到他的求助信息时就会采取保护行动。当警察换岗位或者离职或是退休之后就会告诉该求助者不用保存自己的号码了。

public class ObserverPolice {

    private DangerListener listener = new DangerListener() {
        @Override
        public void somethingHappen(String event) {
            System.out.println("ObserverPolice receive msg for "+event);
        }
    };

    public void action(){
        HelperSeeker seeker = HelperSeeker.getInstance();
        seeker.registerDanger(listener);
    }


    public void onChange(){
        HelperSeeker.getInstance().unRegisterDanger(listener);
    }

}

责任链模式

责任链模式即接受者在处理请求的时候创建了一个对象链来进行事件处理，这个对象链中每个接受者都拥有下一个的引用，当自己能处理该请求时则自己处理掉，不能处理的话往下传递，直至处理完毕。类似“击鼓传花”。
例如，当前要实现一个打印日志的功能，日志分三个级别，一般日志，错误日志和文件日志。等级越高的日志越是要谨慎打印，等级低的限制宽松一些，一般的都要打印。
还举个例子，屏幕上有一个弹窗，弹窗上会进行一些操作也会弹窗，弹窗上又有可能弹窗，简而言之有多重弹窗，假如现在有三层弹窗，在最底层的页面突然收到一个消息，要求把所有弹窗都消失掉。这时应该怎么处理呢？
由于最底层的页面是不应该全部持有这三个弹窗的引用的，否则就会造成管理混乱，所以在收到通知的时候只需要在onDimiss()方法中将上面的一个弹窗取消掉就行，而上一个弹窗在取消的时候只需要判断它上面有没有弹窗，有的话就取消就行了，如此类推。当一个弹窗取消的时候，它上面的所有弹窗都会取消掉。每一个弹窗都持有下一个弹窗的引用，都只负责自己是否取消。

image.png

代码如下：
基类logger

public abstract class Logger {

    public static final int LEVEL_CONSOLE = 0;
    public static final int LEVEL_ERROR = 1;
    public static final int LEVEL_FILE = 2;

    private Logger nextLogger = getNextLogger();

    protected abstract Logger getNextLogger();

    private int curLevel = getLevel();

    protected abstract int getLevel();

    protected void loggerMsg(int level,String msg){
        if (curLevel <= level){
            logger(msg);
            if (nextLogger != null){
                nextLogger.logger(msg);
            }
        }
    }

    protected abstract void logger(String msg);

}

三个子类ConsoleLogger，ErrorLogger和FileLogger

public class ConsoleLogger extends Logger {

    @Override
    protected Logger getNextLogger() {
        return new ErrorLogger();
    }

    @Override
    protected int getLevel() {
        return Logger.LEVEL_CONSOLE;
    }

    @Override
    protected void logger(String msg) {
        System.out.println("ConsoleLogger " + msg);
    }
}

public class ErrorLogger extends Logger{
    @Override
    protected Logger getNextLogger() {
        return new FileLogger();
    }

    @Override
    protected int getLevel() {
        return Logger.LEVEL_ERROR;
    }

    @Override
    protected void logger(String msg) {
        System.out.println("ErrorLogger "+msg);
    }
}

public class FileLogger extends Logger{
    @Override
    protected Logger getNextLogger() {
        return null;
    }

    @Override
    protected int getLevel() {
        return Logger.LEVEL_FILE;
    }

    @Override
    protected void logger(String msg) {
        System.out.println("FileLogger "+msg);
    }
}

测试

public class Test {

    public static void main(String[] args) {
        ConsoleLogger logger = new ConsoleLogger();
        logger.loggerMsg(Logger.LEVEL_ERROR,"error msg");
    }

}

打印结果

ConsoleLogger error msg
ErrorLogger error msg

命令模式

命令模式就是将命令者和命令本身以及命令对象分别进行封装，这样再多的命令都可以简化。达到了对象之间的解耦。
将命令者和命令都抽象成接口，命令者持有命令引用而不关心命令如何去实现。一个典型的例子就是Android当中的各个view。每个view都拥有自己的一套绘制流程，onMeasure(),onLayout(),onDraw(),等，view作为一个基类抽象了这些方法，而同时每个view又都是可以被点击的，即view的触摸事件分发，这一套也抽象成了接口方法。基类持有这一引用，具体的实现则由各自去实现。例如onClick(),onLongClick(),onDrag()等。如下图：

image.png

View

public abstract class View {
    protected TouchEvent touchEvent;
    protected String name;

    public View(String name,TouchEvent touchEvent) {
        this.name = name;
        this.touchEvent = touchEvent;
    }

    public void touch(){
        touchEvent.onTouch();
    }

    public String getName(){
        return name;
    }

}

TextView

public class TextView extends View{
    public TextView(String name, TouchEvent touchEvent) {
        super(name, touchEvent);
    }
}

TouchEvent

public interface TouchEvent {
    void onTouch();
}

DragEvent

public class DragEvent implements TouchEvent{
    @Override
    public void onTouch() {
        System.out.println("DragEvent ...");
    }
}

ClickEvent

public class ClickEvent implements TouchEvent{
    @Override
    public void onTouch() {
        System.out.println("ClickEvent ...");
    }
}

测试代码：

    public static void main(String[] args) {
        ClickEvent clickEvent = new ClickEvent();
        DragEvent dragEvent = new DragEvent();
        TextView textView1 = new TextView("textView1",clickEvent);
        System.out.print(textView1.getName()+" ");
        textView1.touch();
        TextView textView2 = new TextView("textView2",dragEvent);
        System.out.print(textView2.getName()+" ");
        textView2.touch();
    }

迭代器模式

这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。一般用于集合中，例如iterator接口，它的实现类有很多种如ArrayList()，LinkList()等等，具体可以直接看jdk源码。