大话设计模式十二：访问者模式

最新推荐文章于 2024-01-19 10:25:31 发布
最新推荐文章于 2024-01-19 10:25:31 发布
阅读量825 收藏 10
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldld1717/article/details/88085131
版权

一.模式定义

访问者模式(Visitor Pattern)：表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。
Visitor Pattern: Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.

 

二.模式要素

Vistor: 抽象访问者
ConcreteVisitor: 具体访问者
Element: 抽象元素
ConcreteElement: 具体元素 
ObjectStructure: 对象结构

 

三.举例说明

1.场景带入一

        假设你开了一家水果店，自己就是销售者。店里常年销售着西瓜、苹果两种水果。你每天都向顾客报出两种水果的价格。

        那你可能会这样组织代码。

IFruit.java  水果接口

package example;

/**
 * @program: Test
 * @description: 水果接口
 * @author: Lei Dong
 * @create: 2019-03-03 10:27
 **/
public interface IFruit {
    /**
     * 得到名称
     *
     * @return
     */
    String obtainName();

    /**
     * 返回日常的价格
     *
     * @return
     */
    int obtainCommonPrice();
}

Watermelon.java  西瓜

package example;

/**
 * @program: Test
 * @description: 西瓜
 * @author: Lei Dong
 * @create: 2019-03-03 10:30
 **/
public class Watermelon implements IFruit {
    private static final String NAME = "西瓜";

    @Override
    public String obtainName() {
        return NAME;
    }

    /**
     * 返回西瓜日常的价格
     *
     * @return
     */
    @Override
    public int obtainCommonPrice() {
        return 2;
    }
}

Apple.java  苹果

package example;

/**
 * @program: Test
 * @description: 苹果
 * @author: Lei Dong
 * @create: 2019-03-03 10:39
 **/
public class Apple implements IFruit {
    private static final String NAME = "苹果";

    @Override
    public String obtainName() {
        return NAME;
    }

    @Override
    public int obtainCommonPrice() {
        return 3;
    }
}

Seller.java  销售者

package example;

import java.util.List;

/**
 * @program: Test
 * @description: 销售者
 * @author: Lei Dong
 * @create: 2019-03-03 10:31
 **/
class Seller {
    List<IFruit> fruitList;

    Seller(List<IFruit> fruitList) {
        this.fruitList = fruitList;
    }

    /**
     * 展示水果的日常价格
     */
    void showCommonDetail() {
        System.out.println("日常价格：");
        for (IFruit fruit : fruitList) {
            System.out.println(fruit.obtainName() + ":" +  fruit.obtainCommonPrice() + "元/斤");
        }
    }
}

Main.java  

package example;

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

/**
 * @program: Test
 * @description:
 * @author: Lei Dong
 * @create: 2019-03-03 10:27
 **/
public class Main {
    public static void main(String[] args) {
        List<IFruit> fruitList = new ArrayList<>();
        fruitList.add(new Apple());
        fruitList.add(new Watermelon());

        Seller seller = new Seller(fruitList);
        seller.showCommonDetail();
    }
}

运行结果：

        你已经完美解决了现在的问题。

2.场景带入二

        但是你转念一想，好像不够完善。因为这两种水果的价钱并非一成不变，逢年过节的肯定要调整价格。这个其实也不难，你会这样写代码。

IFruit.java  水果接口（增加其他节日价格的相关返回方法）

package example;

/**
 * @program: Test
 * @description: 水果接口
 * @author: Lei Dong
 * @create: 2019-03-03 10:27
 **/
public interface IFruit {
    /**
     * 得到名称
     *
     * @return
     */
    String obtainName();

    /**
     * 返回日常的价格
     *
     * @return
     */
    int obtainCommonPrice();

    /**
     * 返回春节的价格
     *
     * @return
     */
    int obtainSpringFestivalPrice();

    /**
     * 返回情人节的价格
     *
     * @return
     */
    int obtainValentinesDayPrice();
}

Watermelon.java  西瓜（增加实现新的接口方法）

package example;

/**
 * @program: Test
 * @description: 西瓜
 * @author: Lei Dong
 * @create: 2019-03-03 10:30
 **/
