迭代器模式

关注

数据遍历

,且分离数据与迭代器，实现解耦

一、需求

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

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

二、传统的设计方案(类图)

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

三、传统的方式的问题分析

1)将学院看做是学校的子类，系是学院的子类，这样实际上是站在

组织大小

来进行分层次的

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

遍历的操作

3)解决方案：=>

迭代器模式

四、迭代器模式基本介绍

基本介绍

1) 迭代器模式 （Iterator Pattern）是常用的设计模式，属于 行为型模式 2)如果我们的 集合元素是用不同的方式实现的 ，有数组，还有 java 的集合类，或者还有其他方式，当客户端要 遍历这些集合元素
的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。

3)迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

原理类图

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

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

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

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

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

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

5)Client : 客户端，通过 Iterator 和 Aggregate 依赖子类

五、迭代器模式应用实例

1)应用实例要求

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

2)设计思路分析

Iterator：输出的方式，遍历方式

College：真正需要遍历的集合，数据

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

3)代码实现

主函数

public class Client {
    public static void main(String[] args) {
        //创建学院
        List<College> collegeList = new ArrayList<College>();

        ComputerCollege computerCollege = new ComputerCollege(); 
        InfoCollege infoCollege = new InfoCollege();

        collegeList.add(computerCollege);
        //collegeList.add(infoCollege);


        OutPutImpl outPutImpl = new OutPutImpl(collegeList); 
        outPutImpl.printCollege();
    }
}

College学院接口

//College学院接口
public interface College {
    //获取学院名
    public String getName();

    //增加系的方法
    public void addDepartment(String name, String desc);

    //返回一个迭代器,遍历
    public Iterator	createIterator();
}

ComputerCollege计算机学院

//计算机学院
public class ComputerCollege implements College {
    Department[] departments;
    int numOfDepartment = 0 ;// 保存当前数组的对象个数
    
    public ComputerCollege() { 
        departments = new Department[5];
        addDepartment("Java 专业", " Java 专业  ");
        addDepartment("PHP 专业", " PHP 专业  ");
        addDepartment("大数据专业", "  大数据专业 ");
    }

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

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

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

ComputerCollegeIterator

public class ComputerCollegeIterator implements Iterator {
    //这里我们需要 Department  是以怎样的方式存放=>数组
    Department[] departments;
    int position = 0; //遍历的位置

    //构造器
    public ComputerCollegeIterator(Department[] departments) { 
        this.departments = departments;
    }

    //判断是否还有下一个元素 
    @Override
    public boolean hasNext() {
        // TODO Auto-generated method stub
        if(position >= departments.length || departments[position] == null) { 
            return false;
        }else {
            return true;
        }
    }

    @Override
    public Object next() {
        Department department = departments[position]; 
        position += 1;
        return department;
    }

    //删除的方法，默认空实现
    public void remove() {}

}

Department

//系
@Data
public class Department {
    private String name; 
    private String desc;
    
    public Department(String name, String desc) {
        super();
        this.name = name; 
        this.desc = desc;
    }
}

InfoColleageIterator

public class InfoColleageIterator implements Iterator {
    List<Department> departmentList; //  信息工程学院是以 List 方式存放系
    int index = -1;//索引

    public InfoColleageIterator(List<Department> departmentList) { 
        this.departmentList = departmentList;
    }

    //判断 list 中还有没有下一个元素
    @Override
    public boolean hasNext() {
        if(index >= departmentList.size() - 1) {
            return false;
        } else {
            index += 1; 
            return true;
        }
    }

    @Override
    public Object next() {
        return departmentList.get(index);
    }

    // 空 实 现 
    remove public void remove() {}
}

InfoCollege

public class InfoCollege implements College {
    List<Department> departmentList;
    
    public InfoCollege() {
        departmentList = new ArrayList<Department>();
        addDepartment("信息安全专业", " 信息安全专业 "); 
        addDepartment("网络安全专业", " 网络安全专业 ");
        addDepartment("服务器安全专业", "  服务器安全专业 ");
    }

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

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

    @Override
    public Iterator createIterator() {
        return new InfoColleageIterator(departmentList);
    }
}

OutPutImpl

public class OutPutImpl {
    //学院集合
    List<College> collegeList;
    
    public OutPutImpl(List<College> collegeList) {
        this.collegeList = collegeList;
    }
    
    //遍历所有学院,然后调用 printDepartment  输出各个学院的系
    public void printCollege() {
        //从 collegeList 取出所有学院, Java 中的 List 已经实现 Iterator 
        Iterator<College> iterator = collegeList.iterator();
        while(iterator.hasNext()) {
            //取出一个学院
            College college = iterator.next();
            System.out.println("=== "+college.getName() +"=====" ); 
            printDepartment(college.createIterator()); //得到对应迭代器
        }
    }

