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

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

一、解释器模式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.效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。

这个例子还是不够典型的，可以参考链接http://blog.csdn.net/feier7501/article/details/8604151里的例子。

二、迭代器模式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本身已经提供了完美的支持，更多可见链接：http://blog.csdn.net/chenhuade85/article/details/8146992

三、中介者模式

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
1.Mediator
中介者定义一个接口用于与各同事（Colleague）对象通信。

public abstract class Mediator {

public abstract void notice(String content);
}

2.ConcreteMediator具体中介者通过协调各同事对象实现协作行为。了解并维护它的各个同事。
public *lass ConcreteMediator e*tends Mediator {

private ColleagueA ca;

pri*ate ColleagueB cb;

public ConcreteMediator() {
ca = new ColleagueA();
cb = new Col*eagueB();
}

public void no*ice(String content) {
if (co*tent.equals("boss")) {
//老板来了, 通知员工A
ca*action();
}
if (content.equals("client")) {
//客户来了, *知前台B
cb.action();
}
}
}

3.Colleagueclass每一个同事类都知道它的中介者对象。 每一个同事对象在需与其他的同事通信的时候*与它的中介者通信。
public class ColleagueA extends Colleague {


public void action() {
System.out.println("普通员工努力工作");
}
}

public class ColleagueB extends Colleague {

public void action() {
System.out.println("前台注意了!");
}
}
测试代码：
public class Test {

public static void main(String[] args) {
Mediator med = new ConcreteMediator();
//老板来了
med.notice("boss");

//客户来了
med.notice("client");
}
}
result

普通员工努力工作
前台注意了!

适用性：
1.一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
2.一个对象引用其他很多对象并且直接与这些对象通信,导致难以复*该对象。
3.想定制一个分布在多个类中的行为，*又不想生成太多的子类。

更多可参考链接：http://blog.csdn.net/chenhuade85/article/details/8141831