public class Watermelon implements IFruit {
    private static final String NAME = "西瓜";

    @Override
    public String obtainName() {
        return NAME;
    }

    @Override
    public int obtainCommonPrice() {
        return 2;
    }

    @Override
    public int obtainSpringFestivalPrice() {
        return 10;
    }

    @Override
    public int obtainValentinesDayPrice() {
        return 5;
    }
}

Apple.java  苹果（增加实现新的接口方法）

package example;

/**
 * @program: Test
 * @description: 苹果
 * @author: Lei Dong
 * @create: 2019-03-03 10:39
 **/
public class Apple implements IFruit {
    private static final String NAME = "苹果";

    @Override
    public String obtainName() {
        return NAME;
    }

    @Override
    public int obtainCommonPrice() {
        return 3;
    }

    @Override
    public int obtainSpringFestivalPrice() {
        return 12;
    }

    @Override
    public int obtainValentinesDayPrice() {
        return 30;
    }
}

Seller.java  销售者（添加展示春节水果价格和情人节水果价格的方法）

package example;

import java.util.List;

/**
 * @program: Test
 * @description: 销售者
 * @author: Lei Dong
 * @create: 2019-03-03 10:31
 **/
class Seller {
    List<IFruit> fruitList;

    Seller(List<IFruit> fruitList) {
        this.fruitList = fruitList;
    }

    /**
     * 展示水果的日常价格
     */
    void showCommonDetail() {
        System.out.println("日常价格：");
        for (IFruit fruit : fruitList) {
            System.out.println(fruit.obtainName() + ":" +  fruit.obtainCommonPrice() + "元/斤");
        }
    }

    /**
     * 展示水果的春节价格
     */
    void showSpringFestivalDetail() {
        System.out.println("春节价格：");
        for (IFruit fruit : fruitList) {
            System.out.println(fruit.obtainName() + ":" +  fruit.obtainSpringFestivalPrice() + "元/斤");
        }
    }

    /**
     * 展示水果的情人节价格
     */
    void showValentinesDayPrice() {
        System.out.println("情人节价格：");
        for (IFruit fruit : fruitList) {
            System.out.println(fruit.obtainName() + ":" + fruit.obtainValentinesDayPrice() + "元/斤");
        }
    }
}

Main.java

package example;

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

/**
 * @program: Test
 * @description:
 * @author: Lei Dong
 * @create: 2019-03-03 10:27
 **/
public class Main {
    public static void main(String[] args) {
        List<IFruit> fruitList = new ArrayList<>();
        fruitList.add(new Apple());
        fruitList.add(new Watermelon());

        Seller seller = new Seller(fruitList);
        seller.showCommonDetail();

        seller.showSpringFestivalDetail();

        seller.showValentinesDayPrice();
    }
}

运行结果：

        这种实现的变化就是，每增加一个节日，就需要在水果接口IFruit中添加一个返回该节日水果价格的接口，具体的水果类再去实现新增的接口。然后需要在Seller类中新建新的方法去实现对该节日水果价格的展示。动IFruit接口和在具体的水果类中实现接口方法还能忍，但是频繁改动Seller类就比较难受了。

        有没有办法说不改变Seller类也能实现这样的功能呢？有的，那就是访问者模式的写法。

        访问者模式的UML图如下：

        

四.代码实现

IFruit.java  水果接口

package example;

/**
 * @program: Test
 * @description: 水果接口
 * @author: Lei Dong
 * @create: 2019-03-03 10:27
 **/
public interface IFruit {
    /**
     * 得到名称
     *
     * @return
     */
    String obtainName();

    /**
     * 接受访问者
     *
     * @param visitor
     */
    void accept(IVisitor visitor);

    /**
     * 返回日常的价格
     *
     * @return
     */
    int obtainCommonPrice();

    /**
     * 返回春节的价格
     *
     * @return
     */
    int obtainSpringFestivalPrice();

    /**
     * 返回情人节的价格
     *
     * @return
     */
    int obtainValentinesDayPrice();
}

Watermelon.java  西瓜

package example;

