• 行为型设计模式---访问者模式

    一、介绍

    访问者模式是一种将数据操作与数据结构分离的设计模式

    基本想法：

       （1）软件系统中拥有一个由许多对象构成的、比较稳定的对象结构，这些对象的类都拥有一个accept方法用来接受访问者对象的访问。访问者是一个接口，它拥有一个visit方法，这个方法对访问到的对象结构中不同类型的元素做出不同的处理。

       （2）在对象结构的一次访问过程中，我们遍历整个对象结构，对每一个元素都实施accept方法，在每一个元素的acept方法中调用访问者的visit方法，从而使访问者得以处理对象结构的每一个元素，我们可以针对对象结构设计不同的访问者类来完成不同的操作，达到区别对待的效果。

       

     二、定义及使用场景

    定义及使用场景
    定义：封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。

    可以对定义这么理解：有这么一个操作，它是作用于一些元素之上的，而这些元素属于某一个对象结构。同时这个操作是在不改变各元素类的前提下，在这个前提下定义新操作是访问者模式精髓中的精髓。

    使用场景：
    （1）对象结构比较稳定，但经常需要在此对象结构上定义新的操作。

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

    三、类图

     

    图解：

    抽象访问者(Visitor)角色：为该对象结构中具体元素角色声明一个访问操作接口，用来代表为对象结构添加的新功能，理论上可以代表任意的功能。

    具体访问者(ConcreteVisitor)角色：实现每个由抽象访问者角色（Visitor）声明的操作接口。

    抽象元素(Element)角色：定义一个accept()操作，它以一个访问者（Visitor）对象作为参数。

    具体元素(ConcreteElement)角色：实现由抽象元素(Element)角色提供的accept()操作。

    对象结构(ObjectStructure)角色：这是使用访问者模式必备的角色。一般具备以下特征：

               （1）能枚举它的元素。

               （2）可以提供一个高层的接口以允许该访问者访问它的元素。

               （3）可以是一个复合（组合模式）或是一个集合，如一个列表或一个无序集合
     

     1.首先定义一个接口来代表要新加入的功能，称为访问者，访问对象结构中的对象。

    1. //访问者接口
    2. interface Visitor{
    3.    // 访问concreteElementA，相当于为concreteElementA添加新功能
    4.     public void visitConcreteElementA(ConcreteElementA elementA);
    5.  
    6.     // 访问concreteElementB，相当于为concreteElementB添加新功能
    7.     public void visitConcreteElementB(ConcreteElementB elementB);
    8. }

    2.访问者具体实现

    1. //具体访问者A
    2. class concreteVisitorA implements Visitor{
    3.     public void visitConcreteElementA(ConcreteElementA elementA){
    4. //        把访问ConcreteElementA时，需要执行的功能在这里实现，可能需要访问元素已有的功能，比如operationA()
    5.  
    6.         System.out.println("concreteVisitorA访问====》ConcreteElementA对象");
    7.     }
    8.  
    9.  
    10.     public void visitConcreteElementB(ConcreteElementB elementB){
    11. //        把访问ConcreteElementB时，需要执行的功能在这里实现，可能需要访问元素已有的功能，比如operationB()
    12.  
    13.         System.out.println("concreteVisitorA访问====》ConcreteElementB对象");
    14.     }
    15. }
    16.  
    17. //具体访问者B
    18. class concreteVisitorB implements Visitor{
    19.     public void visitConcreteElementA(ConcreteElementA elementA){
    20. //        把访问ConcreteElementA时，需要执行的功能在这里实现，可能需要访问元素已有的功能，比如operationA()
    21.  
    22.         System.out.println("concreteVisitorB访问====》ConcreteElementA对象");
    23.     }
    24.  
    25.  
    26.     public void visitConcreteElementB(ConcreteElementB elementB){
    27. //        把访问ConcreteElementB时，需要执行的功能在这里实现，可能需要访问元素已有的功能，比如operationB()
    28.  
    29.         System.out.println("concreteVisitorB访问====》ConcreteElementB对象");
    30.     }
    31. }

    3.抽象元素Element

    1. //抽象元素Element的定义
    2.  
    3. abstract class Element{
    4. //    接受访问者的访问
    5.     public abstract void accept(Visitor visitor);
    6. }

    4.具体的Element

    1.  
    2. //具体ElementA
    3. class ConcreteElementA extends Element{
    4.     public void accept(Visitor visitor){
    5. //        回调访问者对象的相应方法
    6.         visitor.visitConcreteElementA(this);
    7.     }
    8.  
    9. //    表示元素已有的功能实现
    10.     public void operationA(){
    11.         System.out.println("执行ConcreteElementA已有的operationA方法");
    12.     }
    13. }
    14.  
    15. //具体ElementB
    16. class ConcreteElementB extends Element{
    17.     public void accept(Visitor visitor){
    18. //        回调访问者对象的相应方法
    19.         visitor.visitConcreteElementB(this);
    20.     }
    21.  
    22.     //    表示元素已有的功能实现
    23.     public void operationB(){
    24.         System.out.println("执行ConcreteElementB已有的operationB方法");
    25.     }
    26. }

    5.对象结构

    1. //对象结构，通常在这里对元素对象进行遍历，让访问者能够访问到所有的元素
    2. class ObjectStructure{
    3. //    表示对象结构
    4.     private List<Element> list =new ArrayList<Element>();
    5. //    组建对象结构，向对象结构中添加元素
    6.     public void addElement(Element element){
    7.         this.list.add(element);
    8.     }
    9.  
    10. //    提供给客户端操作的方法，让访问者对对象结构中的所有元素进行访问
    11.     public void handleRequest(Visitor visitor){
    12. //        循环对象结构中的元素，进行访问
    13.         for (Element element:list){
    14.             element.accept(visitor);
    15.         }
    16.     }
    17. }

    6.客户类

    1. public class Client {
    2.     public static void main(String[] args) {
    3. //        创建对象结构
    4.         ObjectStructure os=new ObjectStructure();
    5.  
    6. //        为对象结构中添加元素对象
    7.         os.addElement(new ConcreteElementA());
    8.         os.addElement(new ConcreteElementB());
    9.  
    10. //        创建访问者
    11.         Visitor visitor =new concreteVisitorA();
    12.  
    13. //        调用对象结构的业务处理方法
    14.         os.handleRequest(visitor);
    15.     }
    16.  
    17. }

    四.应用

    一个商场（SuperMarket），通常都会包括：商店（Store）、监控室（MonitoringRoom）、卫生间（WaterCloset）。商场的访问者大致可以分为两大类：顾客（Customer）、商场工作人员（MarketStaff）。顾客可以逛商店、上卫生间，但却不能进入监控室；工作人员可以进入监控室、上卫生间，但却不能像顾客一样逛商店，也就是说对于商场的同一个地点，不同的访问者有不同的行为权限，而且访问者的种类很有可能需要根据时间的推移发生变化（没准哪天，工商局的人要来视察呢！此时就需要增加工商局人员的访问者了）。


    1.类图

    2.实现

    1. package 访问者模式案例2;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. //访问者接口
    7. interface Visitor{
    8.     public void visitWaterCloset(WaterCloset waterCloset);
    9.     public void visitMonitoringRoom(MonitoringRoom monitoringRoom);
    10.     public void visitStore(Store store);
    11. }
    12.  
    13. //实现类
    14. class MarketStaff implements Visitor{
    15.     public void visitWaterCloset(WaterCloset waterCloset){
    16.         System.out.println("工作人员进入厕所");
    17.         waterCloset.wash();
    18.     }
    19.     public void visitMonitoringRoom(MonitoringRoom monitoringRoom){
    20.         System.out.println("工作人员进入监控室");
    21.         monitoringRoom.monitor();
    22.     }
    23.     public void visitStore(Store store){
    24.         System.out.println("工作人员不能逛商店哦");
    25.     }
    26. }
    27. class Customer implements Visitor{
    28.     public void visitWaterCloset(WaterCloset waterCloset){
    29.         System.out.println("顾客进入厕所");
    30.         waterCloset.wash();
    31.     }
    32.     public void visitMonitoringRoom(MonitoringRoom monitoringRoom){
    33.         System.out.println("顾客不能查看监控哦");
    34.     }
    35.     public void visitStore(Store store){
    36.         System.out.println("顾客进入商店");
    37.         store.shopping();
    38.     }
    39. }
    40. //抽象元素
    41. abstract class Place{
    42.     public abstract void accept(Visitor visitor);
    43. }
    44. //具体元素
    45. class WaterCloset extends Place{
    46.     public void accept(Visitor visitor){
    47.         visitor.visitWaterCloset(this);
    48.     }
    49. //    自己的方法
    50.     public void wash(){
    51.         System.out.println("洗手手");
    52.     }
    53. }
    54. class Store extends Place{
    55.     public void accept(Visitor visitor){
    56.         visitor.visitStore(this);
    57.     }
    58.     //    自己的方法
    59.     public void shopping(){
    60.         System.out.println("购物");
    61.     }
    62. }
    63. class MonitoringRoom extends Place{
    64.     public void accept(Visitor visitor){
    65.         visitor.visitMonitoringRoom(this);
    66.     }
    67.     //    自己的方法
    68.     public void monitor(){
    69.         System.out.println("查看监控");
    70.     }
    71. }
    72. //对象结构类
    73. class SuperMarket{
    74. //    对象结构
    75.     private List<Place> list =new ArrayList<>();
    76.  
    77. //    对象结构组建方法
    78.     public void add(Place place){
    79.         this.list.add(place);
    80.     }
    81.  
    82. //    为客户端提供一个遍历所有对象结构元素的方法，输入访问者参数
    83.     public void handleRequest(Visitor visitor){
    84.         for (Place place:list){
    85.             place.accept(visitor);
    86.         }
    87.     }
    88.  
    89. }
    90. public class Client {
    91.     public static void main(String[] args) {
    92.         //    创建商场
    93.         SuperMarket superMarket=new SuperMarket();
    94. //    添加元素
    95.         superMarket.add(new WaterCloset());
    96.         superMarket.add(new MonitoringRoom());
    97.         superMarket.add(new Store());
    98.  
    99. //        提供访问者
    100.         Visitor visitor1=new Customer();
    101.         Visitor visitor2=new MarketStaff();
    102.         superMarket.handleRequest(visitor1);
    103.         superMarket.handleRequest(visitor2);
    104.     }
    105.  
    106. }

     

  • 相关阅读:
    WiFi-IoT 鸿蒙开发套件样例开发
    Java日期时间类
    数据库SQL-测试常用查询
    MySQL进阶—索引1
    AlexNet网络结构详解与花分类数据集下载
    [华为云云服务器评测] Unbutnu添加SSH Key、编译启动Springboot项目
    RTMP摄像头直播-CameraX数据采集处理
    牛血清白蛋白(BSA)修饰脂质体
    Compose 动画艺术探索之动画规格
    从零开始学习makefile(5)makefile中patsubst的作用
  • 原文地址：https://blog.csdn.net/h18377528386/article/details/125433434