设计模式：08-访问者模式 / 迭代器模式

最新推荐文章于 2023-09-11 09:00:00 发布
最新推荐文章于 2023-09-11 09:00:00 发布
阅读量779 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 访问者模式 迭代器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JinglongSource/article/details/104173622
版权

文章目录

16. 访问者模式（Visitor Pattern）

16.1 需求的引入

测评系统的需求：将观众分为男人和女人，对歌手进行测评，当看完某个歌手表演后，得到他们对该歌手不同的评价(评价 有不 同的种类，比如 成功、失败 等)

16.2 基本介绍

基本介绍

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

在这里插入图片描述

对原理类图的说明- 即(访问者模式的角色及职责)

  1. Visitor 是抽象访问者，为该对象结构中的 ConcreteElement 的每一个类声明一个 visit 操作
  2. ConcreteVisitor ：是一个具体的访问值 实现每个有 Visitor 声明的操作，是每个操作实现的部分.
  3. ObjectStructure 能枚举它的元素， 可以提供一个高层的接口，用来允许访问者访问元素
  4. Element 定义一个 accept 方法，接收一个访问者对象
  5. ConcreteElement 为具体元素，实现了 accept 方法

16.3 应用实例

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

/**
 * 需求:
 * 将人分为男人和女人，对歌手进行测评，当看完某个歌手表演后，
 * 得到他们对该歌手不同的评价(评价 有不同 的种类，比如 成功、失败 等)，
 * 请使用访问者模式来说实现
 *
 * @author houyu
 * @createTime 2020/2/4 20:46
 */
public class Demo {

    public static void main(String[] args) {

        // 创建 ObjectStructure
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.add(new Man("张三"));
        objectStructure.add(new Man("李四"));
        objectStructure.add(new Woman("王五"));

        // 成功
        Success success = new Success();
        objectStructure.display(success);
        //
        System.out.println("--------------------------------------------");
        // 失败
        Fail fail = new Fail();
        objectStructure.display(fail);
    }

    /**
     * 人(元素Element )
     */
    public static abstract class Person {
        protected String name;

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

        /** 提供一个方法，让访问者可以访问  */
        public abstract void accept(Action action);
    }

    /**
     * 男人(具体元素 ConcreteElement )
     *
     * 说明
     * 1. 这里我们使用到了双分派, 即首先在客户端程序中，将具体状态作为参数传递 Woman 中(第一次分派)
     * 2. 然后 Woman 类调用作为参数的 "具体方法" 中方法 getWomanResult, 同时将自己(this)作为参数传入，完成第二次的分派
     *
     */
    public static class Man extends Person {
        public Man(String name) {
            super(name);
        }

        @Override
        public void accept(Action action) {
            action.getManResult(this);
        }
    }

    /**
     * 女人(具体元素 ConcreteElement )
     */
    public static class Woman extends Person {

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

        @Override
        public void accept(Action action) {
            action.getWomanResult(this);
        }
    }

    /**
     * 行动(访问者:操作者)
     */
    public static abstract class Action {
        /** 得到男性 的测评 */
        public abstract void getManResult(Man man);
        /** 得到女性 的测评 */
        public abstract void getWomanResult(Woman woman);
    }

    /**
     * 失败(具体访问者)
     */
    public static class Fail extends Action {
        @Override
        public void getManResult(Man man) {
            System.out.println(man.name + "男人给的评价该歌手失败!");
        }

        @Override
        public void getWomanResult(Woman woman) {
            System.out.println(woman.name + "女人给的评价该歌手失败!");
        }
    }

    /**
     * 成功(具体访问者)
     */
    public static class Success extends Action {
        @Override
        public void getManResult(Man man) {
            System.out.println(man.name + ":男人给的评价该歌手成功!");
        }

        @Override
        public void getWomanResult(Woman woman) {
            System.out.println(woman.name + ":女人给的评价该歌手成功!");
        }
    }

    /**
     * 对象结构: 数据结构，管理很多人（Man , Woman）
     */
    public static class ObjectStructure {
        private List<Person> personList = new ArrayList<>(16);

        public void add(Person person) {
            personList.add(person);
        }

