设计模式一访问者模式

欢迎光临我的博客[http://poetize.cn]，前端使用Vue2，聊天室使用Vue3，后台使用Spring Boot

---

概述

将作用于元素的操作分离出来封装成独立的类

优点

1. 符合单一职责原则

2. 元素类可以通过接受不同的访问者来实现对不同操作的扩展。

缺点

1. 具体元素对访问者公布细节，违背了迪米特法则。

2. 违背了依赖倒置原则，访问者依赖的是具体元素，而不是抽象元素。

适用场景

1. 对象结构中对象对应的类很少改变，经常但需要在此对象结构上定义新的操作。

2. 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作 “污染” 这些对象的类，也不希望在增加新操作时修改这些类。

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

import java.util.ArrayList;
import java.util.Iterator;

public class Visitor {
    public static void main(String[] args) {
        //元素
        Elementing a = new Elementing1();
        Elementing b = new Elementing2();
        Elementing c = new Elementing3();
        //访问者
        Visitoring t = new ConcreteVisitor();
        //对象结构
        ObjecStructure objecStructure = new ObjecStructure();
        objecStructure.add(a);
        objecStructure.add(b);
        objecStructure.add(c);
        objecStructure.iterator(t);
    }
}

//抽象访问者
interface Visitoring {
    public void visit(Elementing1 el);

    public void visit(Elementing2 el);

    public void visit(Elementing3 el);

}

//具体访问者
class ConcreteVisitor implements Visitoring {

    @Override
    public void visit(Elementing1 el) {
        System.out.println("对元素一的操作！");
    }

    @Override
    public void visit(Elementing2 el) {
        System.out.println("对元素二的操作！");
    }

    @Override
    public void visit(Elementing3 el) {
        System.out.println("对元素三的操作！");
    }
}

//抽象元素
abstract class Elementing {

    public abstract void accept(Visitoring vis);
}

//具体元素
class Elementing1 extends Elementing {

    @Override
    public void accept(Visitoring vis) {
        vis.visit(this);
    }

    public String doing() {
        return "一号就是这样反应？";
    }
}

//具体元素
class Elementing2 extends Elementing {

    @Override
    public void accept(Visitoring vis) {
        vis.visit(this);
    }

    public String going() {
        return "燥起来";
    }
}

//具体元素
class Elementing3 extends Elementing {

    @Override
    public void accept(Visitoring vis) {
        vis.visit(this);
    }

    public String flying() {
        return "谢谢";
    }
}

//对象结构（Object Structure）
class ObjecStructure {
    private ArrayList<Elementing> arr = new ArrayList<>();

    public void add(Elementing el) {
        arr.add(el);
    }

    public void remove(Elementing el) {
        arr.remove(el);
    }

    public void iterator(Visitoring vis) {
        Iterator<Elementing> it = arr.iterator();
        while (it.hasNext()) {
            it.next().accept(vis);
        }
    }
}