设计模式之----迭代器模式

最新推荐文章于 2021-08-19 13:53:29 发布
最新推荐文章于 2021-08-19 13:53:29 发布
阅读量306 收藏 3
点赞数
分类专栏： 其他 文章标签： 迭代器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxzxzx0119/article/details/81747693
版权

设计模式之迭代器模式

  • 迭代器模式总结
  • 两个餐馆合并案例
  • 传统设计
  • 迭代器模式设计
  • Java内置迭代器设计
  • 单一责任原则

迭代器模式总结

  • 迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。
  • 提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。把在元素之间游走的责任交给迭代器，而不是聚合对象。
  • 优点: 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
  • 迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

两个餐馆合并案例

案例:
现在有两个餐馆，一个蛋糕店，一个中餐厅，都有各自的菜单，现在要合并，也就是说要通过一个女服务员直接点单:
这里写图片描述

传统设计

这里写图片描述

首先两个餐厅: 

package iterator.bad;

import java.util.ArrayList;

/**
 * 蛋糕店
 */
public class CakeHouse {

    private ArrayList<MenuItem> menuItems;

    public CakeHouse() {
        menuItems = new ArrayList<>();
        addItem("Cakefood1",33.3);
        addItem("Cakefood2",44.4);
    }

    private void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        menuItems.add(menuItem);
    }

    //获取菜单项 //暴露在外面 //耦合度高，  封装性不好
    public ArrayList<MenuItem> getMenuItems() {
        return menuItems;
    }
}
package iterator.bad;


/**
 * 中餐厅
 */
public class DinerHouse {

    private final static int Max_Item = 5;//最多只有五个菜单项

    private int cur; //游标  

    public int getCur() {
        return cur;
    }

    private MenuItem[] menuItems;

    public DinerHouse() {
        menuItems = new MenuItem[Max_Item];
        addItem("Dinerfood1",11.1);
        addItem("Dinerfood2",22.2);
    }

    public void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        if(cur >= Max_Item){
            System.out.println("sorry! menu is full! can't add any item!");
        }else {
            menuItems[cur++] = menuItem;
        }
    }
    //暴露出来
    public MenuItem[] getMenuItems() {
        return menuItems;
    }
}

菜单项: 

package iterator.bad;

/**
 * 每个餐厅的菜单项
 */
public class MenuItem {

    private String name;
    private double price;


