java設計模式（行爲型）之訪問者模式

第0章：簡介

訪問者模式的定義：用表示“訪問者”的類來訪問數據結構中的元素，並把各元素的處理交給訪問者類。這樣，當需要增加新的處理時，我們只需要編寫新的訪問者，然後讓數據結構可以接受訪問者的訪問即可。

訪問者模式的本質：分離數據結構和處理

參考：研磨設計模式（書籍），大話設計模式（書籍），圖解設計模式（書籍）

模式圖：

待補充

第1章：實踐

第0節：模板方法模式（原語、鉤子操作實現）

（1）訪問者接口（Visitor.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * 訪問者接口
 *
 * 訪問者模式的定義：用表示“訪問者”的類來訪問數據結構中的元素，並把各元素的處理交給訪問者類。
 *      這樣，當需要增加新的處理時，我們只需要編寫新的訪問者，然後讓數據結構可以接受訪問者的訪問即可。
 * 訪問者模式的本質：分離數據結構和處理
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public interface Visitor {

    /**
     * 訪問節點A
     * @param concreteNodeA
     */
    public void visit(ConcreteNodeA concreteNodeA);

    /**
     * 訪問節點B
     * @param concreteNodeB
     */
    public void visit(ConcreteNodeB concreteNodeB);
}

（2）訪問者1（ConcreteVisitor1.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * 訪問者1
 *
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public class ConcreteVisitor1 implements Visitor {

    /**
     * 訪問者1訪問節點A
     * @param concreteNodeA
     */
    @Override
    public void visit(ConcreteNodeA concreteNodeA) {
        System.out.println("訪問者1訪問節點A的方法:");
        //訪問者1訪問節點A的方法
        concreteNodeA.method();
    }

    /**
     * 訪問者1訪問節點B
     * @param concreteNodeB
     */
    @Override
    public void visit(ConcreteNodeB concreteNodeB) {
        System.out.println("訪問者1訪問節點B的方法:");
        //訪問者1訪問節點B的方法
        concreteNodeB.method();
    }
}

（3）訪問者2（ConcreteVisitor2.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * 訪問者2
 *
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public class ConcreteVisitor2 implements Visitor {

    /**
     * 訪問者2訪問節點A
     * @param concreteNodeA
     */
    @Override
    public void visit(ConcreteNodeA concreteNodeA) {
        System.out.println("訪問者2訪問節點A的方法:");
        //訪問者1訪問節點A的方法
        concreteNodeA.method();
    }

    /**
     * 訪問者2訪問節點B
     * @param concreteNodeB
     */
    @Override
    public void visit(ConcreteNodeB concreteNodeB) {
        System.out.println("訪問者2訪問節點B的方法:");
        //訪問者1訪問節點B的方法
        concreteNodeB.method();
    }
}

（4）抽象節點接口（Node.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * 抽象節點接口（數據節點），接受一個訪問者對象
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public abstract class Node {

    /**
     * 接受訪問者的操作
     * @param visitor
     */
    public abstract void accept(Visitor visitor);
}

（5）具體節點A（ConcreteNodeA.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * 具體節點A
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public class ConcreteNodeA extends Node{

    /**
     * 接受訪問者的操作
     * @param visitor
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    /**
     * 節點A的方法
     */
    public void method(){
        System.out.println("節點A自有的方法");
    }
}

（6）具體節點B（ConcreteNodeB.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public class ConcreteNodeB extends Node {

    /**
     * 接受訪問者的操作
     * @param visitor
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    /**
     * 節點B的方法
     */
    public void method(){
        System.out.println("節點B自有的方法");
    }
}

（7）結構對象（ObjectStructure.java）

package com.mcc.core.designPattern.behavior.visitor;

import java.util.ArrayList;
import java.util.List;

/**
 * 結構對象
 * 可以遍歷結構中的所有元素；如果需要，提供一個高層次的接口讓訪問者對象可以訪問每一個元素；
 * 如果需要，可以設計成一個複合對象或者一個聚集，如List或Set。
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public class ObjectStructure {

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

    /**
     * 執行方法操作，接受訪問者的操作
     * @param visitor
     */
    public void action(Visitor visitor){
        for(Node node : nodes)
        {
            node.accept(visitor);
        }
    }

    /**
     * 添加新節點
     * @param node
     */
    public void add(Node node){
        nodes.add(node);
    }

}

（8）客戶端測試（Client.java）

package com.mcc.core.designPattern.behavior.visitor;

/**
 * 客戶端測試
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         My blog: https://blog.csdn.net/menergy
 *         Created by Administrator on 2018/4/29.
 */
public class Client {

    public static void main(String[] args){

        //創建一個結構對象
        ObjectStructure os = new ObjectStructure();
        //給結構增加一個節點A
        os.add(new ConcreteNodeA());
        //給結構增加一個節點B
        os.add(new ConcreteNodeB());
        //創建訪問者1
        Visitor visitor1 = new ConcreteVisitor1();
        os.action(visitor1);

        System.out.println("---------------------------------------");
        //給結構再增加一個節點
        os.add(new ConcreteNodeA());
        //創建訪問者1
        Visitor visitor2 = new ConcreteVisitor1();
        os.action(visitor2);

    }
}