迭代器模式与观察者模式

最新推荐文章于 2024-11-11 16:57:31 发布
最新推荐文章于 2024-11-11 16:57:31 发布
阅读量156 收藏
点赞数
文章标签： java 设计模式 数据结构 python redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yorickjun/article/details/116646144
版权

迭代器模式与观察者模式

参考教程：https://www.bilibili.com/video/BV1G4411c7N4
代码实现 Github：https://github.com/yaokuku123/pattern

迭代器模式

  1. 案例

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

5-1592899506899.png
  1. 传统方法
6-1592899533512.png
  • 分析

  1. 将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的

  2. 实际上我们的要求是 ：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现遍历的操作

  1. 迭代器模式

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

  1. 代码实现
7-1592899697426.png

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

  1. Iterator ： 迭代器接口，是系统提供，含义 hasNext, next, remove

  2. ConcreteIterator : 具体的迭代器类，管理迭代

  3. Aggregate :一个统一的聚合接口， 将客户端和具体聚合解耦

  4. ConcreteAggreage : 具体的聚合持有对象集合， 并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合

  5. Client：客户端通过Iterator和Aggregate依赖子类

[图片上传失败...(image-c60506-1593227929478)]

package com.yqj.pattern.iterator;

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

class Department {
    private String name;
    private String desc;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}


class ComputerCollegeIterator implements Iterator<Department> {

    private Department[] departments;
    int position = 0;

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


    @Override
    public boolean hasNext() {
        if (position >= departments.length || departments[position] == null) {
            return false;
        }
        return true;
    }

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

    }
}

class InfoCollegeIterator implements Iterator<Department> {

    private List<Department> departments;
    private int index = -1;

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

    @Override
    public boolean hasNext() {
        if (index >= departments.size() - 1) {
            return false;
        } else {
            index++;
            return true;
        }
    }

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

interface College {
    String getName();
    //增加系的方法
    void addDepartment(String name, String desc);
    //返回迭代器遍历
    Iterator createIterator();
}

class ComputerCollege implements College {
    private Department[] departments;
    //保存当前数组的对象个数
    private int numOfDepartment = 0;

    public ComputerCollege() {
        departments = new Department[5];
        addDepartment("Java","Java desc");
        addDepartment("C++","C++ desc");
        addDepartment("Python","Python desc");
    }

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

    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name, desc);
        departments[numOfDepartment++] = department;
    }

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

class InfoCollege implements College{

    List<Department> departments;

    public InfoCollege() {
        departments = new ArrayList<>();
        addDepartment("信息安全","信息安全");
        addDepartment("网络安全","网络安全");
        addDepartment("服务器安全","服务器安全");
    }

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

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

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

//遍历类
class OutputImpl{
    private List<College> colleges;

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

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

    public void printDepartment(Iterator<Department> iterator){
        while (iterator.hasNext()){
            Department department = iterator.next();
            System.out.println(department.getName());
        }
    }
}

public class Client {
    public static void main(String[] args) {
        List<College> colleges = new ArrayList<>();
        ComputerCollege computerCollege = new ComputerCollege();
        InfoCollege infoCollege = new InfoCollege();
        colleges.add(computerCollege);
        colleges.add(infoCollege);
        OutputImpl output = new OutputImpl(colleges);
        output.printCollege();
    }
}
  1. 小结

优点

  1. 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。

  2. 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。

  3. 提供了一种设计思想，就是一个类应该只有一个引起变化的原因(叫做单一责任原则)。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。

  4. 当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式

缺点

每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类

观察者模式

  1. 案例

天气预报项目需求,具体要求如下： 1) 气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如 发布到自己的网站或第三方)。 2) 需要设计开放型API，便于其他第三方也能接入气象站获取数据。 3) 提供温度、气压和湿度的接口 4) 测量数据更新时，要能实时的通知给第三方

  1. 传统方案
1-1592961163081.png
  • 分析
  1. 无法在运行时动态的添加第三方 (新浪网站) 2) 违反ocp原则=>观察者模式
  1. 观察者模式

解释：对象之间多对一依赖的一种设计方案，被依赖的对象为Subject， 依赖的对象为Observer，Subject通知Observer变化,Subject是1的一方。Observer是多的一方。

  1. 代码实现
2-1592961436939.png 
package com.yqj.pattern.observer;

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

interface Subject{
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObserver();
}

class WeatherData implements Subject{

    private float temperature;
    private float pressure;
    private float humidity;
    private List<Observer> observers = new ArrayList<>();

