设计模式之访问者模式

最新推荐文章于 2024-03-03 13:27:16 发布
最新推荐文章于 2024-03-03 13:27:16 发布
阅读量156 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 访问者模式 访问者模式适用场景 如何实现访问者模式 访问者模式包含角色
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bird_tp/article/details/110138786
版权

1、问题引入

     在软件开发过程中，遍历集合的操作是访问操作的一种，且我们经常把遍历和其他的逻辑混合在一起，且当我更换遍历方式时，我还需要修改代码，因此，我们思考，可不可以将访问操作独立出来变成一个新的类，当我们需要增加访问操作的时候，直接增加新的类，原来的代码不需要任何的改变。

而访问者模式恰好可以实现这个，使得使用不同的访问方式都可以对某些元素进行访问。

二、定义

    将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。

三、意图

　　表示一个作用于某对象结构中的各个元素的操作。它可以在不改变各元素的类的前提下定义作用于这些元素的新的操作。

四、使用场景

1、对象结构中对象对应的类较少改变、但是会经常在此对象结构上定义新的操作

2、需要对一个对象结构中进行一些不相关的操作、需要在新增操作时避免改变其原来的类

五、优缺点

优点

1、符合单一职责原则。每个类负责一个职责

2、具有优秀的扩展性和灵活性、添加新的操作会变得较为容易、同时也不会改变其原来的结构代码

3、访问者模式将一些相关的行为操作集合在了访问者对象中，并没有分散在其元素类中

缺点

1、具体元素对访问者公开了细节，违背了迪米特原则

2、增加具体元素节点变得困难、与之随之增加的就是在访问者中新增。

六、包含角色

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

七、代码结构

package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: Visitor
 * @Author: tanp
 * @Description: 抽象访问者(Visitor)角色，声明了一个或者多个方法操作，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。
 * @Date: 2020/11/26 11:21
 */
public interface Visitor {

    void visit(ConcreteElementA concreteElementA);

    void visit(ConcreteElementB concreteElementB);
}

package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: ConcreteVisitorA
 * @Author: tanp
 * @Description: 具体访问者(ConcreteVisitor)角色：实现抽象访问者所声明的接口，也就是抽象访问者所声明的各个访问操作，确定访问者访问一个元素时该做什么
 * @Date: 2020/11/26 11:36
 */
public class ConcreteVisitorA implements Visitor{
    @Override
    public void visit(ConcreteElementA concreteElementA) {
        System.out.println("访问者A访问A元素");
    }

    @Override
    public void visit(ConcreteElementB concreteElementB) {
        System.out.println("访问者A访问B元素");
    }
}
package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: ConcreteVisitorB
 * @Author: tanp
 * @Description: 具体访问者(ConcreteVisitor)角色：实现抽象访问者所声明的接口，也就是抽象访问者所声明的各个访问操作，确定访问者访问一个元素时该做什么。
 * @Date: 2020/11/26 11:42
 */
public class ConcreteVisitorB implements Visitor{
    @Override
    public void visit(ConcreteElementA concreteElementA) {
        System.out.println("访问者B访问A元素");
    }

    @Override
    public void visit(ConcreteElementB concreteElementB) {
        System.out.println("访问者B访问B元素");
    }
}
package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: Element
 * @Author: tanp
 * @Description: 抽象元素(Element)角色：声明一个接受操作，接受一个访问者对象作为一个参数，被接受的访问者对象作为 accept() 方法的参数。
 * @Date: 2020/11/26 11:26
 */
public interface Element {
    /**接受观察者的访问方法*/
    void accept(Visitor visitor);
}
package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: ConcreteElementA
 * @Author: tanp
 * @Description: 具体元素角色，实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作
 * @Date: 2020/11/26 11:23
 */
public class ConcreteElementA implements Element{
    @Override
    public void accept(Visitor visitor) {
            visitor.visit(this);
    }
}
package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: ConcreteElementB
 * @Author: tanp
 * @Description: 具体元素角色，实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作
 * @Date: 2020/11/26 11:23
 */
public class ConcreteElementB implements Element{
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
package visitor.v1;

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

/**
 * @Package: visitor.v1
 * @ClassName: ObjectStructure
 * @Author: tanp
 * @Description: 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现
 * @Date: 2020/11/26 11:47
 */
public class ObjectStructure {

    List<Element> list = new ArrayList<Element>();

    public void add(Element element){
        list.add(element);
    }

    public void remove(Element element){
        list.remove(element);
    }


