访问者模式（Visitor Pattern）

于 2024-03-14 16:56:32 发布
阅读量670 收藏 9
点赞数 4
分类专栏： Java设计模式 文章标签： 访问者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_wxw/article/details/136496848
版权

访问者模式

说明

访问者模式（Visitor Pattern）属于行为型模式，表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
该模式是将数据结构与数据操作分离的设计模式，是将作用于某种数据结构中的各元素的操作封装起来。该模式的实施前提是数据结构相对稳定，不会频繁变动，但是作用于结构上的操作又经常变动。

结构

访问者模式的主要角色如下：
抽象访问者（Visitor）：即作用于元素操作的抽象，定义了访问具体元素的接口；
具体访问者（Concrete Visitor）：根据需求实现对具体元素的操作；
抽象元素（Element）：被访问的元素抽象，定义了接收访问者的接口；
具体元素（Concrete Element）：被访问的具体元素，实现接收方法；
结构对象（Object Struture）：维护了具体元素的集合，并提供方法接收访问者对集合中的元素进行访问。
访问者模式-类结构图

代码案例

业务背景是：某个培训机构只有语文、英语、数学老师，每个科目的老师都有对应的行为，并且行为会随着需求而改变。

反例

/**
 * @program: visitor
 * @description: 老师抽象类
 * @author: wxw
 * @create: 2024-03-14 16:12
 **/
public abstract class Teacher {

    // 姓名
    protected String name;

    public Teacher(String name) {
        this.name = name;
    }

    // 备课
    public abstract void prepareLessons();

    // 上课
    public abstract void giveClass();

    // 布置作业
    public abstract void assignHomework();

    // 批改作业
    public abstract void homeworkCorrecting();
}

/**
 * @program: visitor
 * @description: 语文老师
 * @author: wxw
 * @create: 2024-03-14 16:15
 **/
public class ChineseTeacher extends Teacher{

    public ChineseTeacher(String name) {
        super(name);
    }

    @Override
    public void prepareLessons() {
        System.out.println(String.format("语文老师【%s】开始备课.", this.name));
    }

    @Override
    public void giveClass() {
        System.out.println(String.format("语文老师【%s】开始授课.", this.name));
    }

    @Override
    public void assignHomework() {
        System.out.println(String.format("语文老师【%s】开始布置作业.", this.name));
    }

    @Override
    public void homeworkCorrecting() {
        System.out.println(String.format("语文老师【%s】开始批改作业.", this.name));
    }

}

/**
 * @program: visitor
 * @description: 英语老师
 * @author: wxw
 * @create: 2024-03-14 16:15
 **/
public class EnglishTeacher extends Teacher{

    public EnglishTeacher(String name) {
        super(name);
    }

    @Override
    public void prepareLessons() {
        System.out.println(String.format("英语老师【%s】开始备课.", this.name));
    }

    @Override
    public void giveClass() {
        System.out.println(String.format("英语老师【%s】开始授课.", this.name));
    }

    @Override
    public void assignHomework() {
        System.out.println(String.format("英语老师【%s】开始布置作业.", this.name));
    }

    @Override
    public void homeworkCorrecting() {
        System.out.println(String.format("英语老师【%s】开始批改作业.", this.name));
    }

}

/**
 * @program: visitor
 * @description: 数学老师
 * @author: wxw
 * @create: 2024-03-14 16:15
 **/
public class MathTeacher extends Teacher{

    public MathTeacher(String name) {
        super(name);
    }

    @Override
    public void prepareLessons() {
        System.out.println(String.format("数学老师【%s】开始备课.", this.name));
    }

    @Override
    public void giveClass() {
        System.out.println(String.format("数学老师【%s】开始授课.", this.name));
    }

    @Override
    public void assignHomework() {
        System.out.println(String.format("数学老师【%s】开始布置作业.", this.name));
    }

    @Override
    public void homeworkCorrecting() {
        System.out.println(String.format("数学老师【%s】开始批改作业.", this.name));
    }

}

public class Test {
    public static void main(String[] args) {
        List<Teacher> teachers = new ArrayList<>();
        Teacher zhangsan = new ChineseTeacher("张三");
        Teacher lisi = new MathTeacher("李四");
        Teacher wangwu = new EnglishTeacher("王五");
        teachers.add(zhangsan);
        teachers.add(lisi);
        teachers.add(wangwu);

        for (Teacher t: teachers) {
            System.out.println("============================");
            t.prepareLessons();
            t.giveClass();
            t.assignHomework();
            t.homeworkCorrecting();
            System.out.println("============================");
        }
    }
}

假设培训机构为了提高教学质量，要求所有老师都必须跟同学进行单独沟通，了解每个同学的情况。
这时就需要在Teacher抽象类中添加沟通的方法，所有的子类都得实现该方法，违背了开闭原则。

