设计模式——访问者模式

一、访问者模式基本介绍

【1】访问者模式（Visitor Pattern）：封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。
【2】主要将数据结构与数据操作分离：解决数据结构和操作耦合性问题。
【3】访问者模式的基本工作原理：在被访问者（上面提到的评委）的类里面加一个对外提供接待访问者的接口。
【4】访问者模式主要应用场景：需要对一个对象结构中的对象进行很多不同的操作（这些操作彼此没有关联），同时避免让这些操作 “污染” 这些类对象，可以选用访问者模式。

二、访问者模式的优缺点

【访问者（Visitor）模式，其主要优点如下】：
● 扩展性好：能够在不修改对象结构中元素的情况下，为对象结构中的元素添加新功能；
● 复用性好：可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用功能；
● 灵活性好：访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由；
【访问者（Visitor）模式，其主要缺点如下】：
● 增加新的元素类很困难：在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加响应的具体操作，违背了 “开闭原则”。
● 破坏封装：访问者模式中具体元素对访问者公布细节，这破坏了对象的封装性。
● 违反了依赖倒置原则：访问模式依赖了具体类，而没有依赖抽象类。
● 具体元素对访问者公布细节：也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的，这样造成了具体元素变得更比较困难。

三、访问者模式结构类图

访问者模式的关键在于：如何将元素的操作分离出来封装成独立的类，其基本机构如下：
【1】抽象访问者角色（Visitor）：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作，该操作中的参数类型标识了被访问的具体元素。
【2】具体访问者角色（ConcreteVisitor）：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
【3】抽象元素角色（Element）：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept 方法的参数。
【4】具体元素角色（ConcreteElement）：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this)，另外具体元素中可能包含本身业务逻辑的相关操作。
【5】对象结构角色（Object Structure）：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法,通常由List、Set、Map 等聚合类实现。

四、访问者模式案例分析

评委评价歌手是否晋级的案例

【1】抽象访问者角色

1 //访问者接口
2 public interface Action {
3     //得到评委A的评价  JudgesImpl_A 具体实现类
4     public void getJudage_A(JudgesImpl_A judageA);
5     //得到评委B的评价
6     public void getJudage_B(JudgesImpl_B judageB);
7 }

【2】抽象访问者的具体实现类——晋级

 1 //晋级
 2 public class Promotion implements Action {
 3 
 4     @Override
 5     public void getJudage_A(JudgesImpl_A judageA) {
 6         System.out.println("评委A名称:"+judageA.getName());
 7         System.out.println("给的评价是=========晋级");
 8     }
 9 
10     @Override
11     public void getJudage_B(JudgesImpl_B judageB) {
12         System.out.println("评委B名称:"+judageB.getName());
13         System.out.println("给的评价是=========晋级");
14     }
15 
16 }

【3】抽象访问者的具体实现类——淘汰

 1 public class Eleminate implements Action{
 2 
 3     @Override
 4     public void getJudage_A(JudgesImpl_A judageA) {
 5         System.out.println("评委A名称:"+judageA.getName());
 6         System.out.println("给的评价是=========淘汰");
 7     }
 8 
 9     @Override
10     public void getJudage_B(JudgesImpl_B judageB) {
11         System.out.println("评委B名称:"+judageB.getName());
12         System.out.println("给的评价是=========淘汰");
13     }
14 
15 }

【4】抽象元素接口，包含访问者方法 accept ——评委接口

1 //评委接口  被访问者接口
2 public interface IJudges {
3     //提供一个访问方法,出入访问者实例
4     public void accept(Action action);
5 }

【5】抽象元素接口的具体实现类——评委A

 1 //评委A  被访问者
 2 public class JudgesImpl_A implements IJudges{
 3     //传入一个评委名称
 4     private String name;
 5     //构造器
 6     public JudgesImpl_A(String name) {
 7         super();
 8         this.name = name;
 9     }
10 
11     @Override
12     public void accept(Action action) {
13         System.out.println("具体被访问者（评委A）对象，给出的评价是==");
14         action.getJudage_A(this);
15     }
16 
17     public String getName() {
18         return name;
19     }
20 
21     public void setName(String name) {
22         this.name = name;
23     }
24     
25 }