    /**遍历所有元素，将每个调用接受观察者访问的方法*/
    public void accept(Visitor visitor){
        Iterator<Element> iterator = list.iterator();
        while (iterator.hasNext()){
            iterator.next().accept(visitor);
        }
    }
}
package visitor.v1;

/**
 * @Package: visitor.v1
 * @ClassName: DemoClient
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/11/26 15:34
 */
public class DemoClient {

    public static void main(String[] args) {
        //新建对象结构实例
        ObjectStructure objectStructure = new ObjectStructure();
        //添加元素
        objectStructure.add(new ConcreteElementA());
        objectStructure.add(new ConcreteElementB());
        //新建观察者
        Visitor visitor = new ConcreteVisitorA();
        objectStructure.accept(visitor);
        visitor = new ConcreteVisitorB();
        objectStructure.accept(visitor);
    }

}

八、代码示例

我们现在来编写一个案例，就是一个补习班上3有个同学，1个老师，补习的科目有语数外三科，老师这次组织了一次考试，考试的成绩已经出来了，现在的要求是编写一个访问者模式的代码系统，实现老师访问系统的时候，可以看到每个学生的各个分数和学生总分数，学生则是看到自己单独的各科分数，下面开始编码

package visitor.v2;

/**
 * @Package: visitor.v2
 * @ClassName: Visitor
 * @Author: tanp
 * @Description: 抽象访问者(Visitor)角色，声明了一个或者多个方法操作，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。
 * @Date: 2020/11/26 17:16
 */
public abstract class Visitor {

    protected String name;

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


    abstract int visit(English english);

    abstract int visit(Math math);

    abstract int visit(Chinese chinese);

}
package visitor.v2;

/**
 * @Package: visitor.v2
 * @ClassName: Teacher
 * @Author: tanp
 * @Description: 具体访问者(ConcreteVisitor)角色：实现抽象访问者所声明的接口，也就是抽象访问者所声明的各个访问操作，确定访问者访问一个元素时该做什么
 * @Date: 2020/11/26 16:30
 */
public class Teacher extends Visitor {

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


    @Override
    public int visit(English english) {
        System.out.println("name：" + english.StudentName + ",english:" + english.score);
        return english.score;
    }

    @Override
    public int visit(Math math) {
        System.out.println("name：" + math.StudentName + ",math:" + math.score);
        return math.score;
    }

    @Override
    public int visit(Chinese chinese) {
        System.out.println("name：" + chinese.StudentName + ",chinese:" + chinese.score);
        return chinese.score;
    }
}
package visitor.v2;

/**
 * @Package: visitor.v2
 * @ClassName: Student
 * @Author: tanp
 * @Description: 具体访问者(ConcreteVisitor)角色：实现抽象访问者所声明的接口，也就是抽象访问者所声明的各个访问操作，确定访问者访问一个元素时该做什么
 * @Date: 2020/11/26 16:28
 */
public class Student extends Visitor {

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

    @Override
    public int visit(English english) {
        if (name.equals(english.StudentName)) {
            System.out.println("name：" + name + ",english:" + english.score);
        }
        return english.score;
    }

    @Override
    public int visit(Math math) {
        if (name.equals(math.StudentName)) {
            System.out.println("name：" + name + ",math:" + math.score);
        }
        return math.score;
    }

    @Override
    public int visit(Chinese chinese) {
        if (name.equals(chinese.StudentName)) {
            System.out.println("name：" + name + ",chinese:" + chinese.score);
        }
        return chinese.score;
    }
}
package visitor.v2;

import java.util.Random;

/**
 * @Package: visitor.v2
 * @ClassName: Subjects
 * @Author: tanp
 * @Description: 抽象元素(Element)角色：声明一个接受操作，接受一个访问者对象作为一个参数，被接受的访问者对象作为 accept() 方法的参数。
 * @Date: 2020/11/26 16:17
 */
public abstract class Subjects {

    /**学生姓名*/
    protected String StudentName;

    /**学生分数*/
    protected int score;

    public Subjects(String studentName){
        this.StudentName = studentName;
        score = new Random().nextInt(100);
    }

    public abstract int accept(Visitor visitor);

}
package visitor.v2;

/**
 * @Package: visitor.v2
 * @ClassName: Chinese
 * @Author: tanp
 * @Description: 具体元素角色，实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作
 * @Date: 2020/11/26 16:32
 */
public class Chinese extends Subjects{


    public Chinese(String studentName) {
        super(studentName);
    }

