Java经典23种设计模式之行为型模式(二)

阅读量：5328 次

发布时间：2019-06-14

本文共 4642 字，大约阅读时间需要 15 分钟。

本文接着介绍行为型模式里的解释器模式、迭代器模式、中介者模式。

一、解释器模式Interpret

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

1.AbstractExpression(抽象表达式) 声明一个抽象的解释操作，这个接口为抽象语法树中全部的节点所共享。

public abstract class Expression {

abstract void interpret(Context ctx);

}

2.Expression 实现与文法中的终结符相关联的解释操作。

public class AdvanceExpression extends Expression {    void interpret(Context ctx) {        System.out.println("这是高级解析器!");    }}public class SimpleExpression extends Expression {    void interpret(Context ctx) {        System.out.println("这是普通解析器!");    }}

3.Context（上下文）包括解释器之外的一些全局信息。

public class Context {    private String content;        private List list = new ArrayList();        public void setContent(String content) {        this.content = content;    }        pu*lic String getContent() {        return this.content;    }        public void add(Expression eps) {        list.add(eps);    }        public List getList() {        return list;    }}

測试代码：

public class Test {

public static void main(String[] args) {

Context ctx = new Context();

ctx.add(new SimpleExpression());

ctx.add(new AdvanceExpression());

ctx.add(new SimpleExpression());

for (Expression eps : ctx.getList()) {

eps.interpret(ctx);

}

result

这是普通解析器!

这是高级解析器!

这是普通解析器!

适用性：

当有一个语言须要解释运行,而且你可将该语言中的句子表示为一个抽象语法树时，可使

用解释器模式。而当存在*下情况时该模式效果最好：

1.该文法简单对于复杂的文法,文法的*层次变得庞大而无法管理。

2.效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成还有一种形式。

这个样例还是不够典型的，能够參考链接里的样例。

二、迭代器模式Interator

提供一种方法訪问一个容器对象中的各个元素。而又不暴漏该对象的内部细节。号称是Java里使用最多的模式。

1.Iterator 迭代器定义訪问和遍历元素的接口。

public interface Iterator {

Object next();

void first();

void last();

boolean hasNext();

}

2.ConcreteIterator详细迭代器实现迭代器接口。对该聚合遍历时跟踪当前位置。

public class IteratorImpl implements Iterator {    private List list;        private int index;        public Ite*atorImpl(List list* {        index = 0;        this.list = list;    }        public void first() {        index = 0;    }    public void last() {        index = list.getSize();    }    public Object next() {        Object obj = list.get(index);        index++;        ret*rn obj;    }    public boolean hasNext() {        return index < list.getSize();    }}

3.Aggregate聚合定义创建对应迭代器对象的接口。

public interface List {

    Iterator iterator();

Object get(int index);

int getSize();

void add(Object obj);

}

4.ConcreteAggregate详细聚合实现创建对应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例.

public class ListImpl implements List {    private Object[] list;        private int index;        private int size;        public ListImpl() {        index = 0;        size = 0;        list = new Object[100];    }        public Iterator iterator() {        return new IteratorImpl(this);    }        public O*ject get(int index) {        return list[index];    }        public int getSize() {        return this.size;    }        public void add(Object obj) {        list[index++] = obj;        size++;    }}

測试代码：

public class Test {    public stati* void main(String[] arg*) {        List list = new ListImpl();        list.add("a");        list.add("b");        list.add("c");        //第一种迭代方式        Iterator it = list.iterator();        while (*t.ha*Next()) {            S*stem.out.println(it.next());        }                Syst*m.out.println("=====");        //另外一种迭代方式        for (int i = 0; i < list.getSize(); i++) {            System.out.println(list.get(i));        }    }}

适用性：

1.訪问一个聚合对象的内容而无需暴露它的内部表示。

2.支持对聚合对象的多种遍历。

3.为遍历不同的聚合结构提供一*统一的接口(即,支持多态迭代)。

迭代器模式非经常常使用。java本身已经提供了完美的支持，很多其它可见链接：