        public void remove(Person person) {
            personList.remove(person);
        }

        /** 显示测评情况 */
        public void display(Action action) {
            for(Person person : personList) {
                person.accept(action);
            }
        }
    }

}

应用案例的小结-双分派

  • 上面提到了双分派，所谓双分派是指不管类怎么变化，我们都能找到期望的方法运行。双分派意味着得到执行的操作取决于请求的种类和两个接收者的类型
  • 以上述实例为例，假设我们要添加一个 Wait 的状态类，考察 Man 类和 Woman 类的反应，由于使用了双分派，只需增加一个 Action 子类即可在客户端调用即可，不需要改动任何其他类的代码。

16.4 访问者模式的注意事项和细节

优点

  1. 访问者模式符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高
  2. 访问者模式可以对功能进行统一，可以做报表、UI、拦截器与过滤器，适用于数据结构相对稳定的系统

缺点

  1. 具体元素对访问者公布细节，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的,这样造成了具体元素变更比较困难
  2. 违背了依赖倒转原则。访问者依赖的是具体元素，而不是抽象元素
  3. 因此，如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问者模式就是比较合适的.

17. 迭代器模式（Iterator Pattern）

17.1 需求的引入

编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院， 一个学院有多个系。如下：

----计算机学院---
计算机科学与技术
软件工程
网络工程
----信息工程学院------
通信工程
信息工程

17.2 基本介绍

基本介绍

  1. 迭代器模式（Iterator Pattern）是常用的设计模式，属于行为型模式
  2. 如果我们的集合元素是用不同的方式实现的，有数组，还有 java 的集合类，或者还有其他方式，当客户端要遍 历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。
  3. 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表 示，即：不暴露其内部的结构。

  • 原理类图
    在这里插入图片描述

  • 对原理类图的说明-即(迭代器模式的角色及职责)

  1. Iterator ： 迭代器接口，是系统提供，含义 hasNext, next, remove
  2. ConcreteIterator : 具体的迭代器类，管理迭代
  3. Aggregate :一个统一的聚合接口， 将客户端和具体聚合解耦
  4. ConcreteAggreage : 具体的聚合持有对象集合， 并提供一个方法，返回一个迭代器， 该迭代器可以正确遍历 集合
  5. Client :客户端， 通过 Iterator 和 Aggregate 依赖子类

17.3 应用实例

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

/**
 * 迭代器模式
 *
 *
 * @author houyu
 * @createTime 2020/2/6 10:32
 */
public class Demo {

    public static void main(String[] args) {

        List<College> list = new ArrayList<>(4);

        ComputerCollege computerCollege = new ComputerCollege();
        computerCollege.addDepartment("计算机科学与技术");
        computerCollege.addDepartment("软件工程");
        computerCollege.addDepartment("网络工程");

        InfoCollege infoCollege = new InfoCollege();
        infoCollege.addDepartment("通信工程");
        infoCollege.addDepartment("信息工程");

        list.add(computerCollege);
        list.add(infoCollege);

        OutPutImpl outPut = new OutPutImpl(list);
        outPut.print();
        /*
         * =====计算机学院======
         * 计算机科学与技术
         * 软件工程
         * 网络工程
         * =====信息工程学院======
         * 通信工程
         * 信息工程
         */

    }

    /**
     * 专业
     */
    public static class Department {
        private String name;

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

    /**
     * 定义基础集合, 装载系
     */
    public static interface College {

        String getName();

        void addDepartment(String name);

        /** 返回一个迭代器,遍历 */
        Iterator<Department> createIterator();
    }

    /**
     * 计算机迭代器
     */
    public static class ComputerCollegeIterator implements Iterator<Department> {

        private Department[] departments;
        private int index = 0;

        public ComputerCollegeIterator(Department[] departments) {
            this.departments = departments;
        }

        @Override
        public boolean hasNext() {
            return index < departments.length;
        }

        @Override
        public Department next() {
            return departments[index++];
        }
    }

    /**
     * 计算机集合
     */
    public static class ComputerCollege implements College {

        private Department[] departments = new Department[3];
        private int index = 0;

        @Override
        public String getName() {
            return "计算机学院";
        }