    @Override
    public int accept(Visitor visitor) {
        return visitor.visit(this);
    }
}
package visitor.v2;

/**
 * @Package: visitor.v2
 * @ClassName: English
 * @Author: tanp
 * @Description: 具体元素角色，实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作
 * @Date: 2020/11/26 16:15
 */
public class English extends Subjects {


    public English(String studentName) {
        super(studentName);
    }

    @Override
    public int accept(Visitor visitor) {
        return visitor.visit(this);
    }
}
package visitor.v2;

/**
 * @Package: visitor.v2
 * @ClassName: Math
 * @Author: tanp
 * @Description: 具体元素角色，实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作
 * @Date: 2020/11/26 16:31
 */
public class Math extends Subjects{

    public Math(String studentName) {
        super(studentName);
    }

    @Override
    public int accept(Visitor visitor) {
        return visitor.visit(this);
    }
}
package visitor.v2;


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

/**
 * @Package: visitor.v2
 * @ClassName: ObjectStructure
 * @Author: tanp
 * @Description: 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现
 * @Date: 2020/11/26 16:48
 */
public class ObjectStructure {

    List<Subjects> list = new ArrayList<Subjects>();

    public void add(Subjects subject) {
        list.add(subject);
    }


    /**
     * 遍历所有元素，将每个调用接受观察者访问的方法
     */
    public void accept(Visitor visitor) {
        String name = visitor.name.substring(0, 4);
        //单科成绩
        int score = 0;
        //总分
        int sum = 0;
        int index = 0;
        for (Subjects subjects : list) {
            score = subjects.accept(visitor);
            //以下逻辑为老师查看学生总分所写，但是代码逻辑要求list中的学生成绩必须是按一个一个学生添加得来
            if (name.equals("miss")) {
                sum = sum + score;
                index++;
                if (index == 3) {
                    System.out.println(subjects.StudentName + "总分:" + sum);
                    index = 0;
                }
            }
        }
    }
}
package visitor.v2;

import proxy.Subject;

/**
 * @Package: visitor.v2
 * @ClassName: DemoClient
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/11/26 17:03
 */
public class DemoClient {

    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.add(new English("mike"));
        objectStructure.add(new Chinese("mike"));
        objectStructure.add(new Math("mike"));
        objectStructure.add(new English("lucy"));
        objectStructure.add(new Chinese("lucy"));
        objectStructure.add(new Math("lucy"));
        Visitor visitor = new Student("mike");
        System.out.println("学生mike查看成绩");
        objectStructure.accept(visitor);
        visitor = new Teacher("miss zhang");
        System.out.println("老师查看成绩");
        objectStructure.accept(visitor);
    }

}

九、总结

　　访问者模式就介绍到这里啦。访问者模式主要是将数据结构及操作分离、解决了稳定的数据结构和容易变化的操作的耦合性。在新增操作的时候不修改原来的结构对象的类。直接修改访问者对象中的操作即可新增操作。

 

 

 

 

