java23种设计模式-行为型模式-访问者模式

一、定义

访问者（Visitor）模式的定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。

二、优点及缺点

优点：

1、扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。

2、复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度。

3、灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。

4、符合单一职责原则。访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。 

缺点：

1、增加新的元素类很困难。在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。

2、破坏封装。访问者模式中具体元素对访问者公布细节，这破坏了对象的封装性。

3、违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。

三、代码实现：

访问者类接口：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:35
 *  @Description: 访问者类接口
 */
public interface Visitor {

    /**
     *  @Author: caesar
     *  @Date：2020年12月22日 17:12:33
     *  @Description: 访问方法
     */
    public void visitor(ConcreteElementA concreteElementA);
    public void visitor(ConcreteElementB concreteElementB);
}

具体访问者A：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:31
 *  @Description: 具体访问者A
 */
public class ConcreteVisitorA implements Visitor{
    @Override
    public void visitor(ConcreteElementA concreteElementA) {
        System.out.println("访问者A访问");
        concreteElementA.operationA();
    }

    @Override
    public void visitor(ConcreteElementB concreteElementB) {
        System.out.println("访问者A访问");
        concreteElementB.operationB();
    }
}

具体访问者B：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:59
 *  @Description: 抽象访问者B
 */
public class ConcreteVisitorB implements Visitor{
    @Override
    public void visitor(ConcreteElementA concreteElementA) {
        System.out.println("访问者B访问");
        concreteElementA.operationA();
    }

    @Override
    public void visitor(ConcreteElementB concreteElementB) {
        System.out.println("访问者B访问");
        concreteElementB.operationB();
    }
}

抽象元素类：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:21
 *  @Description: 抽象元素类
 */
public interface Element {
    /**
     *  @Author: caesar
     *  @Date：2020年12月22日 17:12:55
     *  @Description: 接收访问者
     */
    public void accept(Visitor visitor);
}

具体元素类A：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:57
 *  @Description: 具体对象类A
 */
public class ConcreteElementA implements Element{

    /**
     *  @Author: caesar
     *  @Date：2020年12月22日 17:12:55
     *  @Description: 接收访问者
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
    public void operationA(){
        System.out.println("这是A的具体操作。。。。。。");
    }
}

具体元素类B：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:57
 *  @Description: 具体对象类B
 */
public class ConcreteElementB implements Element{
    /**
     *  @Author: caesar
     *  @Date：2020年12月22日 17:12:55
     *  @Description: 接收访问者
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
    public void operationB(){
        System.out.println("这是B的具体操作。。。。。。");
    }

}

对象结构类：

package com.example.demo.sjms.fangwenzhemoshi;

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

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:09
 *  @Description: 结构对象
 */
public class ObjectStructure {
    private List<Element> list;
    public ObjectStructure(){
        list = new ArrayList<Element>();
    }
    // 添加
    public void add(Element element){
        list.add(element);
    }
    // 删除
    public void remove(Element element){
        list.remove(element);
    }
    // 接收访问者
    public void accept(Visitor visitor){
        list.forEach(element -> {
            element.accept(visitor);
        });
    }
}

测试类：

package com.example.demo.sjms.fangwenzhemoshi;

/**
 *  @Author: caesar
 *  @Date：2020年12月22日 17:12:54
 *  @Description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.add(new ConcreteElementA());
        objectStructure.add(new ConcreteElementB());
        objectStructure.accept(new ConcreteVisitorA());
        objectStructure.accept(new ConcreteVisitorB());
    }
}

四、源码级别

五、总结

主要解决：对象结构相对稳定，但其操作算法经常变化的程序。对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。