在閻宏博士的《JAVA與模式》一書中開頭是這樣描述訪客（Visitor）模式的：
訪客模式是物件的行為模式。訪客模式的目的是封裝一些施加於某種資料結構元素之上的操作。一旦這些操作需要修改的話，接受這個操作的資料結構就可以保持不變。
分派的概念
變數被宣告時的型別叫做變數的靜態型別(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，這破壞了物件的封裝性。