软件设计模式之路-----迭代器模式

 

在软件设计中，我们经常需要访问聚合对象的各个元素。因为遍历方法可能会改动。所以不能将访问方法直接写在聚合对象中，因为这会违背“开闭原则”。

简单点开篇就是，想想 Java 中的 Collection、List、Set、Map 。他们都是使用了迭代器模式访问元素的

迭代器模式定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

优点：

• 访问一个聚合对象的内容而无须暴露它的内部表示。
• 遍历任务交由迭代器完成，这简化了聚合类。 
• 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。增加新的聚合类和迭代器类都很方便，无须修改原有代码。
• 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点：

• 增加了类的个数，这在一定程度上增加了系统的复杂性。

在日常开发中，我们几乎不会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器。

迭代器模式的结构与实现

结构

1. 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2. 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。 
3. 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。 
4. 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

实现

实现场景：定义一个班级类，使用迭代器来遍历班级中的学生。

package com.wly.DesignPatterns;

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

/**
 * @program: StudyDome
 * @author: yuanzhang
 * @create: 2020-12-29 15:17
 **/
public class IteratorPattern {
    public static void main(String[] args) {
        ClassGrade classGrade = new ClassGradeImpl();
        //给班级加入十个娃
        for (int i = 1; i < 11; i++) {
            Student student = new Student("王"+i,i);
            classGrade.addStudent(student);
        }
        studentIterator studentIterator = classGrade.getStudentIterator();
        System.out.println("开始报数");
        while (studentIterator.hasNext()){
            Student student = studentIterator.next();
            System.out.println(String.format("我是 %s ,编号为 %d",student.getName(),student.getNumber()));
        }
    }
}
//学生实体类
class Student{
    private String name;
    private Integer number;

    public Student(String name, Integer number) {
        this.name = name;
        this.number = number;
    }

    public String getName() {
        return name;
    }

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

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }
}
/** 
 * @Annotation:抽象聚合类：班级
 * @Author: yuanzhang
 * @Date:  15:24
 */ 
interface ClassGrade{
    void addStudent(Student student);

    void removeStudent(Student student);

    studentIterator getStudentIterator();
}
/**
 * @Annotation:具体聚合类：班级体
 * @Author: yuanzhang
 * @Date:  15:27
 */
class ClassGradeImpl implements ClassGrade{
    private List<Student> studentList;

    public ClassGradeImpl() {
        this.studentList = new ArrayList <Student>();
    }

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

    @Override
    public void removeStudent(Student student) {
        studentList.remove(student);
    }

    @Override
    public studentIterator getStudentIterator() {
        return new StudentIteratorImpl(studentList);
    }
}
/**
 * @Annotation:抽象迭代器：学生迭代器
 * @Author: yuanzhang
 * @Date:  15:30
 */
interface studentIterator{
    boolean hasNext();
    Student next();
}
/**
 * @Annotation:具体迭代器：学生迭代器
 * @Author: yuanzhang
 * @Date:  15:31
 */
class StudentIteratorImpl implements studentIterator{
    private List<Student> studentList;

    /**游标*/
    private int index=0;

    public StudentIteratorImpl(List <Student> studentList) {
        this.studentList = studentList;
    }

    @Override
    public boolean hasNext() {
        return studentList.size()>index;
    }

    @Override
    public Student next() {
        return studentList.get(index++);
    }
}

输出

开始报数
我是 王1 ,编号为 1
我是 王2 ,编号为 2
我是 王3 ,编号为 3
我是 王4 ,编号为 4
我是 王5 ,编号为 5
我是 王6 ,编号为 6
我是 王7 ,编号为 7
我是 王8 ,编号为 8
我是 王9 ,编号为 9
我是 王10 ,编号为 10