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

        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本身已經提供了完美的支援，很多其它可見連結：

三、中介者模式

用一個中介對象來封裝一系列的對象互動。中介者使各對象不須要顯式地互相引用。進而使其耦合松散，而且能夠獨立地改變它們之間的互動。

    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 {

        System.out.println("前台注意了!");

        Mediator med = new ConcreteMediator();

        //老闆來了

        med.notice("boss");

        //客戶來了

        med.notice("client");

普通員工努力工作

前台注意了!

1.一組對象以定義良好可是複雜的方式進行通信。

産生的互相依賴關系結構混亂且難以了解。

2.一個對象引用其它非常多對象而且直接與這些對象通信,導緻難以複*該對象。

3.想定制一個分布在多個類中的行為。*又不想生成太多的子類。