/**
 * @program: Test
 * @description: 西瓜
 * @author: Lei Dong
 * @create: 2019-03-03 10:30
 **/
public class Watermelon implements IFruit {
    private static final String NAME = "西瓜";

    @Override
    public String obtainName() {
        return NAME;
    }

    @Override
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public int obtainCommonPrice() {
        return 2;
    }

    @Override
    public int obtainSpringFestivalPrice() {
        return 10;
    }

    @Override
    public int obtainValentinesDayPrice() {
        return 5;
    }
}

Apple.java  苹果

package example;

/**
 * @program: Test
 * @description: 苹果
 * @author: Lei Dong
 * @create: 2019-03-03 10:39
 **/
public class Apple implements IFruit {
    private static final String NAME = "苹果";

    @Override
    public String obtainName() {
        return NAME;
    }

    @Override
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public int obtainCommonPrice() {
        return 3;
    }

    @Override
    public int obtainSpringFestivalPrice() {
        return 12;
    }

    @Override
    public int obtainValentinesDayPrice() {
        return 30;
    }
}

Seller.java  销售者

package example;

import java.util.List;

/**
 * @program: Test
 * @description: 销售者
 * @author: Lei Dong
 * @create: 2019-03-03 10:31
 **/
class Seller {
    List<IFruit> fruitList;

    Seller(List<IFruit> fruitList) {
        this.fruitList = fruitList;
    }

    void showPrice(IVisitor visitor) {
        for (IFruit fruit : fruitList) {
            fruit.accept(visitor);
        }
    }
}

IVisitor.java  访问者接口

package example;

/**
 * @program: Test
 * @description: 访问者接口
 * @author: Lei Dong
 * @create: 2019-03-03 11:38
 **/
public interface IVisitor {
    /**
     * 访问西瓜
     *
     * @param watermelon
     */
    void visit(Watermelon watermelon);

    /**
     * 访问苹果
     *
     * @param apple
     */
    void visit(Apple apple);
}

CommonVisitor.java  日常访问者

package example;

/**
 * @program: Test
 * @description: 日常访问者
 * @author: Lei Dong
 * @create: 2019-03-03 11:41
 **/
public class CommonVisitor implements IVisitor {
    @Override
    public void visit(Watermelon watermelon) {
        System.out.println(watermelon.obtainName() + "的日常价格是：" + watermelon.obtainCommonPrice() + "元/斤");
    }

    @Override
    public void visit(Apple apple) {
        System.out.println(apple.obtainName() + "的日常价格是：" + apple.obtainCommonPrice() + "元/斤");
    }
}

SpringFestivalVisitor.java  春节访问者

package example;

/**
 * @program: Test
 * @description: 春节访问者
 * @author: Lei Dong
 * @create: 2019-03-03 11:44
 **/
public class SpringFestivalVisitor implements IVisitor {
    @Override
    public void visit(Watermelon watermelon) {
        System.out.println(watermelon.obtainName() + "春节的价格是：" + watermelon.obtainSpringFestivalPrice() + "元/斤");
    }

    @Override
    public void visit(Apple apple) {
        System.out.println(apple.obtainName() + "春节的价格是：" + apple.obtainSpringFestivalPrice() + "元/斤");
    }
}

ValentinesDayVisitor.java  情人节访问者

package example;

/**
 * @program: Test
 * @description: 情人节访问者
 * @author: Lei Dong
 * @create: 2019-03-03 11:48
 **/
public class ValentinesDayVisitor implements IVisitor {
    @Override
    public void visit(Watermelon watermelon) {
        System.out.println(watermelon.obtainName() + "情人节的价格是：" + watermelon.obtainValentinesDayPrice() + "元/斤");
    }

    @Override
    public void visit(Apple apple) {
        System.out.println(apple.obtainName() + "情人节的价格是：" + apple.obtainValentinesDayPrice() + "元/斤");
    }
}

Main.java

package example;

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

/**
 * @program: Test
 * @description:
 * @author: Lei Dong
 * @create: 2019-03-03 10:27
 **/