    //输出 学院输出 系
    public void printDepartment(Iterator iterator) { 
        while(iterator.hasNext()) {
            Department d = (Department)iterator.next(); 
            System.out.println(d.getName());
        }
    }
    
}

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

优点

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

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

3)提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是

要把管理对象集合和遍历对象集合的责任分开

，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。

4)当要展示一组相似对象，或者

遍历

一组相同对象时使用, 适合使用迭代器模式

缺点

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

观察者模式

关注

一对多的订阅形式

，分离观察者(订阅者)和数据提供者，实现解耦

一、天气预报项目需求,具体要求如下：

1)气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)。

2)需要设计开放型 API，便于其他第三方也能接入气象站获取数据。

3)提供温度、气压和湿度的接口

4)测量数据更新时，要能实时的通知给第三方

二、普通方案

传统的设计方案

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

代码实现

WeatherData主动推送的方式

CurrentConditions理解为应用网址

主函数：

public class Client {
    public static void main(String[] args) {
        //创建接入方 currentConditions
        CurrentConditions currentConditions = new CurrentConditions();
        //创建 WeatherData 并将 接入方 currentConditions 传递到 WeatherData 中
        WeatherData weatherData = new WeatherData(currentConditions);

        //更新天气情况
        weatherData.setData(30, 150, 40);
        //天气情况变化
        System.out.println("============天气情况变化=============");
        weatherData.setData(40, 160, 20);
    }
}

CurrentConditions：

/**
*	显示当前天气情况（可以理解成是气象站自己的网站）
*	@author Administrator
*
*/
public class CurrentConditions {
    // 温度，气压，湿度
    private float temperature; 
    private float pressure; 
    private float humidity;

    //更新 天气情况，是由 WeatherData 来调用，我使用推送模式
    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("***Today mTemperature: " + temperature + "***");
        System.out.println("***Today mPressure: " + pressure + "***");
        System.out.println("***Today mHumidity: " + humidity + "***");
    }
    
}

WeatherData：

/**
*	类是核心
*	1. 包含最新的天气情况信息
*	2. 含有 CurrentConditions 对象
*	3.  当数据有更新时，就主动的调用	CurrentConditions 对象 update 方法(含 display),  这样他们（接入方）就看到最新的信息
*	@author Administrator
*
*/
public class WeatherData { 
    private float temperatrue; 
    private float pressure; 
    private float humidity;
    //加入新的第三方
    private CurrentConditions currentConditions;
    
    public WeatherData(CurrentConditions currentConditions) { 
        this.currentConditions = currentConditions;
    }

    public float getTemperature() { 
        return temperatrue;
    }

    public float getPressure() { 
        return pressure;
    }

    public float getHumidity() { 
        return humidity;
    }

    public void dataChange() {
        //调用 接入方的 update
        currentConditions.update(getTemperature(), getPressure(), getHumidity());
    }

    //当数据有更新时，就调用 setData
    public void setData(float temperature, float pressure, float humidity) { 
        this.temperatrue = temperature;
        this.pressure = pressure; 
        this.humidity = humidity;
        //调用 dataChange， 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }
    
}

问题分析

1)其他第三方接入气象站获取数据的问题

无法在运行时动态的添加第三方 (新浪网站)

3)违反 ocp 原则=>

观察者模式

//在 WeatherData 中，当增加一个第三方，都需要创建一个对应的第三方的公告板对象，并加入到 dataChange, 不利于维护，也不是动态加入
public void dataChange() {
    currentConditions.update(getTemperature(), getPressure(), getHumidity());
}

三、观察者模式原理

观察者模式类似订牛奶业务

1)奶站/气象局：Subject

2)用户/第三方网站：Observer （观察者）

Subject：登记注册、移除和通知 ---->相当于上面的WeatherData

1)registerObserver：注册

2)removeObserver：移除

3)notifyObservers() 通知所有的注册的用户，根据不同需求，可以是更新数据，让用户来取，也可能是实施推送，看具体需求定

Observer：接收输入（观察者）
观察者模式：

对象之间
多对一依赖 的一种设计方案，被依赖的对象为 Subject，依赖的对象为 Observer，Subject通知 Observer 变化, 比如这里的奶站是 Subject，是 1 的一方。用户时 Observer，是多的一方。

四、观察者模式解决天气预报需求

1、类图说明

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

2、代码实现

BaiduSite