【6】抽象元素接口的具体实现类——评委B

 1 //评委B  被访问者
 2 public class JudgesImpl_B implements IJudges{
 3     private String name;
 4     //构造器
 5     public JudgesImpl_B(String name) {
 6         super();
 7         this.name = name;
 8     }
 9 
10     @Override
11     public void accept(Action action) {
12         System.out.println("具体被访问者（评委B）对象，给出的评价是==");
13         action.getJudage_B(this);
14     }
15 
16     public String getName() {
17         return name;
18     }
19 
20     public void setName(String name) {
21         this.name = name;
22     }
23     
24 }

【7】对象结构实现类，将被访问类进行封装。

 1 //将评委评论进行统计
 2 public class ObjectStrFactory {
 3     //维护一个被访问者集合
 4     private List<IJudges> judage = new LinkedList();
 5     
 6     //添加评委
 7     public void add(IJudges jud) {
 8         judage.add(jud);
 9     }
10     //移除评委
11     public void remove(IJudges jud) {
12         judage.remove(jud);
13     }
14     //展示评论
15     public void disply(Action action) {
16         for (IJudges iJudges : judage) {
17             iJudges.accept(action);
18         }
19     }
20 }

【8】客户端调用

 1 public class Client {
 2     public static void main(String[] args) {
 3         //创建结构体工厂
 4         ObjectStrFactory objectStrFactory = new ObjectStrFactory();
 5         //添加评委
 6         objectStrFactory.add(new JudgesImpl_A("周杰伦"));
 7         objectStrFactory.add(new JudgesImpl_B("蔡徐坤"));
 8         //展示评价:晋级的评价
 9         /**
10          * 输出：
11          * 具体被访问者（评委A）对象，给出的评价是==
12          * 评委A名称:周杰伦
13          * 给的评价是=========晋级
14          * 具体被访问者（评委B）对象，给出的评价是==
15          * 评委B名称:蔡徐坤
16          * 给的评价是=========晋级
17          */
18         objectStrFactory.disply(new Promotion());
19         //如果评价是 淘汰
20         /**
21          * 输入：
22          * 具体被访问者（评委A）对象，给出的评价是==
23          * 评委A名称:周杰伦
24          * 给的评价是=========淘汰
25          * 具体被访问者（评委B）对象，给出的评价是==
26          * 评委B名称:蔡徐坤
27          * 给的评价是=========淘汰
28          */
29         objectStrFactory.disply(new Eleminate());
30     }
31 }

五、访问者模式的优点实操

当需要扩展一个 “待定” 的元素选项时，非常方便，简单两步操作即可完成：
【1】添加 “待定” 元素的实体类，如下：并实现所有评委给的 “待定评价” 即可。

 1 //待定
 2 public class Wait implements Action{
 3 
 4     @Override
 5     public void getJudage_A(JudgesImpl_A judageA) {
 6         System.out.println("评委A名称:"+judageA.getName());
 7         System.out.println("给的评价是=========待定");
 8     }
 9 
10     @Override
11     public void getJudage_B(JudgesImpl_B judageB) {
12         System.out.println("评委B名称:"+judageB.getName());
13         System.out.println("给的评价是=========待定");
14     }
15         
16 }

【2】客户端调用时，只需传入待定的实体类，便可获取待定评价。通过扩展我们才看出来访问者模式的强大之处。

 1 public class Client {
 2     public static void main(String[] args) {
 3                 //输出
 4         /**
 5          * 具体被访问者（评委B）对象，给出的评价是==
 6          * 评委B名称:蔡徐坤
 7          * 给的评价是=========淘汰
 8          * 具体被访问者（评委A）对象，给出的评价是==
 9          * 评委A名称:周杰伦
10          * 给的评价是=========待定
11          * 具体被访问者（评委B）对象，给出的评价是==
12          * 评委B名称:蔡徐坤
13          * 给的评价是=========待定
14          */
15         objectStrFactory.disply(new Wait());
16     }
17 }

posted @ 2020-11-19 14:30 Java程序员进阶阅读(248) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java程序员进阶