public class Main {
    public static void main(String[] args) {
        List<IFruit> fruitList = new ArrayList<>();
        fruitList.add(new Apple());
        fruitList.add(new Watermelon());
        Seller seller = new Seller(fruitList);

        IVisitor commonVisitor = new CommonVisitor();
        seller.showPrice(commonVisitor);

        IVisitor springFestivalVisitor = new SpringFestivalVisitor();
        seller.showPrice(springFestivalVisitor);

        IVisitor valentinesDayVisitor = new ValentinesDayVisitor();
        seller.showPrice(valentinesDayVisitor);
    }
}

运行结果:

        结合UML图来看。

        Visitor指代：IVisitor

        ConcreteVisitor指代：CommonVisitor、SpringFestivalVisitor、ValentinesDayVisitor

        Element指代：IFruit

        ConcreteElement指代：Watermelon、Apple

        Object Structure指代：Seller

        Client指代：Main

        

五.总结

1.模式优点

（1）使得增加新的访问操作变得很容易。
（2）将有关元素对象的访问行为集中到一个访问者对象中，而不是分散到一个个的元素类中。 
（3）可以跨过类的等级结构访问属于不同的等级结构的元素类。
（4）让用户能够在不修改现有类层次结构的情况下，定义该类层次结构的操作。

2.模式缺点

（1）增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，违背了“开闭原则”的要求。
（2）破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴露一些自己的内部操作和内部状态，否则无法供访问者访问。

3.模式适用场景

（1）一个对象结构包含很多类型的对象，希望对这些对象实施一些依赖其具体类型的操作。在访问者中针对每一种具体的类型都提供了一个访问操作，不同类型的对象可以有不同的访问操作。
（2）需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。访问者模式使得我们可以将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离。
（3）对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。