public class BaiduSite implements Observer {
    // 温度，气压，湿度
    private float temperature; 
    private float pressure; 
    private float humidity;

    //  更新  天气情况，是由  WeatherData  来调用，我使用推送模式
    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("===百度网站====");
        System.out.println("***百度网站 气温 : " + temperature + "***");
        System.out.println("***百度网站 气压: " + pressure + "***");
        System.out.println("***百度网站 湿度: " + humidity + "***");
    }
}

主函数

public class Client {
    public static void main(String[] args) {
        //创建一个 WeatherData
        WeatherData weatherData = new WeatherData();

        //创建观察者
        CurrentConditions currentConditions = new CurrentConditions();
        BaiduSite baiduSite = new BaiduSite();

        // 注 册 到 weatherData 
        weatherData.registerObserver(currentConditions); 
        weatherData.registerObserver(baiduSite);

        //测试                                                         
        System.out.println("通知各个注册的观察者, 看看信息");
        weatherData.setData(10f, 100f, 30.3f);
        weatherData.removeObserver(currentConditions);
        
        System.out.println("==========================");
        
        //测试
        System.out.println("通知各个注册的观察者, 看看信息"); 
        weatherData.setData(10f, 100f, 30.3f);
    }
}

CurrentConditions

public class CurrentConditions implements Observer {
    // 温度，气压，湿度
    private float temperature;
    private float pressure; 
    private float humidity;

    // 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
    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("***Today mTemperature: " + temperature + "***"); 
        System.out.println("***Today mPressure: " + pressure + "***");
        System.out.println("***Today mHumidity: " + humidity + "***");
    }
    
}

Observer

//观察者接口，有观察者来实现 
public interface Observer {
    public void update(float temperature, float pressure, float humidity);
}

Subject

//接口, 让 WeatherData 来实现
public interface Subject {
    public void registerObserver(Observer o); 
    public void removeObserver(Observer o); 
    public void notifyObservers();
}

WeatherData

/**
*	类是核心
*	1. 包含最新的天气情况信息
*	2. 含有 观察者集合，使用 ArrayList 管理
*	3.  当数据有更新时，就主动的调用	ArrayList, 通知所有的（接入方）就看到最新的信息
*	@author Administrator
*
*/
@Data
public class WeatherData implements Subject { 
    private float temperatrue;
    private float pressure;
    private float humidity;
    //观察者集合
    private ArrayList<Observer> observers;
    
    //加入新的第三方
    public WeatherData() {
        observers = new ArrayList<Observer>();
    }

    public void dataChange() {
        //调用 接入方的 update
        notifyObservers();
    }

    //当数据有更新时，就调用 setData
    public void setData(float temperature, float pressure, float humidity) { 
        this.temperatrue = temperature;
        this.pressure = pressure; 
        this.humidity = humidity;
        //调用 dataChange， 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }

    //注册一个观察者 
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    //移除一个观察者 
    @Override
    public void removeObserver(Observer o) {
        if(observers.contains(o)) {
            observers.remove(o);
        }
    }
    
    //遍历所有的观察者，并通知 
    @Override
    public void notifyObservers() {
        //遍历集合
        for(int i = 0; i < observers.size(); i++) {
            //根据每个订阅的观察者对应的数据
            observers.get(i).update(this.temperatrue, this.pressure, this.humidity);
        }
    }
}

3、观察者模式的好处

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

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

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

迭代器模式

一、需求

二、传统的设计方案(类图)

三、传统的方式的问题分析

四、迭代器模式基本介绍

五、迭代器模式应用实例

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

观察者模式

一、天气预报项目需求,具体要求如下：

二、普通方案

三、观察者模式原理

四、观察者模式解决天气预报需求

1、类图说明

2、代码实现

3、观察者模式的好处

继续阅读

nginx location中斜线的位置的重要性

数据结构与算法（27）——排序（二）

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

Linux设备模型（中）之上层容器

scala (3) Function 和 Method

Day318.迭代器模式&amp;观察者模式 -Java设计模式迭代器模式观察者模式

迭代器模式

一、需求

二、传统的设计方案(类图)

三、传统的方式的问题分析

四、迭代器模式基本介绍

五、迭代器模式应用实例

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

观察者模式

一、天气预报项目需求,具体要求如下：

二、 普通方案

三、 观察者模式原理

四、观察者模式解决天气预报需求

1、 类图说明

2、代码实现

3、观察者模式的好处

继续阅读

Day318.迭代器模式&观察者模式 -Java设计模式迭代器模式观察者模式

二、普通方案

三、观察者模式原理

1、类图说明