    public MenuItem(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

女招待: 

package iterator.bad;

import java.util.ArrayList;

/**
 * 女招待员
 * 必须同时有两个对象的引用
 */
public class Waitress {

    //蛋糕店的
    private CakeHouse cakeHouse;
    private ArrayList<MenuItem> cakeItems;

    //中餐厅的
    private DinerHouse dinerHouse;
    private MenuItem[] dinerItems;


    public Waitress() {
        cakeHouse = new CakeHouse();
        cakeItems = cakeHouse.getMenuItems();

        dinerHouse = new DinerHouse();
        dinerItems = dinerHouse.getMenuItems();
    }

    public void printMenu(){
        MenuItem item = null;
        for(int i = 0; i < cakeItems.size(); i++){
            item = cakeItems.get(i);
            System.out.println(item.getName() + " " + item.getPrice());
        }
        for(int i = 0; i < dinerHouse.getCur(); i++){
            item = dinerItems[i];
            System.out.println(item.getName() + " " + item.getPrice());
        }
    }

}

测试: 

package iterator.bad;

public class MyTest {

    public static void main(String[] args) {
        Waitress waitress = new Waitress();
        waitress.printMenu();
    }
}

输出:

Cakefood1 33.3
Cakefood2 44.4
Dinerfood1 11.1
Dinerfood2 22.2

这中方案存在的问题:

  • 如果再来一个餐厅要合并，比如说菜单是HashTable的，这样那边也要暴露自己的菜单，而且女招待要修改代码；
  • 开发要针对接口的开发，而不是具体实现的开发，而且这样设计耦合性增加；

迭代器模式设计

这里写图片描述
这里写图片描述
先看迭代器: 

package iterator.good;

/**
 * 迭代器的接口
 */
public interface Iterator {
    public boolean hasNext();
    public Object next();
}

两个餐厅: 

package iterator.good;

import java.util.ArrayList;

/**
 * 蛋糕店
 */
public class CakeHouse {

    private ArrayList<MenuItem> menuItems;

    public CakeHouse() {
        menuItems = new ArrayList<>();
        addItem("Cakefood1",33.3);
        addItem("Cakefood2",44.4);
    }

    private void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        menuItems.add(menuItem);
    }


    //实现迭代器的设计  不能设计为静态的
    private class CakeHouseIterator implements Iterator{

        private int pos;

        public CakeHouseIterator() {
            pos = 0;
        }

        @Override
        public boolean hasNext() {
            if(pos < menuItems.size()){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            MenuItem menuItem = menuItems.get(pos++);
            return menuItem;
        }
    }

    public Iterator getIterator(){
       return new CakeHouseIterator();
    }
}
package iterator.good;

/**
 * 中餐厅
 */
public class DinerHouse {

    private final static int Max_Item = 5;//最多只有五个菜单项

    private int cur; //游标  

    private MenuItem[] menuItems;

    public DinerHouse() {
        menuItems = new MenuItem[Max_Item];
        addItem("Dinerfood1",11.1);
        addItem("Dinerfood2",22.2);
    }

    public void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        if(cur >= Max_Item){
            System.out.println("sorry! menu is full! can't add any item!");
        }else {
            menuItems[cur++] = menuItem;
        }
    }

    private class DinerHouseIterator implements Iterator{
        private int pos;

        public DinerHouseIterator() {
            pos = 0;
        }

        @Override
        public boolean hasNext() {
            if(pos < cur){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            MenuItem menuItem = menuItems[pos++];
            return menuItem;
        }
    }

    public Iterator getIterator(){
        return new DinerHouseIterator();
    }
}

菜单项(不变的): 

package iterator.good;

/**
 * 每个餐厅的菜单项
 */
public class MenuItem {

    private String name;
    private double price;


    public MenuItem(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

女招待: 

package iterator.good;

import iterator.good.MenuItem;

import java.util.ArrayList;

/**
 * 女招待  直接遍历Iterator
 */
public class Waitress {

    private ArrayList<Iterator> iterators = new ArrayList<>();

    public Waitress() {
    }

    //放入迭代器
    public void addIterator(Iterator iterator){
        iterators.add(iterator);
    }

    //不需要知道有些什么餐厅  完全解耦
    public void printMenu(){
        Iterator iterator = null;
        MenuItem menuItem = null;

        for(int i = 0; i < iterators.size(); i++){
            iterator = iterators.get(i); //每一个集合容器
            while(iterator.hasNext()){
                menuItem = (MenuItem)iterator.next();
                System.out.println(menuItem.getName() + " " + menuItem.getPrice());
            }
        }

    }
}

测试类: 

package iterator.good;

public class MyTest {
    public static void main(String[] args) {

        CakeHouse cake = new CakeHouse();
        DinerHouse diner = new DinerHouse();

        Waitress waitress = new Waitress();

        waitress.addIterator(cake.getIterator());
        waitress.addIterator(diner.getIterator());

        waitress.printMenu();

    }
}

输出效果(和之前的一样): 

Cakefood1 33.3
Cakefood2 44.4
Dinerfood1 11.1
Dinerfood2 22.2

使用迭代器设计模式很好的满足了扩容性和解耦。

Java内置迭代器设计

这里写图片描述
这里写图片描述
三家餐厅: (其中只有中餐厅使用的是数组，所以还是自己要添加一个，并实现Java中的Iterator接口)

package iterator.java;

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

/**
 * 蛋糕店
 */
public class CakeHouse {

    private ArrayList<MenuItem> menuItems;  //因为arrayList在java内部已经是实现了Iterator接口，所以可以直接得到

    public CakeHouse() {
        menuItems = new ArrayList<>();
        addItem("Cakefood1",33.3);
        addItem("Cakefood2",44.4);
    }

    private void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        menuItems.add(menuItem);
    }

    public Iterator getIterator(){
        return menuItems.iterator();  //内部的
    }
}
package iterator.java;


import java.util.Iterator;

/**
 * 中餐厅
 */
public class DinerHouse {

    private final static int Max_Item = 5;//最多只有五个菜单项

    private int cur; //游标   注意这里设置成public 的是为了要Waitress中使用

    private MenuItem[] menuItems;

    public DinerHouse() {
        menuItems = new MenuItem[Max_Item];
        addItem("Dinerfood1",11.1);
        addItem("Dinerfood2",22.2);
    }

    public void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        if(cur >= Max_Item){
            System.out.println("sorry! menu is full! can't add any item!");
        }else {
            menuItems[cur++] = menuItem;
        }
    }

    /**
     * 实现的是  Java内置的util包里面的
     */
    private class DinerHouseIterator implements Iterator {
        private int pos;

        public DinerHouseIterator() {
            pos = 0;
        }

        @Override
        public boolean hasNext() {
            if(pos < cur){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            MenuItem menuItem = menuItems[pos++];
            return menuItem;
        }

        @Override
        public void remove() {

        }
    }

    public Iterator getIterator(){
        return new DinerHouseIterator();
    }
}

新加的咖啡馆: (使用HashTable):

package iterator.java;

import java.util.Hashtable;
import java.util.Iterator;

/**
 * 新增的咖啡餐厅
 */
public class CafeHouse {

    private Hashtable<String,MenuItem> menuItems;

    public CafeHouse() {
        menuItems = new Hashtable<>();
        addItem("Cafefood1",55.5);
        addItem("Cafefood2",66.6);
    }

    public void addItem(String name,double price){
        MenuItem menuItem = new MenuItem(name,price);
        menuItems.put(name,menuItem);
    }

    public Iterator getIterator(){
        return menuItems.values().iterator(); //都有一个聚类 包括keys()和values()
    }
}

菜单项和女服务完全不需要改动: 

package iterator.java;

/**
 * 每个餐厅的菜单项
 */
public class MenuItem {

    private String name;
    private double price;


    public MenuItem(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}
package iterator.java;

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

/**
 * 女招待  直接遍历Iterator
 */
public class Waitress {

    private ArrayList<Iterator> iterators = new ArrayList<>();

    public Waitress() {
    }

    //放入迭代器
    public void addIterator(Iterator iterator){
        iterators.add(iterator);
    }

    //不需要知道有些什么餐厅  完全解耦
    public void printMenu(){
        Iterator iterator = null;
        MenuItem menuItem = null;

        for(int i = 0; i < iterators.size(); i++){
            iterator = iterators.get(i); //每一个集合容器
            while(iterator.hasNext()){
                menuItem = (MenuItem)iterator.next();
                System.out.println(menuItem.getName() + " " + menuItem.getPrice());
            }
        }

    }
}

测试:

package iterator.java;

public class MyTest {
    public static void main(String[] args) {

        CakeHouse cake = new CakeHouse();
        DinerHouse diner = new DinerHouse();
        CafeHouse cafe = new CafeHouse();

        Waitress waitress = new Waitress();

        waitress.addIterator(cake.getIterator());
        waitress.addIterator(diner.getIterator());
        waitress.addIterator(cafe.getIterator());

        waitress.printMenu();

    }
}

效果:

这里写图片描述
注意这里的Hash表输出和添加的顺序无关
再次体会到这样设计的好处:

  • 不需要修改女招待的代码；
  • 解耦和封装；

单一责任原则

概念： 一个类应该只有一个引起变化的原因。

  • 一个类只解决一个问题或者一个变化，比如说菜单项这个类，只是用来存储菜单的，至于遍历以及其他，由其他类完成；
  • 就是尽量不要一个类牵扯太多东西，目的还是为了降低耦合性；
zxzxin
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式学习总结(16) 迭代器模式
hacke2' Blog
04-06 2039
本系列主要记录设计模式的意图是什么，它要解决一个什么问题，什么时候可以使用它；它是如何解决的，掌握它的结构图，记住它的关键代码；能够想到至少两个它的应用实例，一个生活中的，一个软件中的；这个模式的优缺点是什么，其有哪些使用场景，在使用时要注意什么。
java设计模式---迭代器模式(iterator pattern)
渔潭的博客
03-20 2895
java设计模式—迭代器模式(iterator pattern) 1. 概述 可以存储多个成员对象（元素），这些类通常称为聚合类（Aggregate Classes），对应的对象称为聚合对象。为了更加方便地操作这些聚合对象，同时可以很灵活地为聚合对象增加不同的遍历方法，可以访问一个聚合对象中的元素但又不需要暴露它的内部结构。这就是接下来我们将要学习的迭代器模式，通过引入迭代器，客户端无须了解聚...
Java-迭代器-设计模式（十五）
大老龙的博客
01-26 149
Java实现迭代器模式的一个demo。
设计模式之迭代器模式
守夜人爱吃兔子的博客
08-19 226
迭代器模式的定义是通过提供一种方法顺序访问一个聚合对象中的各个元素，而又不必暴露该聚合对象中的内部表示。迭代器模式是针对聚合对象（数组、集合、链表）的“访问”而来。通过定义不同的遍历策略来遍历聚合对象。 应用场景 如果希望提供访问一个聚合对象的内容，但又不想暴露它的内部表示的时候可使用迭代器模式 如果希望有多种遍历方式可以访问聚合对象。 如果希望为遍历不同的聚合对象提供一个统一的接口，可以使用迭代器模式（多态迭代）。 UML图 迭代器模式中涉及的角色： 抽象迭代器角色（Iterator）：此
java设计模式之迭代器模式
weixin_34199405的博客
03-26 64
一、迭代器模式简介 迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。 迭代器模式让我们能游走于聚合内的每一个元素，而又不暴露内部的表示。把游走的任务放在迭代器上，而不是聚合上，这样简化了聚合的接口和实现，也让责任各得其所。 在设计中使用迭代器的影响是明显的：如果你有一个统一的方法访问聚合中的每一个对象，你就可以编写多态的代码和这些聚合搭配使用，只要有了...
java常用设计模式-迭代器模式
最新发布
08-28
Java 迭代器模式是一种行为设计模式，它提供了一种访问集合对象元素的方法，而不需要暴露该对象的内部表示。该模式适用于需要遍历集合对象的场景，例如数组、列表、树等。 迭代器模式的主要优点是： 1. 避免了集合...
c++设计模式-行为型模式-迭代器模式
06-25
迭代器模式是软件设计模式中的一种行为模式，它在C++以及其他面向对象编程语言中有着广泛的应用。这个模式的主要目标是允许用户以一种统一的方式遍历聚合对象中的元素，而无需暴露聚合对象的内部结构。这增加了代码...
JAVA-设计模式-行为型模式-迭代器模式
08-10
JAVA-设计模式-行为型模式-迭代器模式
GoF_23个设计模式通用类图(含下载)
09-19
GoF_23个设计模式通用类图，灰常的好看啊，大家来下吧，哈哈哈哈哈哈
设计模式--迭代器模式java例子
02-12
迭代器模式是一种行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java中，迭代器模式广泛应用于集合框架，如ArrayList、LinkedList等。本示例将深入探讨如何在Java中实现和使用迭代器...
iterator-demo 迭代器设计模式demo
03-16
这个“iterator-demo”应该是一个示例项目，用于演示如何在实际编程中应用迭代器模式。下面我们将深入探讨迭代器模式及其在IT领域的应用。 迭代器模式的核心思想是为集合类提供一种统一的访问方式，使得客户代码...
十一、迭代器模式与命令模式详解
编程之心的博客
03-21 388
十一、迭代器模式与命令模式详解 18.迭代器模式 18.1.课程目标 1、 了解迭代器模式和命令的应用场景。 2、 自己手写迭代器 3、 掌握迭代器模式和命令模式在源码中的应用，知其所以然。 18.2.内容定位 听说过迭代器模式和命令模式，但并不知其所以然的人群。 18.3.迭代器模式 迭代器模式( Iterator Pattern ) 又称为游标模式(Cursor Pattern), 它提供一种...
【java设计模式】（6）---迭代器模式（案例解析）
a8892117的博客
07-01 2322
设计模式之迭代器模式 一、java迭代器介绍 1、迭代器接口 在jdk中,与迭代器相关的接口有两个:Iterator 与 Iterable。 Iterator:迭代器，Iterator及其子类通常是迭代器本身的结构与方法；迭代器是一种模式，它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离，即我们无需关心该序列的底层结构是什么样子的。只要拿到 这个对象,使用迭代...
设计模式—— 十五 ：命令模式
三分恶的博客
06-28 2825
请求发送者与接收者解耦——命令模式
Java Iterator Pattern(迭代器模式)
mazaiting的博客
09-10 111
迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。迭代器模式属于行为型模式。 关键代码：定义接口：hasNext, next。 优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。...
JAVA设计模式之 迭代器模式【Iterator Pattern】
小吕丶Code阶区
12-01 1783
一、概述     提供一种方法来访问聚合对象(容器container)，而不用暴露这个对象的内部细节。 二、适用场景     1>遍历访问聚合对象中的元素，而无须暴露它的内容表示，将聚合对象的访问和内部数据的存储分离。使得访问聚合对象时无须了解其内部的实现细节。     2>需要为一个聚合对象提供多种遍历实现。 三、UML类图 四、参与者  1>Ite
Windows下使用cmd + Vim进行编程(初级_vimrc配置(无插件配置))
热门推荐
zxzxin的博客~
05-03 4万+
目录 说明 下载安装gvim，配置环境变量，设置管理员打开cmd cmd下使用vim打开文件并编程 _vimrc的简单配置 vim下一些简单的操作 g++命令编译运行main.cpp文件 小结 说明 很多搞算法的童鞋喜欢用codeblocks写c,c++，现在ACM区域赛中大部分使用linux下的vim进行编程,使用vim编程最大的好处就是可以脱离鼠标进行编程，还有就是使用...
设计模式在Android开发中的应用-迭代器模式
"Iterator(迭代器模式)是设计模式中的一种，在Android开发中扮演着重要角色。迭代器模式主要用于遍历容器对象中的元素，而无需暴露其底层表示。这种模式提供了一种统一的访问接口，使得代码更加简洁、可读性强。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值