        @Override
        public void addDepartment(String name) {
            departments[index++] = new Department(name);
        }

        @Override
        public Iterator<Department> createIterator() {
            return new ComputerCollegeIterator(departments);
        }
    }

    /**
     * 信息学院迭代器
     */
    public static class InfoCollegeIterator implements Iterator<Department> {

        private List<Department> departments;
        private int index = 0;

        public InfoCollegeIterator(List<Department> departments) {
            this.departments = departments;
        }

        @Override
        public boolean hasNext() {
            return index < departments.size();
        }

        @Override
        public Department next() {
            return departments.get(index++);
        }
    }

    /**
     * 信息学院集合
     */
    public static class InfoCollege implements College {

        private List<Department> departments = new ArrayList<>(16);

        @Override
        public String getName() {
            return "信息工程学院";
        }

        @Override
        public void addDepartment(String name) {
            departments.add(new Department(name));
        }

        @Override
        public Iterator<Department> createIterator() {
            return new InfoCollegeIterator(departments);
        }
    }

    /**
     * 打印工具
     */
    public static class OutPutImpl {
        private List<College> colleges;

        public OutPutImpl(List<College> colleges) {
            this.colleges = colleges;
        }

        public void print() {
            Iterator<College> iterator = colleges.iterator();
            while(iterator.hasNext()) {
                College college = iterator.next();
                System.out.println("=====" + college.getName() + "======");
                Iterator<Department> collegeIterator = college.createIterator();
                printCollege(collegeIterator);
            }
        }

        private void printCollege(Iterator<Department> collegeIterator) {
            while(collegeIterator.hasNext()) {
                Department department = collegeIterator.next();
                System.out.println(department.name);
            }
        }

    }

}

17.4 迭代器模式在 JDK-ArrayList 集合应用的源码分析

  • 系统提供 Iterator 接口
public interface Iterator<E> {}
  • 内部类 Itr 充当具体实现迭代器 Iterator 的类， 作为 ArrayList 内部类
private class Itr implements Iterator<E> {}
  • List 就是充当了聚合接口，含有一个 iterator() 方法，返回一个迭代器对象
public interface List<E> extends Collection<E> {
	// ...
	Iterator<E> iterator();
	// ...
}
  • ArrayList 是实现聚合接口 List 的子类，实现了 iterator()
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
	// ...
    public Iterator<E> iterator() {
        return new Itr();
    }
   	// ...
}
  • 迭代器模式解决了 不同集合(ArrayList ,LinkedList) 统一遍历问题

17.5 迭代器模式的注意事项和细节

优点

  1. 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。
  2. 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
  3. 提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把 迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。 而如果遍历方式改变的话，只影响到了迭代器。
  4. 当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式

缺点

  1. 每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类
