Java设计模式之行为型-迭代器模式(UML类图+案例分析)

这篇具有很好参考价值的文章主要介绍了Java设计模式之行为型-迭代器模式(UML类图+案例分析)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、基础概念

二、UML类图

三、角色设计

四、案例分析

五、总结


一、基础概念

迭代器模式是一种常用的设计模式,它主要用于遍历集合对象,提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露该对象的内部表示。

举个简单的比喻,聚合对象像一个存放苹果的篮子,迭代器就像篮子边上的搬运工,专门负责把苹果一个一个取出来。客户端只需要找到搬运工,然后不停地让他取出苹果就可以了,而不需要关心篮子里面是怎么存放的。这样既方便客户端使用,也屏蔽了聚合对象内部的复杂性!

二、UML类图

Java设计模式之行为型-迭代器模式(UML类图+案例分析),Java,设计模式,java,设计模式,迭代器模式

三、角色设计

角色 描述
抽象聚合角色 定义存创建、添加、获取等迭代器对象的接口
具体聚合角色 抽象聚合角色的实现类,返回一个具体迭代器实例
抽象迭代器角色 定义访问和遍历聚合元素的接口,通常包裹hashNext()和next()方法
具体迭代器角色 实现抽象迭代器接口中所定义的方法,完成聚合对象的遍历,记录遍历的当前为止
客户端角色 用于使用迭代器遍历聚合对象

四、案例分析

用迭代器模式模拟一个学生管理系统,主要内容如下:

1、定义Student类,表示学生信息。

2、定义StudentAggregate接口,作为学生集合的抽象接口。

3、实现StudentAggregateImpl类,具体的学生集合,使用List存储Student。

4、定义Iterator接口,规定迭代器的通用方法。

5、实现StudentIterator类,具体的学生迭代器。

6、在客户端代码中,通过迭代器遍历StudentAggregateImpl中的学生集合。

通过迭代器模式实现对学生集合的遍历,同时隐藏学生集合的具体实现细节,示例代码如下:

定义学生类:

public class Student {

  private String name;
  private int age;

  public Student(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public int getAge() {
    return age;
  }
}

学生集合抽象聚合类:


public interface StudentAggregate {

  public Iterator createIterator();

  public int getNumberOfStudents();

  public Student getStudent(int index);

  public void addStudent(Student student);

}

学生集合具体聚合角色:

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

public class StudentAggregateImpl implements StudentAggregate{
  private List<Student> students;
  
  public StudentAggregateImpl() {
    students = new ArrayList<>();
  }

  @Override
  public Iterator createIterator() {
    return new StudentIterator(this);
  }  

  @Override
  public int getNumberOfStudents() {
    return students.size();
  }

  @Override
  public Student getStudent(int index) {
    return students.get(index);
  }

  @Override
  public void addStudent(Student student) {
    students.add(student);
  }
}

 抽象迭代器角色:

public interface Iterator {
  
  public boolean hasNext();

  public Student next();

}

学生具体迭代器角色:

public class StudentIterator implements Iterator {

  private StudentAggregate studentAggregate;
  private int index;

  public StudentIterator(StudentAggregate studentAggregate) {
    this.studentAggregate = studentAggregate;
  }

  @Override
  public boolean hasNext() {
    return (index < studentAggregate.getNumberOfStudents());
  }

  @Override
  public Student next() {
    return studentAggregate.getStudent(index++);
  }

}

客户端:

public class Client {

    public static void main(String[] args) {
        //使用示例
        StudentAggregate students = new StudentAggregateImpl();
        // 添加学生
        Student john = new Student("John", 18);
        Student mike = new Student("Mike", 18);
        students.addStudent(john);
        students.addStudent(mike);
        Iterator iterator = students.createIterator();
        while(iterator.hasNext()) {
            Student student = iterator.next();
            System.out.println(student.getName());
        }
    }
}

运行结果如下:

Java设计模式之行为型-迭代器模式(UML类图+案例分析),Java,设计模式,java,设计模式,迭代器模式

这个迭代器模式在学生管理示例中的执行逻辑过程: 

1、定义Student类,用于表示学生信息。

2、定义StudentAggregate接口,作为抽象学生集合类,声明管理学生的通用方法。

3、实现StudentAggregateImpl类,具体的学生集合,使用List存储Student对象。

4、定义Iterator接口,规定迭代器的通用方法。

5、实现StudentIterator类,具体的学生迭代器,持有对StudentAggregate的引用。

6、创建StudentAggregateImpl对象students,表示具体的学生集合。

7、调用students的addStudent()方法,向集合中添加学生。

8、调用students的createIterator()方法,获取迭代器对象。

9、使用迭代器的hasNext()和next()方法遍历students集合,访问其中的学生对象。

10、在整个过程中,客户端代码都只与Iterator接口发生依赖,而不需了解学生集合的具体实现/

这样通过迭代器模式可以实现学生集合的遍历,同时也达到了对访问学生集合的控制和集合内部表示的封装。 

五、总结

优点:

1隔离了集合对象的遍历行为,抽象出一个迭代器类来负责迭代元素。

2提供了一种方法顺序访问一个聚合对象中的各个元素,而又无需暴露该对象的内部表示。

3迭代器简化了聚合类。客户端如果需要遍历聚合对象,只需要初始化一个迭代器,不需要知道聚合对象内部的具体实现。

4在同一个聚合类中可以定义多个遍历方式,通过不同的迭代器来实现。

5符合单一职责原则。

6实现了集合类的常用遍历算法,容易扩展和维护。

缺点:

1、增加了类的个数,代码复杂度会增加,需要维护更多的代码。

2、多态性能损耗。遍历时需要进行多次虚函数调用,遍历效率降低。

3、遍历算法复用性差。每次遍历都需要创建新的迭代器实例,无法重用已定义好的遍历算法。

应用场景:

1、访问一个聚合对象的内容而无需暴露它的内部表示。

2、为遍历不同的集合结构提供一个统一的接口(即支持多态迭代)。

3、提供一种方法顺序访问一个聚合对象中的各个元素,而又无需暴露该对象的内部表示。

4、分离集合对象的遍历行为到一个独立的迭代器类中。

符合的设计原则:

1、单一职责原则(Single Responsibility Principle)

迭代器模式将集合对象的遍历行为抽象到迭代器类中,集合类只负责存储,迭代器类只负责遍历。二者职责区分明确,符合单一职责原则。

2、开闭原则(Open Closed Principle)

可以在不修改集合类的情况下,定义新的迭代器类,满足扩展需求。增强了系统的可扩展性。

3、依赖倒转原则(Dependency Inversion Principle)

迭代器模式中,集合类和客户端都依赖于抽象迭代器接口,而不是依赖于具体迭代器类,倒转了依赖关系。

4、组合复用原则(Composite Reuse Principle)

客户端可以统一使用迭代器接口遍历不同的集合类,复用迭代器提供的遍历功能。

5、里氏替换原则(Liskov Substitution Principle)

迭代器模式中,每个迭代器类都可以通过继承迭代器接口,替换基类迭代器角色。文章来源地址https://www.toymoban.com/news/detail-560117.html

到了这里,关于Java设计模式之行为型-迭代器模式(UML类图+案例分析)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java设计模式之行为型-备忘录模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 五、总结  备忘录模式是一种行为型设计模式,它允许保存一个对象的内部状态到一个备忘录对象中,这样就可以在需要的时候恢复这个对象的状态了,同时又不违反封装性原则。 这个模式的核心就是备忘录对象,

