设计模式一访问者模式


欢迎光临我的博客[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 等聚合类实现。
  1 import java.util.ArrayList;
  2 import java.util.Iterator;
  3 
  4 public class Visitor {
  5     public static void main(String[] args) {
  6         //元素
  7         Elementing a = new Elementing1();
  8         Elementing b = new Elementing2();
  9         Elementing c = new Elementing3();
 10         //访问者
 11         Visitoring t = new ConcreteVisitor();
 12         //对象结构
 13         ObjecStructure objecStructure = new ObjecStructure();
 14         objecStructure.add(a);
 15         objecStructure.add(b);
 16         objecStructure.add(c);
 17         objecStructure.iterator(t);
 18     }
 19 }
 20 
 21 //抽象访问者
 22 interface Visitoring {
 23     public void visit(Elementing1 el);
 24 
 25     public void visit(Elementing2 el);
 26 
 27     public void visit(Elementing3 el);
 28 
 29 }
 30 
 31 //具体访问者
 32 class ConcreteVisitor implements Visitoring {
 33 
 34     @Override
 35     public void visit(Elementing1 el) {
 36         System.out.println("对元素一的操作!");
 37     }
 38 
 39     @Override
 40     public void visit(Elementing2 el) {
 41         System.out.println("对元素二的操作!");
 42     }
 43 
 44     @Override
 45     public void visit(Elementing3 el) {
 46         System.out.println("对元素三的操作!");
 47     }
 48 }
 49 
 50 //抽象元素
 51 abstract class Elementing {
 52 
 53     public abstract void accept(Visitoring vis);
 54 }
 55 
 56 //具体元素
 57 class Elementing1 extends Elementing {
 58 
 59     @Override
 60     public void accept(Visitoring vis) {
 61         vis.visit(this);
 62     }
 63 
 64     public String doing() {
 65         return "一号就是这样反应?";
 66     }
 67 }
 68 
 69 //具体元素
 70 class Elementing2 extends Elementing {
 71 
 72     @Override
 73     public void accept(Visitoring vis) {
 74         vis.visit(this);
 75     }
 76 
 77     public String going() {
 78         return "燥起来";
 79     }
 80 }
 81 
 82 //具体元素
 83 class Elementing3 extends Elementing {
 84 
 85     @Override
 86     public void accept(Visitoring vis) {
 87         vis.visit(this);
 88     }
 89 
 90     public String flying() {
 91         return "谢谢";
 92     }
 93 }
 94 
 95 //对象结构(Object Structure)
 96 class ObjecStructure {
 97     private ArrayList<Elementing> arr = new ArrayList<>();
 98 
 99     public void add(Elementing el) {
100         arr.add(el);
101     }
102 
103     public void remove(Elementing el) {
104         arr.remove(el);
105     }
106 
107     public void iterator(Visitoring vis) {
108         Iterator<Elementing> it = arr.iterator();
109         while (it.hasNext()) {
110             it.next().accept(vis);
111         }
112     }
113 }
posted @ 2019-08-02 11:36  LittleDonkey  阅读(134)  评论(0编辑  收藏  举报