重构后

抽象元素（Element）

/**
 * @program: visitor
 * @description: 老师抽象类
 *              抽象元素（Element）
 * @author: wxw
 * @create: 2024-03-14 16:12
 **/
public abstract class Teacher {

    // 姓名
    protected String name;

    public Teacher(String name) {
        this.name = name;
    }

    // 接收方法
    public abstract void accept(IActionVisitor actionVisitor);
}

抽象访问者（Visitor）

/**
 * @program: visitor
 * @description: 老师行为访问者接口
 *              抽象访问者（Visitor）
 * @author: wxw
 * @create: 2024-03-14 16:33
 **/
public interface IActionVisitor {

    // 访问语文老师
    void visitorChineseTeacher(ChineseTeacher chineseTeacher);
    // 访问英语老师
    void visitorEnglishTeacher(EnglishTeacher englishTeacher);
    // 访问数学老师
    void visitorMathTeacher(MathTeacher mathTeacher);

}

具体元素（Concrete Element）

/**
 * @program: visitor
 * @description: 语文老师
 *              具体元素（Concrete Element）
 * @author: wxw
 * @create: 2024-03-14 16:15
 **/
public class ChineseTeacher extends Teacher {

    public ChineseTeacher(String name) {
        super(name);
    }

    @Override
    public void accept(IActionVisitor actionVisitor) {
        actionVisitor.visitorChineseTeacher(this);
    }

}

/**
 * @program: visitor
 * @description: 英语老师
 *              具体元素（Concrete Element）
 * @author: wxw
 * @create: 2024-03-14 16:15
 **/
public class EnglishTeacher extends Teacher {

    public EnglishTeacher(String name) {
        super(name);
    }

    @Override
    public void accept(IActionVisitor actionVisitor) {
        actionVisitor.visitorEnglishTeacher(this);
    }

}

/**
 * @program: visitor
 * @description: 数学老师
 *              具体元素（Concrete Element）
 * @author: wxw
 * @create: 2024-03-14 16:15
 **/
public class MathTeacher extends Teacher {

    public MathTeacher(String name) {
        super(name);
    }

    @Override
    public void accept(IActionVisitor actionVisitor) {
        actionVisitor.visitorMathTeacher(this);
    }
}

具体访问者（Concrete Visitor）

/**
 * @program: visitor
 * @description: 备课访问者
 *              具体访问者（Concrete Visitor）
 * @author: wxw
 * @create: 2024-03-14 16:37
 **/
public class PrepareLessonsVisitor implements IActionVisitor {
    @Override
    public void visitorChineseTeacher(ChineseTeacher chineseTeacher) {
        System.out.println(String.format("语文老师【%s】开始备课.", chineseTeacher.name));
    }

    @Override
    public void visitorEnglishTeacher(EnglishTeacher englishTeacher) {
        System.out.println(String.format("英语老师【%s】开始备课.", englishTeacher.name));
    }

    @Override
    public void visitorMathTeacher(MathTeacher mathTeacher) {
        System.out.println(String.format("数学老师【%s】开始备课.", mathTeacher.name));
    }
}

/**
 * @program: visitor
 * @description: 上课访问者
 *              具体访问者（Concrete Visitor）
 * @author: wxw
 * @create: 2024-03-14 16:37
 **/
public class GiveClassVisitor implements IActionVisitor {
    @Override
    public void visitorChineseTeacher(ChineseTeacher chineseTeacher) {
        System.out.println(String.format("语文老师【%s】开始上课.", chineseTeacher.name));
    }

    @Override
    public void visitorEnglishTeacher(EnglishTeacher englishTeacher) {
        System.out.println(String.format("英语老师【%s】开始上课.", englishTeacher.name));
    }

    @Override
    public void visitorMathTeacher(MathTeacher mathTeacher) {
        System.out.println(String.format("数学老师【%s】开始上课.", mathTeacher.name));
    }
}

/**
 * @program: visitor
 * @description: 布置作业访问者
 *              具体访问者（Concrete Visitor）
 * @author: wxw
 * @create: 2024-03-14 16:37
 **/
public class AssignHomeworkVisitor implements IActionVisitor {
    @Override
    public void visitorChineseTeacher(ChineseTeacher chineseTeacher) {
        System.out.println(String.format("语文老师【%s】开始布置作业.", chineseTeacher.name));
    }

    @Override
    public void visitorEnglishTeacher(EnglishTeacher englishTeacher) {
        System.out.println(String.format("英语老师【%s】开始布置作业.", englishTeacher.name));
    }

    @Override
    public void visitorMathTeacher(MathTeacher mathTeacher) {
        System.out.println(String.format("数学老师【%s】开始布置作业.", mathTeacher.name));
    }
}

