23种设计模式模式详解 Java 行为型模式（三）

23种设计模式模式详解 Java 行为型模式（三）

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式的好处：代码的可重用性、可扩展性，可阅读性，保证代码的可靠。（代码要优雅）

关于相关源码可以在GitHub上下载：
https://github.com/rickey17/design

• 策略模式
• 模板方法模式
• 观察者模式
• 迭代子模式
• 责任链模式
• 命令模式
• 备忘录模式
• 状态模式
• 访问者模式
• 中介者模式
• 解释器模式

---

策略模式

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口。

UML图：

策略很好理解，源码就不贴了。

模板方法模式

解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1…n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。

源码：

public abstract class Template {

    public abstract int method();

    public int templateMethod(){
        return method();
    }

}

public class TemplateUser extends Template {

    public int method(){
        return 0;
    }

}

Template 定义一个模板方法，但是具体实现，确实用抽象方法，等待子类去实现。
spring中大量用到这种方法。如AbstractApplicationContext的refresh()函数启动spring容器。

观察者模式

观察者模式很好理解，当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。

UML图：

理解起来也很简单，就是被观察者持有观察者对象。

迭代子模式

迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。

UML 类图：

源码：

public class MyCollection implements Collection {

    private String[] c = {"A","B","C","D","E"};  

    public Object get(){
         return c[i];
    }

    public Iterator iterator(){
        return new Iterator(this);
    }

    public Object get(int i) {  
       return c.length;
    }  

}

public class MyIterator implements Iterator {

    private Collection collection;

    private int pos = -1;  

    public MyIterator(Collection collection){
        this.collection = collection;
    }

    public Object first(){
        pos = 0;  
        return collection.get(pos);  
    }

    public boolean hasNext(){
        if(pos<collection.size()-1){  
            return true;  
        }else{  
            return false;  
        }  
    }

    public Object next(){
        if(pos<collection.size()-1){  
            pos++;  
        }  
        return collection.get(pos); 
    }

}

迭代类持有集合类对象，集合类只是依赖于迭代类

责任链模式

有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。

UML 类图如下：

代码：

public interface Handler {  
    void operator();  
} 

public abstract class AbstractHandler {  

    private Handler handler;  

    public Handler getHandler() {  
        return handler;  
    }  

    public void setHandler(Handler handler) {  
        this.handler = handler;  
    }  

}  

public class MyHandler extends AbstractHandler implements Handler {  

    private String name;  

    public MyHandler(String name) {  
        this.name = name;  
    }  

    @Override  
    public void operator() {  
        System.out.println(name+"deal!");  
        if(getHandler()!=null){  
            getHandler().operator();  
        }  
    }  
}  

public class Test {  

    public static void main(String[] args) {  
        MyHandler h1 = new MyHandler("h1");  
        MyHandler h2 = new MyHandler("h2");  
        MyHandler h3 = new MyHandler("h3");  

        h1.setHandler(h2);  
        h2.setHandler(h3);  

        h1.operator();  
    }  
}  

可以结合spring MVC去理解

命令模式

通过把命令看做一个对象，实现发布命令和执行命令之间的解耦。

举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。

UML 类图：

比较好理解，就是对象一级一级的持有下一级对象

备忘录模式

主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。

UML 类图如下

源码：

public class Memento {  

    private String value;  

    public Memento(String value) {  
        this.value = value;  
    }  

    public String getValue() {  
        return value;  
    }  

    public void setValue(String value) {  
        this.value = value;  
    }  
}  

public class Original {  

    private String value;  

    public String getValue() {  
        return value;  
    }  

    public void setValue(String value) {  
        this.value = value;  
    }  

    public Original(String value) {  
        this.value = value;  
    }  

    public Memento createMemento(){  
        return new Memento(value);  
    }  

    public void restoreMemento(Memento memento){  
        this.value = memento.getValue();  
    }  
}  

public class Storage {  

    private Memento memento;  

    public Storage(Memento memento) {  
        this.memento = memento;  
    }  

    public Memento getMemento() {  
        return memento;  
    }  

    public void setMemento(Memento memento) {  
        this.memento = memento;  
    }  
}  

状态模式

当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点：1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。

UML 类图

很好理解，一个上下文对象持有状态类，当状态类发生变化时，选择不同的方法。

访问者模式

访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。

简单来说，访问者模式就是一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。

UML 类图：

访问者访问主体，主体接受访问，两者相互依赖

源码

public class MyVisitor implements IVisitor {  

    @Override  
    public void visit(Subject sub) {  
        System.out.println("visit the subject："+sub.getSubject());  
    }  
}  

public class MySubject implements ISubject {  

    @Override  
    public void accept(Visitor visitor) {  
        visitor.visit(this);  
    }  

    @Override  
    public String getSubject() {  
        return "love";  
    }  
}  

中介者模式

中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用。

UML 类图：

User类统一接口，User1和User2分别是不同的对象，二者之间有关联，如果不采用中介者模式，则需要二者相互持有引用，这样二者的耦合度很高，为了解耦，引入了Mediator类，提供统一接口，MyMediator为其实现类，里面持有User1和User2的实例，用来实现对User1和User2的控制。这样User1和User2两个对象相互独立，他们只需要保持好和Mediator之间的关系就行，剩下的全由MyMediator类来维护！

源码：

public class MyMediator implements Mediator {  

    private User user1;  
    private User user2;  

    public User getUser1() {  
        return user1;  
    }  

    public User getUser2() {  
        return user2;  
    }  

    @Override  
    public void createMediator() {  
        user1 = new User1(this);  
        user2 = new User2(this);  
    }  

    @Override  
    public void workAll() {  
        user1.work();  
        user2.work();  
    }  
} 

public abstract class User {  

    private Mediator mediator;  

    public Mediator getMediator(){  
        return mediator;  
    }  

    public User(Mediator mediator) {  
        this.mediator = mediator;  
    }  

    public abstract void work();  
}  

解释器模式

给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。

Context类是一个上下文环境类，Plus和Minus分别是用来计算的实现，解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等！