IT加载中
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
迭代器模式、访问者模式
erose的博客
12-06 414
迭代器模式 定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合时对象的内部表示。 优缺点 优点： 访问一个聚合对象的内容而无需暴露它的内部表示； 遍历任务交由迭代器完成，这简化了聚合类； 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历； 增加新的聚合类和迭代器类都很方便，无须修改原有的代码； 封装性良好，为遍历不同的聚合结构提供了一个统一的接口。 缺点：增加了类的个数，在一定程度上增加了系统的复杂性。 应用场景 当需要为聚合对象提供多种遍历方式时。 当需要为遍历不
设计模式之美——行为型3：迭代模式、访问者模式、命令模式、解释器模式、中介模式
页页的博客
11-25 217
设计模式之美——行为型3：迭代模式、访问者模式、命令模式、解释器模式、中介模式
【设计模式】迭代器模式
技术分享，读书笔记，面试宝典，算法积累，应有尽有～
03-17 189
提供一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示
GoF之迭代器模式、访问者模式详解
weixin_43580064的博客
11-18 283
迭代器（Iterator Pattern）模式 提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。 优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。 缺点： 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器...
软件设计模式(六)：迭代器、访问者、建造者模式
荔枝当大佬的博客
09-11 132
在这篇文章中，荔枝将会介绍有关迭代器模式、访问者模式和建造者模式的相关知识，其中迭代器和建造者相对来说用的比较多，访问者模式相对来说使用的比较少。重点还是需要理解不同模式的特点吧~~~
C++设计模式编程中的迭代器模式应用解析
12-25
迭代器模式应该是最为熟悉的模式了，最简单的证明就是我在实现组合模式、享元模式、观察者模式中就直接用到了 STL 提供的迭代器来遍历 Vector 或者 List数据结构。 迭代器模式也正是用来解决对一个聚合对象的遍历...
Java设计模式-图解-附代码.doc
09-19
包括策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、解释器模式等。这些模式涉及到算法选择、事件处理、异步通信等多种软件设计问题。 设计模式不仅仅...
设计模式之迭代器模式
06-18
迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在Java中，迭代器模式是通过接口实现的，这使得我们可以遍历任何实现了`Iterable`接口的对象，例如集合框架中的`...
吉林大学软件设计模式SDP02-06例子代码
最新发布
11-08
常见的行为型模式有策略模式、模板方法模式、观察者模式、访问者模式、迭代器模式、命令模式、备忘录模式、状态模式、职责链模式和解释器模式。 在这个SDP02-06的例子代码中，可能会包含上述的一种或多种设计模式的...
迭代器模式讲解
Leon_Jinhai_Sun的博客
06-11 212
现在我们来学习迭代器模式,首先我们来看一下迭代器模式的定义与类型,首先呢他提供了一种方法,顺序访问 一个集合对象中的各个元素,而又不暴露该对象的内部表示,简单理解呢,是遍历,大箱子,里面放了很多笔记本电脑, 从上至下,我们从上之下数一下,比如戴尔电脑,第二个惠普电脑,第三个是苹果电脑,那这个就是一个遍历的过程 我们看一下迭代器的适用场景,首先访问一个集合对象的内容,而无需暴露他的...
行为型设计模式---迭代器模式和访问者模式
cj1561435010的博客
09-13 435
一、迭代器模式        迭代器模式提供一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示。该模式为遍历不同的集合结构提供了一个统一的接口。一般都不会手写迭代器，都是使用封装好的，比如JAVA 中的 iterator。        葫芦娃类： public class CalabashBrother { private Strin
设计模式——中介者模式、迭代器模式、访问者模式（双分派）（行为型模式）
m0_63544124的博客
07-29 293
设计模式——中介者模式、迭代器模式、访问者模式（双分派）（行为型模式）
设计模式总结之Visitor Pattern（访问者模式）
热门推荐
cooldragon的专栏
08-12 1万+
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
设计模式GOF23之-----------行为型模式（责任链模式、迭代器模式、中介者模式、命令模式、解释器模式、访问者模式、模版方法模式、状态模式、观察者模式、备忘录模式）
金州饿霸吃不饱的博客
11-09 729
一 责任链模式        任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。 责任链模式的结构 　　下面使用了一个责任链模式的最简单的实现。 　　责任链...
设计模式访问者模式-迭代器模式-观察者模式
冰山丶
04-09 215
设计模式访问者模式-迭代器模式-观察者模式 访问者模式 基本介绍 访问者模式，封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。 主要将数据结构和数据操作分离，解决数据结构和操作耦合性问题。 访问者模式的工作原理：在被访问的类里面加一个对外提供接待访问者的接口。 访问者模式主要应用场景是：需要对一个对象结构中的对象进行很多不同操作（这些操作...
迭代器模式和组合模式混用
weixin_30567225的博客
05-18 175
迭代器模式和组合模式混用 前言 　　园子里说设计模式的文章算得上是海量了，所以本篇文章所用到的迭代器设计模式和组合模式不提供原理解析，有兴趣的朋友可以到一些前辈的设计模式文章上学学，很多很有意思的。在Head First 设计模式这本书中，也有说迭代和组合模式混用的方法，但是使用的语言是JAVA，实现起来比起C#差异还是不少。本人在做几个C#小项目的时候需要用到树形结构，也看到了Head Fi...
设计模式学习笔记(九) - 迭代器模式 Iterator & 访问者模式 Visitor
panjianlongWUHAN的专栏
10-17 262
设计模式学习笔记(九) - 迭代器模式 Iterator & 访问者模式 Visitor
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值