/**
 * @program: visitor
 * @description: 批改作业访问者
 *              具体访问者（Concrete Visitor）
 * @author: wxw
 * @create: 2024-03-14 16:37
 **/
public class HomeworkCorrectingVisitor implements IActionVisitor {
    @Override
    public void visitorChineseTeacher(ChineseTeacher chineseTeacher) {
        System.out.println(String.format("语文老师【%s】开始批改作业.", chineseTeacher.name));
    }

    @Override
    public void visitorEnglishTeacher(EnglishTeacher englishTeacher) {
        System.out.println(String.format("英语老师【%s】开始批改作业.", englishTeacher.name));
    }

    @Override
    public void visitorMathTeacher(MathTeacher mathTeacher) {
        System.out.println(String.format("数学老师【%s】开始批改作业.", mathTeacher.name));
    }
}

结构对象（Object Struture）

/**
 * @program: visitor
 * @description: 培训机构对象结构
 *              结构对象（Object Struture）
 * @author: wxw
 * @create: 2024-03-14 16:43
 **/
public class TrainingAgency {

    private List<Teacher> teacherList = new ArrayList<>();

    public void addTeacher(Teacher teacher){
        teacherList.add(teacher);
    }

    public void removeTeacher(Teacher teacher){
        teacherList.remove(teacher);
    }

    public void startWork(IActionVisitor visitor){
        System.out.println("================================");
        for (Teacher t: teacherList) {
            t.accept(visitor);
        }
        System.out.println("================================");
    }
}

客户端

public class Test {

    public static void main(String[] args) {
        TrainingAgency trainingAgency = new TrainingAgency();
        trainingAgency.addTeacher(new ChineseTeacher("张三"));
        trainingAgency.addTeacher(new EnglishTeacher("李四"));
        trainingAgency.addTeacher(new MathTeacher("王五"));

        // 备课访问者
        IActionVisitor prepareLessonsVisitor = new PrepareLessonsVisitor();
        trainingAgency.startWork(prepareLessonsVisitor);

        // 上课访问者
        IActionVisitor giveClassVisitor = new GiveClassVisitor();
        trainingAgency.startWork(giveClassVisitor);

        // 布置作业访问者
        IActionVisitor assignHomeworkVisitor = new AssignHomeworkVisitor();
        trainingAgency.startWork(assignHomeworkVisitor);

        // 批改作业访问者
        IActionVisitor homeworkCorrectingVisitor = new HomeworkCorrectingVisitor();
        trainingAgency.startWork(homeworkCorrectingVisitor);
    }
}

增加沟通访问者，无需修改Teacher相关的类

/**
 * @program: visitor
 * @description: 与学生沟通访问者
 *              具体访问者（Concrete Visitor）
 * @author: wxw
 * @create: 2024-03-14 16:37
 **/
public class CommunicationVisitor implements IActionVisitor {
    @Override
    public void visitorChineseTeacher(ChineseTeacher chineseTeacher) {
        System.out.println(String.format("语文老师【%s】开始与学生沟通.", chineseTeacher.name));
    }

    @Override
    public void visitorEnglishTeacher(EnglishTeacher englishTeacher) {
        System.out.println(String.format("英语老师【%s】开始与学生沟通.", englishTeacher.name));
    }