OpenLD
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【大话设计模式-17】访问者模式（双分派案例解析）
计忆芳华的博客
07-25 245
文章目录1 测评系统的需求2 传统方式的问题分析3 访问者模式基本介绍4 访问者模式的原理类图5 访问者模式应用实例6 访问者模式的注意事项和细节 1 测评系统的需求 完成测评系统需求 将观众分为男人和女人，对歌手进行测评，当看完某个歌手表演后，得到他们对该歌手不同的评价(评价 有不同的种类，比如 成功、失败 等) 传统方案 2 传统方式的问题分析 如果系统比较小，还是 ok 的，但是考虑系统增加越来越多新的功能时，对代码改动较大，违反了 ocp 原则， 不利于维护 扩展性不好，比如 增加了 新的人
大话设计模式—访问者模式
lmb55的专栏
04-04 3343
在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。主要解决稳定的数据结构和易变的操作耦合问题。大话设计模式中程杰老师给出的定义是，访问者模式：表示一个作用于某对象结构中的各元素的操作，它
23种设计模式之访问者模式（Visitor Pattern）
热门推荐
小威的博客
06-02 1万+
本篇文章将23种设计模式中的访问者模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
设计模式行为型——访问者模式
tszc95的博客
08-09 2107
访问者模式（Visitor Pattern）属于行为型设计模式，它允许在不修改现有对象结构的前提下，定义对这些对象执行操作的新操作。访问者模式将数据结构和操作分离，使得操作可以独立变化。访问者模式基本思想是，针对系统中拥有固定类型数的对象结构（元素），在其内提供一个 accept()方法来接受访问者对象的访问。不同的访问者对同一个元素的访问内容是不同，使得相同的元素集合可以产生不同的数据结果。
访问者模式介绍
最新发布
qq_25409421的博客
01-19 2096
访问者模式允许在运行时将一个或多个操作应用于一组对象，将操作与对象结构分离。该模式主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不污染数据本身，访问者会将多种算法独立归档，并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并确保算法的自由扩展。今天我们就来介绍下访问者模式。
【资源免费下载】Java代码积累丨大话设计模式（Java实现版本）、线程协作
10-31
设计模式参考《大话设计模式》 工厂简单模式 创造型模式 工厂方法模式 抽象工厂模式 原型模式 建造者模式 单例模式 结构型模式 队列模式 桥接模式 组合模式 装饰模式 外观模式 享元模式 代理模式 行为模式（类行为...
28种最全设计模式源码.zip
07-02
本资源包含28种设计模式的源码实现，覆盖了JAVA和C#两种主流编程语言，旨在帮助学习者深入理解并应用设计模式。 1. **简单工厂模式（01简单工厂模式）**：这种模式提供一个工厂类来创建对象，客户端通过调用工厂类...
大话设计模式实现
01-28
设计模式是软件工程中的一种最佳实践，用于解决常见的设计问题并提供可重用的解决方案。在本文中，我们将深入探讨23种设计模式，并了解它们在实际开发中的应用和适用场景。 1. **简单工厂模式**：这是一种创建型...
大话设计模式总结.doc
12-22
设计模式总结 设计模式是软件设计中的一种解决方案，旨在解决软件设计中的一些常见问题。以下是设计模式的总结，涵盖了多种设计模式的概念、特点和应用场景。 一、类图备注 * +public：公共成员变量或方法 * -...
详解设计模式：访问者模式
栗筝i的博客
12-06 4363
访问者模式（Visitor Pattern），是在 GoF 23 种设计模式中定义了的行为型模式。据《大话设计模式》中说算是最复杂也是最难以理解的一种模式了。 访问者模式 是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。 本篇文章内容包括：关于访问者模式、访问者模式 Demo
设计模式之【访问者模式】，动态双分派的魅力
秃了也弱了
05-18 1263
访问者模式（Visitor Pattern）是一种将数据结构与数据操作分离的设计模式。是指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。属于行为型模式。访问者模式被称为最复杂的设计模式，并且使用频率不高，设计模式的作者也评价为：大多数情况下，你不需要使用访问者模式，但是一旦需要使用它时，那就真的需要使用了。访问者模式的基本思想是，针对系统中拥有固定类型数量的对象结构（元素），在其内提供一个accept()方法来接收访问者对象的访问。
设计模式之观察者模式与访问者模式详解和应用
赵广陆
02-19 971
目录 1.访问者模式详解 1.1 访问者模式的定义 1.1.1 访问者模式在生活中的体现 1.1.2 访问者模式的适用场景 1.2 访问者模式的通用实现 1.3 访问者模式的使用案例之KPI考核 1.3.1 类图设计 1.3.2 代码实现 1.4 访问者模式扩展---分派 1.4.1 java中静态分派示例代码 1.4.2 java中动态分派 1.4.3 访问者模式中伪动态双分派 1.5 访问者模式在源码中应用 1.5.1 jdk中FileVisitor
访问者模式
Charge8的博客
12-13 856
访问者模式
访问者模式（行为型模式）
jiangjiangxiaooo的博客
11-16 588
设计模式之访问者模式
GOF设计模式（12）访问者模式
stanwuc的博客
09-02 349
简介 一、定义 访问者模式(Visitor Pattern):提供一个作用于某对象结构中的各元素的操作表示，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。 访问者模式可以为为不同类型的元素提供多种访问操作方式，而且可以在不修改原有系统的情况下增加新的操作方式； 具体的执行过程是：具体元素----具体访问者----具体元素 二、组件 Vist...
大话设计模式——访问者模式
不见长安见晨雾
04-18 485
男女对比——最简单的实现 访问者模式讲的是表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 public class Client { // 最简单的编程实现 public static void main(String[] args) { System.out.println("男人成功时，背后多半有一个伟大的女人。"); System.out.println("女人成功时，背后大多有一个不成功的男人
《大话设计模式--访问者模式》笔记
qq_41790833的博客
11-29 179
1、访问者模式（Visitor），表示一个作用于某对象结构中的各个元素的操作。它使你可以在不改变各个元素的类的前提下定义作用于这些元素的新操作。 2、 访问者模式结构图 2.1访问者模式适用于数据结构相对稳定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集可以相对自由的演化。 2.2访问者模式的目的是要把处理从数据结构中分离出来，如果系统有比较稳定的数据结构，又有易于变化的算...
大话设计模式 c++
09-13
行为型模式包括策略模式、观察者模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式和解释器模式。 每种设计模式都有其特定的应用场景和解决方案，可以根据实际需求选择合适的设计模式来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值