bird_tp
关注
专栏目录
设计模式第22讲——访问者模式（Visitor）
让~学习~成为一种习惯（橡 皮 人の技术博客）
07-05 2264
访问者模式是一种行为型设计模式，它可以用于在不修改已有对象结构的情况下，定义新的操作方式。一、什么是访问者模式 二、角色组成 三、优缺点 四、 应用场景 4.1 生活场景4.2 Java场景 五、代码实现 5.0 UML类图5.1抽象访问者——Visitor5.2 具体访问者——Tourist5.3 抽象元素——Spot5.4 具体元素——View、Relic5.5 对象结构——SpotCollection5.6 testVisitor六、总结
设计模式——访问者模式
qq_39431405的博客
09-07 870
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。先来看第一句话，说是一个作用于某对象结构中的各元素的操作，这里提到了三个事物，一个是对象结构，一个是各元素，一个是操作。那么我们可以这么理解，有这么一个操作，它是作用于一些元素之上的，而这些元素属于某一个对象结构。最关键的第二句来了，它说使用了访问者模式之后，可以让我们在不改变各元素类的前提下定义作用于这些元素的新操作。
设计模式之【访问者模式】，动态双分派的魅力
秃了也弱了
05-18 1371
访问者模式（Visitor Pattern）是一种将数据结构与数据操作分离的设计模式。是指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。属于行为型模式。访问者模式被称为最复杂的设计模式，并且使用频率不高，设计模式的作者也评价为：大多数情况下，你不需要使用访问者模式，但是一旦需要使用它时，那就真的需要使用了。访问者模式的基本思想是，针对系统中拥有固定类型数量的对象结构（元素），在其内提供一个accept()方法来接收访问者对象的访问。
《设计模式》访问者模式
华仔仔的博客
05-13 954
定义：访问模式的角色组成：访问者模式的 UML 类图：UML 类图：抽象元素 Car 接口： 具体元素 ElectroCar 类： 具体元素 OilCar 类： 具体元素 HybridCar 类： 抽象访问者 Visitor 接口： 具体访问者 FuelVisitor 类： 具体访问者 EnduranceVisitor 类： 具体访问者 PriceVisitor 类： 对象结构 ObjectStructure 类： 客户端 Client 类： 因此，访问者模式的优点：访问者模式的缺点：访问者模式的适用场
详解设计模式：访问者模式
栗筝i的博客
12-06 5917
访问者模式（Visitor Pattern），是在 GoF 23 种设计模式中定义了的行为型模式。据《大话设计模式》中说算是最复杂也是最难以理解的一种模式了。 访问者模式 是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。 本篇文章内容包括：关于访问者模式、访问者模式 Demo
C语言 设计模式之访问者模式
12-31
C语言访问者模式 概要： 访问者模式，听上去复杂一些。但是，这种模式用简单的一句话说，就是不同的人对不同的事物有不同的感觉。比如说吧，豆腐可以做成麻辣豆腐，也可以做成臭豆腐。可是，不同的地方的人未必...
C++设计模式之访问者模式
09-04
主要介绍了C++设计模式之访问者模式,本文讲解了什么是访问者模式、访问者模式的UML类图、访问者模式的实现代码等内容,需要的朋友可以参考下
JAVA设计模式之访问者模式详解
09-03
访问者模式是一种面向对象的设计模式，它属于行为模式，其主要目标是将操作与数据结构解耦。在访问者模式中，我们定义一个访问者接口，这个接口规定了可以对哪些元素进行操作。同时，数据结构中的每个元素都有一个...
java设计模式之访问者模式
12-21
访问者模式是一种软件设计模式，它允许在不改变对象结构的情况下，在对象的现有结构上增加新的操作。在Java中，这种模式尤其有用，因为它能够帮助我们保持类的封装性，同时提供了一种灵活的方式来扩展对象的功能。...
设计模式：访问者设计模式
weixin_44251099的博客
05-25 276
访问者设计模式是一种行为型设计模式，用于将算法与对象结构分离。它允许你在不改变对象结构的前提下定义新的操作。
设计模式-访问者模式
最新发布
m0_68810055的博客
03-03 442
设计模式中访问者模式的讲解及代码示例
23种设计模式之访问者模式（Visitor Pattern）
热门推荐
小威的博客
06-02 1万+
本篇文章将23种设计模式中的访问者模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
设计模式—访问者模式
KEEP CODING
06-22 1637
本质是将数据结构和数据操作分离，通过定义一个访问者对象，实现对数据结构中各个元素的访问和处理，从而达到解耦和灵活性的目的。
JavaScript中的访问者模式
m0_75198698的博客
04-27 222
在上面的例子中，我们首先定义了一个Animal类作为动物的基类，同时也定义了具体的Cat、Dog和Bird类作为不同类型的动物。在上面的例子中，我们首先定义了一个Animal类作为动物的基类，同时也定义了具体的Cat、Dog和Bird类作为不同类型的动物。4. 具体元素(ConcreteElement)角色：实现了元素角色中定义的接受访问者的方法，通常情况下，具体元素角色会调用访问者角色中的方法。2. 具体访问者(ConcreteVisitor)角色：实现了访问者角色中定义的方法，具体实现了对元素的操作。
经典的设计模式23——访问者模式
weixin_63967970的博客
06-16 1484
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
【设计模式】访问者模式
qq_35448165的博客
03-12 891
简单来说，访问者模式就是封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新操作。数据结构稳定，但是作用于数据结构的操作经常变化需要数据结构与数据操作分离需要对不同数据类型(元素)进行操作，但是有不使用判断具体类型使得数据结构和作用于结构上的操作解耦，使得操作集合可以独立变化。扩展性好，添加新的操作或者说访问者会非常容易。增加新的元素类型会非常困难，每次新增元素类型，则访问者类必须增加对应元素类型的操作。
深入理解JAVA设计模式：访问者模式解析
"JAVA设计模式之访问者模式详解" 访问者模式是一种在软件设计中用于处理对象结构中的元素操作的设计模式。这种模式将操作封装在独立的访问者对象中，允许在不修改对象结构的情况下添加新的操作。访问者模式是对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值