    @Override
    public void visitorMathTeacher(MathTeacher mathTeacher) {
        System.out.println(String.format("数学老师【%s】开始与学生沟通.", mathTeacher.name));
    }
}
it_wxw
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之访问者模式详解（Visitor Pattern）
Superman_peng的博客
03-31 499
最复杂的设计模式，并且使用频率不高，《设计模式》的作者评价为：大多情况下，你不需要使用访问者模式，但是一旦需要使用它时，那就真的需要使用了。 访问者模式是一种将数据操作和数据结构分离的设计模式。（觉得太抽象，可以看下面的例子）。 模式的定义与特点 访问者（Visitor）模式的定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的...
访问者(Visitor)模式
qq_38636211的博客
07-30 488
访问者(Visitor)模式 隶属类别——对象行为型模式 1. 意图 表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 2. 别名 无 3. 动机 考虑一个编译器，它将源程序表示为一个抽象的语法树。该编译器需在抽象语法树上实施某些操作以进行“静态语义”分析，例如检查是否所有的变量都已经被定义了。它也需要生成代码。因此它可能要定义许多操纵以...
7.9 访问者模式 (Visitor Pattern)
NorthStar的博客
07-25 606
访问者模式
23种设计模式之访问者模式（Visitor Pattern）
热门推荐
小威的博客
06-02 1万+
本篇文章将23种设计模式中的访问者模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
访问者模式-Visitor Pattern
cbmljs的博客
10-15 268
1.访问者模式简介 访问者模式(Visitor Pattern)模式是行为型(Behavioral)设计模式，提供一个作用于某种对象结构上的各元素的操作方式，可以使我们在不改变元素结构的前提下，定义作用于元素的新操作。 换言之，如果系统的数据结构是比较稳定的，但其操作（算法）是易于变化的，那么使用访问者模式是个不错的选择；如果数据结构是易于变化的，则不适合使用访问者模式。 访问者模式一共有五...
行为型模式——访问者模式（Visitor Pattern）
qq_46658171的博客
12-10 274
访问者模式，将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。多个不同的对象（访问者），想要对多个不同的同一类型对象（被访问元素）做一些列操作。
访问者模式（Visitor模式）详解
heima201907的博客
04-14 1190
在现实生活中，有些集合对象中存在多种不同的元素，且每种元素也存在多种不同的访问者和处理方式。例如，公园中存在多个景点，也存在多个游客，不同的游客对同一个景点的评价可能不同；医院医生开的处方单中包含多种药元素，査看它的划价员和药房工作人员对它的处理方式也不同，划价员根据处方单上面的药品名和数量进行划价，药房工作人员根据处方单的内容进行抓药。这样的例子还有很多，例如，电影或电视剧中的人物角色，不同的观...
访问者模式VisitorPattern
10-08
**访问者模式(VisitorPattern)** 访问者模式是一种行为设计模式，它使你能在不修改对象结构的前提下向对象添加新的操作。这种模式常用于处理具有复杂逻辑的对象结构，特别是当你需要对这些对象进行多态操作时。访问...
访问者模式(VisitorPattern)
01-27
访问者模式（VisitorPattern）是一种行为设计模式，其主要目的是为了在不改变数据结构的前提下，增加对元素集合的新操作。这种模式将操作封装在独立的访问者类中，使得操作和数据结构解耦，允许两者独立演进。 **...
php设计模式 Visitor 访问者模式
10-28
访问者模式（Visitor Pattern）是一种行为设计模式，它在不修改已有对象结构的情况下，为对象增加新的功能。这种模式在PHP和其他面向对象编程语言中都得到了广泛应用，尤其在需要对对象进行多样化操作，且不想破坏...
设计模式之访问者模式(Visitor Pattern)
03-10
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
visitor pattern
03-16
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/344236
访问者模式（Visitor）原理图
最新发布
04-18
访问者模式（Visitor Pattern）是GoF提出的23种设计模式中的一种，属于行为模式。它表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。从定义可以看出，...
设计模式 -- 访问者模式（Visitor Pattern）
魔法师之家
03-23 7631
封装一些作用于某些数据结构中的各元素的操作，它可以在不改变数据结构的前提下赋予这些元素新的操作。 应用场景 对象结构比较稳定，但是需要在对象结构的基础上定义新的操作。 需要对同一个类的不同对象执行不不同的操作，但是不希望增加操作的时候改变这些类。 总结 准确识别出Visitor实用的场景，如果一个对象结构不稳定决不可使用，不然在增删元素时改动将非常巨大。 对象结构中的元素要可以迭代访问 Visitor里一般存在与元素个数相同的visit方法。 元
Java设计模式（二十一）行为型- 访问者模式 Visitor Pattern（史上最全访问者模式）与使用场景以及优缺点
移动端开发与最新技术
05-19 471
访问者模式
Visitor Pattern（访问者模式、访客模式）
我与岁月的森林的博客
12-15 258
对访问者模式的学习、理解和应用案例
设计模式总结之Visitor Pattern（访问者模式）
cooldragon的专栏
08-12 1万+
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
设计模式--访问者模式
polo_longsan的专栏
04-19 438
1、访问者模式：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。 2、访问者模式涉及的角色：    (1)Visitor 抽象访问者角色，为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问 者就可以通过该元素角色的特定接口直接访问它。 （2）ConcreteVis
【设计模式】访问者模式（Visitor Pattern）
丧心病狂Loli控的博客
08-18 222
  ???? 核心 访问者模式将数据结构与数据操作分离。 被访问者拥有一个接待访问者的方法，该方法实现调用主体的反转。   ???? 问题场景 你的朋友是一名资深的保险推销员。 迫于业绩的压力，他决定拜访街区中的每栋楼，尝试向他们推销保险。 他的业务能力非常优秀，可以根据不同的客户推销不同的保险产品。如果是居民楼，他会推销医疗保险；如果是银行，他会推销失窃保险；如果是餐厅，他会推销火灾意外险… 现在，你想为这个行为建模。   ???? 解决方案 这是个典型的适合访问者模式的场景
理解设计模式：访问者模式详解
"访问者模式的结构与使用-设计模式课件--耿祥义" 访问者模式是一种在软件工程中广泛应用的设计模式，尤其在需要对对象结构进行操作或扩展其功能时。它允许在不修改对象结构本身的情况下，增加新的操作行为。这种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值