《JAVA與模式》之訪問者模式

標籤：amd   efi   eve   jsf   方法指派   3nf   c++和java   pfx   aaaaa   

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

指派的概念

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

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

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

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

　　靜態指派(Static Dispatch)發生在編譯時間期，指派根據靜態類型資訊發生。靜態指派對於我們來說並不陌生，方法重載就是靜態指派。

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

　靜態指派

　　Java通過方法重載支援靜態指派。用墨子騎馬的故事作為例子，墨子可以騎白馬或者黑馬。墨子與白馬、黑馬和馬的類圖如下所示：

　　在這個系統中，墨子由Mozi類代表

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類型。

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

　動態指派

　　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()方法，列印的是“黑馬吃草”。

　指派的類型

　　一個方法所屬的對象叫做方法的接收者，方法的接收者與方法的參數統稱做方法的宗量。比如下面例子中的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語言裡面，如果一個操作是作用於某個類型不明的對象上面，那麼對這個對象的真實類型測試僅會發生一次，這就是動態單指派的特徵。

　雙重指派

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

　　在Java中可以通過兩次方法調用來達到兩次指派的目的。類圖如下所示：

　　在圖中有兩個對象，左邊的叫做West，右邊的叫做East。現在West對象首先調用East對象的goEast()方法，並將它自己傳入。在East對象被調用時，立即根據傳入的參數知道了調用者是誰，於是反過來調用“調用者”對象的goWest()方法。通過兩次調用將程式控制權輪番交給兩個對象，其時序圖如下所示：

　　這樣就出現了兩次方法調用，程式控制權被兩個對象像傳球一樣，首先由West對象傳給了East對象，然後又被返傳給了West對象。

　　但是僅僅返傳了一下球，並不能解決雙重指派的問題。關鍵是怎樣利用這兩次調用，以及Java語言的動態單指派功能，使得在這種傳球的過程中，能夠觸發兩次單指派。

　　動態單指派在Java語言中是在子類重寫父類的方法時發生的。換言之，West和East都必須分別置身於自己的類型等級結構中，如所示：

　　原始碼

　　West類

public abstract class West {        public abstract void goWest1(SubEast1 east);        public abstract void goWest2(SubEast2 east);}

　　SubWest1類

public class SubWest1 extends West{        @Override    public void goWest1(SubEast1 east) {                System.out.println("SubWest1 + " + east.myName1());    }        @Override    public void goWest2(SubEast2 east) {                System.out.println("SubWest1 + " + east.myName2());    }}

　　SubWest2類

public class SubWest2 extends West{    @Override    public void goWest1(SubEast1 east) {                System.out.println("SubWest2 + " + east.myName1());    }        @Override    public void goWest2(SubEast2 east) {                System.out.println("SubWest2 + " + east.myName2());    }}

　　East類

public abstract class East {    public abstract void goEast(West west);}

　　SubEast1類

public class SubEast1 extends East{    @Override    public void goEast(West west) {        west.goWest1(this);    }        public String myName1(){        return "SubEast1";    }}

　　SubEast2類

public class SubEast2 extends East{    @Override    public void goEast(West west) {        west.goWest2(this);    }        public String myName2(){        return "SubEast2";    }}

　　用戶端類

public class Client {    public static void main(String[] args) {        //組合1        East east = new SubEast1();        West west = new SubWest1();        east.goEast(west);        //組合2        east = new SubEast1();        west = new SubWest2();        east.goEast(west);    }}

　　運行結果如下

SubWest1 + SubEast1
SubWest2 + SubEast1

 

　　系統運行時，會首先建立SubWest1和SubEast1對象，然後用戶端調用SubEast1的goEast()方法，並將SubWest1對象傳入。由於SubEast1對象重寫了其超類East的goEast()方法，因此，這個時候就發生了一次動態單指派。當SubEast1對象接到調用時，會從參數中得到SubWest1對象，所以它就立即調用這個對象的goWest1()方法，並將自己傳入。由於SubEast1對象有權選擇調用哪一個對象，因此，在此時又進行一次動態方法指派。

　　這個時候SubWest1對象就得到了SubEast1對象。通過調用這個對象myName1()方法，就可以列印出自己的名字和SubEast對象的名字，其時序圖如下所示：

　　由於這兩個名字一個來自East等級結構，另一個來自West等級結構中，因此，它們的組合式是動態決定的。這就是動態雙重指派的實現機制。

訪問者模式的結構

　　訪問者模式適用於資料結構相對未定的系統，它把資料結構和作用於結構上的操作之間的耦合解脫開，使得操作集合可以相對自由地演化。訪問者模式的簡略圖如下所示：

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

　　

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

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

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

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

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

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

　　原始碼

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

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

　　具體訪問者VisitorA類

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

　　具體訪問者VisitorB類

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

　　抽象節點類

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

　　具體節點類NodeA

public class NodeA extends Node{    /**     * 接受操作     */    @Override    public void accept(Visitor visitor) {        visitor.visit(this);    }    /**     * NodeA特有的方法     */    public String operationA(){        return "NodeA";    }}

　　具體節點類NodeB

public class NodeB extends Node{    /**     * 接受方法     */    @Override    public void accept(Visitor visitor) {        visitor.visit(this);    }    /**     * NodeB特有的方法     */    public String operationB(){        return "NodeB";    }}

　　結構對象角色類，這個結構對象角色持有一個聚集，並向外界提供add()方法作為對聚集的管理操作。通過調用這個方法，可以動態地增加一個新的節點。

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

　　用戶端類

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

　　雖然在這個示意性的實現裡並沒有出現一個複雜的具有多個樹枝節點的對象樹結構，但是，在實際系統中訪問者模式通常是用來處理複雜的對象樹結構的，而且訪問者模式可以用來處理跨越多個等級結構的樹結構問題。這正是訪問者模式的功能強大之處。

　　準備過程時序圖

　　首先，這個示意性的用戶端建立了一個結構對象，然後將一個新的NodeA對象和一個新的NodeB對象傳入。

　　其次，用戶端建立了一個VisitorA對象，並將此對象傳給結構對象。

　　然後，用戶端調用結構對象聚集管理方法，將NodeA和NodeB節點加入到結構對象中去。

　　最後，用戶端調用結構對象的行動方法action()，啟動訪問過程。

　　

　　訪問過程時序圖

　　

　　結構對象會遍曆它自己所儲存的聚集中的所有節點，在本系統中就是節點NodeA和NodeB。首先NodeA會被訪問到，這個訪問是由以下的操作組成的：

　　（1）NodeA對象的接受方法accept()被調用，並將VisitorA對象本身傳入；

　　（2）NodeA對象反過來調用VisitorA對象的存取方法，並將NodeA對象本身傳入；

　　（3）VisitorA對象調用NodeA對象的特有方法operationA()。

　　從而就完成了雙重指派過程，接著，NodeB會被訪問，這個訪問的過程和NodeA被訪問的過程是一樣的，這裡不再敘述。

訪問者模式的優點

　　●　　好的擴充性

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

　　●　　好的複用性

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

　　●　　分離無關行為

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

訪問者模式的缺點

　　●　　對象結構變化很困難

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

　　●　　破壞封裝

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

《JAVA與模式》之訪問者模式