设计模式_访问者模式_ide
抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。
具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。
具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。
对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现。

访问者模式是将数据结构与数据操作解耦。

public class VisitorPattern {
    public static void main(String[] args){
        ObjectStruct objectStruct = new ObjectStruct();
        objectStruct.add(new ConcreteElementA());
        objectStruct.add(new ConcreteElementB());
        ConcreteVisitorA concreteVisitorA = new ConcreteVisitorA();
        objectStruct.accept(concreteVisitorA);
        System.out.println("----------------------");
        objectStruct.accept(new ConcreteVisitorB());
        System.out.println("----------------------");
        objectStruct.accept(new ConcreteVisitorC());

    }
}
//抽象访问者
interface Visitor {
    // 内嵌具体元素
    void visit(ConcreteElementA element);
    void visit(ConcreteElementB element);
}

// 具体访问者A
class ConcreteVisitorA implements Visitor{

    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("具体访问者A访问-->" + element.OperatorA());
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("具体访问者A访问-->" + element.OperatorB());
    }
}

// 具体访问者B
class ConcreteVisitorB implements Visitor{

    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("具体访问者B访问-->" + element.OperatorA());
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("具体访问者B访问-->" + element.OperatorB());
    }
}
// 访问者C
class ConcreteVisitorC implements Visitor{

    @Override
    public void visit(ConcreteElementA element) {
        System.out.println(element.OperatorA()+"0");
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println(element.OperatorB() + "1");

    }
}
// 抽象元素
interface Element{
    void accept(Visitor visitor);
}
// 具体元素A
class ConcreteElementA implements Element{

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    public String OperatorA(){
        return "具体元素A";
    }
}

// 具体元素B
class ConcreteElementB implements Element{

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    public String OperatorB(){
        return "具体元素B";
    }
}


//对象结构角色
class ObjectStruct{
    private List list = new ArrayList();
    public void accept(Visitor visitor) {
        Iterator i = list.iterator();
        while (i.hasNext()) {
            ((Element) i.next()).accept(visitor);
        }
    }
    public void add(Element element) {
        list.add(element);
    }
    public void remove(Element element) {
        list.remove(element);
    }
}

设计模式_访问者模式_开发语言_02