Java 設計模式系列（二三）訪問者模式(Vistor)

訪問者模式是對象的行為模式。訪問者模式的目的是封裝一些施加於某種數據結構元素之上的操作。一旦這些操作需要修改的話，接受這個操作的數據結構則可以保持不變。

一、訪問者模式結構

訪問者模式適用於數據結構相對未定的系統，它把數據結構和作用於結構上的操作之間的耦合解脫開，使得操作集合可以相對自由地演化。

數據結構的每一個節點都可以接受一個訪問者的調用，此節點向訪問者對象傳入節點對象，而訪問者對象則反過來執行節點對象的操作。這樣的過程叫做“雙重分派”。節點調用訪問者，將它自己傳入，訪問者則將某算法針對此節點執行。訪問者模式的示意性類圖如下所示：

訪問者模式涉及到的角色如下：

• 抽象訪問者(Visitor)角色：聲明了一個或者多個方法操作，形成所有的具體訪問者角色必須實現的接口。

• 具體訪問者(ConcreteVisitor)角色：實現抽象訪問者所聲明的接口，也就是抽象訪問者所聲明的各個訪問操作。

• 抽象節點(Node)角色：聲明一個接受操作，接受一個訪問者對象作為一個參數。

• 具體節點(ConcreteNode)角色：實現了抽象節點所規定的接受操作。

• 結構對象(ObjectStructure)角色：有如下的責任，可以遍歷結構中的所有元素；如果需要，提供一個高層次的接口讓訪問者對象可以訪問每一個元素；如果需要，可以設計成一個復合對象或者一個聚集，如 List 或 Set。

源代碼

(1) Vistor

可以看到，抽象訪問者角色為每一個具體節點都準備了一個訪問操作。由於有兩個節點，因此，對應就有兩個訪問操作。

public interface Visitor {
    /** 對應於NodeA的訪問操作 */
    public void visit(NodeA node);

    /** 對應於NodeB的訪問操作 */
    public void visit(NodeB node);
}

public class VisitorA implements Visitor {
    /** 對應於NodeA的訪問操作 */
    @Override
    public
 
 void visit(NodeA node) {
        System.out.println(node.operationA());
    }

    /** 對應於NodeB的訪問操作 */
    @Override
    public void visit(NodeB node) {
        System.out.println(node.operationB());
    }
}

public class VisitorB implements Visitor {
    /** 對應於NodeA的訪問操作 */
    @Override
    public void visit(NodeA node) {
        System.out.println(node.operationA());
    }

    /** 對應於NodeB的訪問操作 */
    @Override
    public void visit(NodeB node) {
        System.out.println(node.operationB());
    }
}

(2) Node

public abstract class Node {
    /** 接受操作 */
    public abstract void accept(Visitor visitor);
}

public class NodeA extends Node{
    /** 接受操作 */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    /** NodeA特有的方法 */
    public String operationA(){
        return "NodeA";
    }
}

public class NodeB extends Node{
    /** 接受方法 */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    /** NodeB特有的方法 */
    public String operationB(){
        return "NodeB";
    }
}

(3) ObjectStructure

public class ObjectStructure {

    private List<Node> nodes = new ArrayList<Node>();

    /** 執行方法操作 */
    public void action(Visitor visitor) {
        for(Node node : nodes) {
            node.accept(visitor);
        }
    }

    /** 添加一個新元素 */
    public void add(Node node){
        nodes.add(node);
    }
}

(4) 測試

public class Client {

    public static void main(String[] args) {
        //創建一個結構對象
        ObjectStructure os = new ObjectStructure();
        //給結構增加一個節點
        os.add(new NodeA());
        //給結構增加一個節點
        os.add(new NodeB());
        //創建一個訪問者
        Visitor visitor = new VisitorA();
        os.action(visitor);
    }
}

二、分派的概念

變量被聲明時的類型叫做變量的靜態類型(Static Type)，有些人又把靜態類型叫做明顯類型(Apparent Type)；而變量所引用的對象的真實類型又叫做變量的實際類型(Actual Type)。比如：

List list = null;
list = new ArrayList();

聲明了一個變量 list，它的靜態類型（也叫明顯類型）是 List，而它的實際類型是 ArrayList。

根據對象的類型而對方法進行的選擇，就是分派(Dispatch)，分派(Dispatch)又分為兩種，即靜態分派和動態分派。

1. 靜態分派(Static Dispatch)發生在編譯時期，分派根據靜態類型信息發生。靜態分派對於我們來說並不陌生，方法重載就是靜態分派。

2. 動態分派(Dynamic Dispatch)發生在運行時期，動態分派動態地置換掉某個方法。

(1) 靜態分派

Java 通過方法重載支持靜態分派。

public class Mozi {
    
    public void ride(Horse h){
        System.out.println("騎馬");
    }
    
    public void ride(WhiteHorse wh){
        System.out.println("騎白馬");
    }
    