    2024年02月16日
    浏览(38)
  • Java设计模式之创建型-原型模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析  4.1、通用实现(浅克隆) 4.2、深克隆 五、总结 原型模式通过复制已有对象作为原型,通过复制该原型来返回一个新对象,而不是新建对象,说白了就是不断复制相同的对象罢了。 角色 描述 抽象原型类 规定了具

    2024年02月15日
    浏览(49)
  • Java设计模式之结构型-桥接模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 4.1、支付方式 4.2、支付渠道  五、总结 桥接模式(Bridge Pattern)是一种结构型设计模式,其主要目的是“将抽象部分与实现部分分离,使它们都可以独立地变化”。 桥接模式的核心思想是把抽象(abstraction)与实现

    2024年02月13日
    浏览(47)
  • Java设计模式之创建型-单例模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 4.1、饿汉模式 4.2、懒汉模式(线程不安全) 4.3、懒汉模式(线程安全) 4.4、双重检索模式 4.5、静态内部类 4.6、枚举  五、总结 单例模式确保一个类只有一个实例,提供一个全局访问点。一般实现方式是把构造函

    2024年02月13日
    浏览(46)
  • Java设计模式之创建型-建造者模式(UML类图+案例分析)

    目录 一、基本概念 二、UML类图 三、角色设计  四、案例分析 五、总结 建造者模式是一种创建型设计模式,它使我们将一个复杂对象的构建步骤分离出来,使得同样的构建过程可以创建不同的表示。该模式的目的是将构建复杂对象的过程抽象化,从而减少代码的重复和复杂

    2024年02月15日
    浏览(44)
  • Java设计模式之结构型-组合模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 4.1、基本实现 4.2、菜单遍历  五、总结  组合模式(Composite Pattern)又叫部分-整体模式,它通过将对象组合成树形结构来表示“整体-部分”的层次关系,允许用户统一单个对象和组合对象的处理逻辑。 角色 描述

    2024年02月16日
    浏览(50)
  • Java设计模式之结构型-享元模式(UML类图+案例分析)

    目录 一、基本概念 二、UML类图 三、角色设计 四、案例分析 4.1、基本实现 4.2、游戏角色 五、总结 享元模式是一种结构型设计模式,主要用于减少创建大量相似对象所占用的内存,它通过共享技术来有效支持大量细粒度的对象。 角色 描述 抽象享元角色 定义出对象的外部状

    2024年02月16日
    浏览(45)
  • Java设计模式之结构型-装饰器模式(UML类图+案例分析)

    目录 一、基本概念 二、UML类图 三、角色设计 四、代码实现 案例一 案例二  五、总结  装饰器模式是指不必在改变原有的类和不使用继承的情况下,动态扩展一个对象的功能。 角色 描述 抽象构件 是一个接口或者抽象类,定义我们最核心的对象 具体构件 抽象构件的实现,

    2024年02月11日
    浏览(35)
  • Java设计模式之UML类图

    UML图有很多种,但是并非必须掌握所有的UML图,才能完整系统分析和设计工作。一般说来,在UML图中,只要掌握类图、用例图、时序图的使用,就能完成大部分的工作。对于程序员来说,最频繁使用的莫过于类图。因此,这里我只讲解UML类图。 类图是面向对象系统建模中最常

    2024年02月03日
    浏览(42)
  • Java设计模式之责任链模式(UML类图分析+代码详解)

    大家好,我是一名在算法之路上不断前进的小小程序猿!体会算法之美,领悟算法的智慧~ 希望各位博友走过路过可以给我点个免费的赞,你们的支持是我不断前进的动力!! 加油吧!未来可期!! 本文将介绍java设计模式之责任链模式 OA系统采购审批需求 传统方案解决OA系

    2024年02月06日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包