    public float getTemperature() {
        return temperature;
    }

    public float getPressure() {
        return pressure;
    }

    public float getHumidity() {
        return humidity;
    }

    public void setData(float temperature,float pressure,float humidity){
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        notifyObserver();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        if(observers.contains(observer)){
            observers.remove(observer);
        }
    }

    //遍历所有观察者并通知
    @Override
    public void notifyObserver() {
        System.out.println("======update========");
        for (Observer observer : observers) {
            observer.update(temperature,pressure,humidity);
        }
    }
}

interface Observer{
    void update(float temperature,float pressure,float humidity);
}

class Baidu implements Observer{
    private float temperature;
    private float pressure;
    private float humidity;

    @Override
    public void update(float temperature,float pressure,float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    public void display(){
        System.out.println("Baidu temperature:"+temperature);
        System.out.println("Baidu pressure:"+pressure);
        System.out.println("Baidu humidity"+humidity);
    }
}

class Sina implements Observer{
    private float temperature;
    private float pressure;
    private float humidity;

    @Override
    public void update(float temperature,float pressure,float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    public void display(){
        System.out.println("Sina temperature:"+temperature);
        System.out.println("Sina pressure:"+pressure);
        System.out.println("Sina humidity"+humidity);
    }
}

public class Client {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        Observer baidu = new Baidu();
        Observer sina = new Sina();

        weatherData.registerObserver(baidu);
        weatherData.registerObserver(sina);

        weatherData.setData(35,150,20);
        weatherData.setData(33,111,25);
    }
}
  1. 小结

  1. 观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。