    public void ride(BlackHorse bh){
        System.out.println("騎黑馬");
    }
    
    public static void main(String[] args) {
        Horse wh = new WhiteHorse();
        Horse bh = new BlackHorse();
        Mozi mozi = new Mozi();
        mozi.ride(wh);
        mozi.ride(bh);
    }
}

顯然，Mozi 類的 ride() 方法是由三個方法重載而成的。這三個方法分別接受馬(Horse)、白馬(WhiteHorse)、黑馬(BlackHorse)等類型的參數。

那麽在運行時，程序會打印出什麽結果呢？結果是程序會打印出相同的兩行“騎馬”。換言之，墨子發現他所騎的都是馬。

為什麽呢？兩次對 ride() 方法的調用傳入的是不同的參數，也就是 wh 和 bh。它們雖然具有不同的真實類型，但是它們的靜態類型都是一樣的，均是 Horse 類型。

重載方法的分派是根據靜態類型進行的，這個分派過程在編譯時期就完成了。

(2) 動態分派

Java 通過方法的重寫支持動態分派。

public class Horse {
    public void eat(){
        System.out.println("馬吃草");
    }
}

public class BlackHorse extends Horse { 
    @Override
    public void eat() {
        System.out.println("黑馬吃草");
    }
}

public class Client {
    public static void main(String[] args) {
        Horse h = new BlackHorse();
        h.eat();
    }

}

變量 h 的靜態類型是 Horse，而真實類型是 BlackHorse。如果上面最後一行的 eat() 方法調用的是 BlackHorse 類的 eat() 方法，那麽上面打印的就是“黑馬吃草”；相反，如果上面的 eat() 方法調用的是 Horse 類的 eat() 方法，那麽打印的就是“馬吃草”。

所以，問題的核心就是 Java 編譯器在編譯時期並不總是知道哪些代碼會被執行，因為編譯器僅僅知道對象的靜態類型，而不知道對象的真實類型；而方法的調用則是根據對象的真實類型，而不是靜態類型。這樣一來，上面最後一行的 eat() 方法調用的是 BlackHorse 類的 eat() 方法，打印的是“黑馬吃草”。

(3) 分派的類型

一個方法所屬的對象叫做方法的接收者，方法的接收者與方法的參數統稱做方法的宗量。比如下面例子中的Test類

public class Test {

    public void print(String str){
        System.out.println(str);
    }
}

在上面的類中，print() 方法屬於 Test 對象，所以它的接收者也就是 Test 對象了。print() 方法有一個參數是 str,它的類型是 String。

根據分派可以基於多少種宗量，可以將面向對象的語言劃分為單分派語言(Uni-Dispatch)和多分派語言(Multi-Dispatch)。單分派語言根據一個宗量的類型進行對方法的選擇，多分派語言根據多於一個的宗量的類型對方法進行選擇。

C++ 和 Java 均是單分派語言，多分派語言的例子包括 CLOS 和 Cecil。按照這樣的區分，Java 就是動態的單分派語言，因為這種語言的動態分派僅僅會考慮到方法的接收者的類型，同時又是靜態的多分派語言，因為這種語言對重載方法的分派會考慮到方法的接收者的類型以及方法的所有參數的類型。

在一個支持動態單分派的語言裏面，有兩個條件決定了一個請求會調用哪一個操作：一是請求的名字，而是接收者的真實類型。單分派限制了方法的選擇過程，使得只有一個宗量可以被考慮到，這個宗量通常就是方法的接收者。在Java語言裏面，如果一個操作是作用於某個類型不明的對象上面，那麽對這個對象的真實類型測試僅會發生一次，這就是動態的單分派的特征。

(4) 雙重分派

一個方法根據兩個宗量的類型來決定執行不同的代碼，這就是“雙重分派”。Java 語言不支持動態的多分派，也就意味著 Java 不支持動態的雙分派。但是通過使用設計模式，也可以在 Java 語言裏實現動態的雙重分派。

在 Java 中可以通過兩次方法調用來達到兩次分派的目的。

三、總結

(1) 訪問者模式的優缺點

訪問者模式的優點

• 好的擴展性：能夠在不修改對象結構中的元素的情況下，為對象結構中的元素添加新的功能。

• 好的復用性：可以通過訪問者來定義整個對象結構通用的功能，從而提高復用程度。

• 分離無關行為：可以通過訪問者來分離無關的行為，把相關的行為封裝在一起，構成一個訪問者，這樣每一個訪問者的功能都比較單一。

訪問者模式的缺點

• 對象結構變化很困難：不適用於對象結構中的類經常變化的情況，因為對象結構發生了改變，訪問者的接口和訪問者的實現都要發生相應的改變，代價太高。

• 破壞封裝：訪問者模式通常需要對象結構開放內部數據給訪問者和 ObjectStructrue，這破壞了對象的封裝性。

每天用心記錄一點點。內容也許不重要，但習慣很重要！

Java 設計模式系列（二三）訪問者模式(Vistor)