  2. 这样，我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类WeatherData不会修改代码，遵守了ocp原则。

攻城老湿
关注
C++设计模式16：迭代器模式
琅嬛福地
04-28 1265
迭代器模式是一种行为型设计模式，它允许你在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。迭代器模式通过提供一个迭代器来实现这一点，该迭代器用于跟踪集合中的当前元素，并知道如何遍历到下一个元素。在迭代器模式中，集合类通常会实现一个名为 iterator 的方法，该方法返回一个迭代器对象。迭代器对象通常会实现两个方法：next 和 hasNext。next 方法返回集合中的下一个元素，而 hasNext 方法则用于检查是否还有更多的元素需要遍历。
设计模式（四）：行为型模式之模板方法模式、策略模式、命令模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式和解释器模式
HX_2021
11-06 1070
设计模式之行为型模式 一、概述 行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。 行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。 行为型模式是 GoF 设计模式中最为庞大的一类，它包含以下11 种模式。 模板方法（Template Me
设计模式访问者模式-迭代器模式-观察者模式
冰山丶
04-09 259
设计模式访问者模式-迭代器模式-观察者模式 访问者模式 基本介绍 访问者模式，封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。 主要将数据结构和数据操作分离，解决数据结构和操作耦合性问题。 访问者模式的工作原理：在被访问的类里面加一个对外提供接待访问者的接口。 访问者模式主要应用场景是：需要对一个对象结构中的对象进行很多不同操作（这些操作...
设计模式示例四 Observer(观察者)和Iterator(迭代器)
aitanwu4387的博客
02-22 118
之所以把这两个模式放在一起说是因为C#语句的关系。这两种模式实现起来变得很轻松或者说不一样了。Observer(观察者) classObserver{publicdelegatevoidEventHandler(stringstate);publiceventEventHandlerchangeEvent;...
设计模式--观察者模式和迭代器模式
咸鱼梦想
01-02 368
本来想着转载一份博客，但是总感觉加一些自己的思考与想法，写写博客，练习一下表达能力 观察者模式 //观察者模式 // 是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这 通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。 1.当观察者增多时，直接添加新的观察者，之后再将其注册，这样关注的特性发生改变...
设计模式化--迭代器模式和观察者模式
weixin_38705074的博客
10-26 179
1、迭代器模式 package com.yqj.pattern.iterator; import java.util.ArrayList; import java.util.Iterator; import java.util.List; class Department { private String name; private String desc; public Department(String name, String desc) { this.n
观察者模式（Observer）--迭代器模式（Iterator）
02-03 428
15、观察者模式（Observer） 包括这个模式在内的接下来的四个模式，都是类和类之间的关系，不涉及到继承。 当你订阅了该文章，如果后续有更新，会及时通知你。对象之间是一种一对多的关系。 MySubject类就是被观察者。 public interface Observer {       public void update();   }   public class Obs...
迭代器模式Demo
05-23
迭代器模式是一种设计模式，它在软件工程中扮演着重要的角色，特别是在处理集合或容器类对象的遍历操作时。这种模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，...
C++设计模式编程中的迭代器模式应用解析
12-25
迭代器模式应该是最为熟悉的模式了，最简单的证明就是我在实现组合模式、享元模式、观察者模式中就直接用到了 STL 提供的迭代器来遍历 Vector 或者 List数据结构。 迭代器模式也正是用来解决对一个聚合对象的遍历...
[设计模式](十一)：观察者模式|迭代器模式|责任链模式|命令模式（四种类间行为模式）
身披白袍的博客
08-22 1578
观察者模式|迭代器模式|责任链模式|命令模式，这是四种类间行为模式
设计模式：（六）迭代器、观察者、中介者、备忘录模式
余笙的博客
04-08 292
一、迭代器模式 1、概述 迭代器（Iterator）模式：提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素， 不需要知道集合对象的底层表示（即：不暴露其内部的结构）。迭代器模式是一种对象行为型模式。 2、迭代器模式的主要角色 抽象迭代器（Iterator）：定义访问和遍历聚合元素的接口，通常包含hasNext()、next()、remove()等方法。 具体迭代器（Concretelterator）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。 抽象聚合（Agg
Java设计模式（八）观察者模式 迭代器模式
fanyun7654的专栏
07-11 1148
（十五）观察者模式 观察者模式，定义对象间一对多关系，一个对象状态发生改变，所有依赖于它的对象都收到通知并且自动更新，观察者与被观察者分开。例如邮件订阅、RSS订阅，如果有更新就会邮件通知你。 （十六）迭代器模式 说到迭代器首先想到 Iterator ，使用迭代器来为顺序访问集合元素提供一种方式。下面是自己的一个集合，当然只能放 int ，简单的实现了 迭代器的功能，当然实际的Java迭代器比这要复杂很多。
Java设计模式（八）—访问者模式、迭代器模式、观察者模式
qq_37965402的博客
08-04 850
本章目录标题第18章 访问者模式18.1 应用场景：测评系统18.2 传统方式18.3 访问者模式18.4 应用案例：测评系统18.5 访问者模式的注意事项第19章 迭代器模式19.1 需求：院系展示19.2 传统方式19.3 迭代器模式19.4 应用案例：院系展示19.5 迭代器模式在JDK-ArrayList 集合应用19.6 迭代器模式的注意事项第20章 观察者模式20.1 应用场景：天气预报20.2 传统模式20.3 观察者模式20.4 应用案例：天气预报 第18章 访问者模式 18.1 应用场景：
【重走编程路】设计模式概述（九） -- 观察者模式、迭代器模式
weixin_44595767的博客
07-13 1136
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。迭代器模式提供了一种顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示的方法。
软件架构设计师-行为型模式-中介者模式-观察者模式-迭代器模式-C++
插件开发
04-18 202
文章目录1.中介者模式2.观察者模式3.迭代器模式(Iterator Pattern)4.作者答疑   本文定义模式设计中行为型模式的解析，主要讲解中介者模式，观察者模式和迭代器模式。本文内容来至互联网内容的编辑修改，方便读者学习。如有侵权，第一时间联系作者删除。 1.中介者模式   定义:用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 Mediator：中介者，它定义了一个接口用于与各个Colleague对象通信； Conc
行为型模式--策略、模板方法、观察者、迭代器、解释器(六)
灰猫
04-12 703
行为型模式涉及怎样合理的设计对象之间的交互通信，以及怎样合理为对象分配职责，让设计富有弹性，易维护，易复用 行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 策略模式 定义:定义了算法家族，并将每一个算法封装起来，而且使它们还可以相互替换。（让算法变化不会影响使用算法的用户） 适用场景：系...
Day318.迭代器模式&观察者模式 -Java设计模式
阿昌爱Java
07-04 298
迭代器模式 关注在数据遍历 一、需求 编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院， 一个学院有多个系。如图： 二、传统的设计方案(类图) 三、传统的方式的问题分析 1)将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的 2)实际上我们的要求是 ：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现的遍历的操作 3)解决方案：=> 迭代器模式 四、迭代器模式基本介绍 基
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
最新发布
mm
11-11 307
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
行为模式详解：职责链、迭代器与命令模式
最后，观察者模式（也称为发布/订阅模式）定义了一种一对多依赖关系，当一个对象（发布者）的状态发生改变时，所有依赖于它的对象（观察者）都会得到通知并更新自己。这种模式促进了事件驱动编程，增强了系统的松...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攻城老湿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值