设计模式（十五）-- 迭代器模式

源代码
GitHub源代码

1.本文目标

本文目标是为了让大家认识并理解迭代器模式

2.基本套路

定义:提供一种方法,顺序访问一个集合对象中的各个元素,而又不暴露该对象的内部表示
类型:行为型
选择关键点:客户端是否关心遍历的次序
设计原则:遵循迪米特
使用概率:99.99999%
难度系数:中

3.适用场景

1.访问一个集合对象的内容而无需暴露它的内部表示
2.为遍历不同的集合结构提供一个统一的接口

4.使用步骤

用栗子能更好的说明问题,请继续往下看

5.举个栗子

我们用具体的代码去更好的理解这个设计模式

5.1栗子说明

• 背景:网上有很多学习Java的课程
• 目的:然后想通过迭代器模式去进行遍历并打印

5.2使用步骤

实现代码如下:

步骤1.创建课程的实体类

public class Course {
    private String name;

    public Course(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

步骤2.创建课程的集合 接口

public interface CourseAggregate {

    /**
     * 添加课程
     */
    void addCourse(Course course);

    /**
     * 删除课程
     */
    void removeCourse(Course course);

    /**
     * 课程迭代器
     */
    CourseIterator getCourseIterator();
}

步骤3.创建课程的集合 的实现类

public class CourseAggregateImpl implements CourseAggregate {

    private List courseList;

    public CourseAggregateImpl() {
        this.courseList = new ArrayList();
    }

    @Override
    public void addCourse(Course course) {
        courseList.add(course);
    }

    @Override
    public void removeCourse(Course course) {
        courseList.remove(course);
    }

    @Override
    public CourseIterator getCourseIterator() {
        return new CourseIteratorImpl(courseList);
    }
}

步骤4. 课程迭代器的接口类

public interface CourseIterator {
    /**
     * 获取下个一个课程
     */
    Course nextCourse();

    /**
     * 是不是下一个课程
     */
    boolean isLastCourse();
}

步骤5. 课程迭代器的实现类

public class CourseIteratorImpl implements CourseIterator {
    private List courseList;
    private int position;
    private Course course;
    public CourseIteratorImpl(List courseList){
        this.courseList=courseList;
    }

    @Override
    public Course nextCourse() {
        System.out.println("返回课程,位置是: "+position);
        course=(Course)courseList.get(position);
        position++;
        return course;
    }

    @Override
    public boolean isLastCourse(){
        if(position< courseList.size()){
            return false;
        }
        return true;
    }
}

步骤6. 测试

 public static void main(String[] args) {
         //创建3个课程
        Course course1 = new Course("Java基础");
        Course course2 = new Course("Android基础");
        Course course3 = new Course("Java设计模式");

        //把这3个课程添加到课程集合类中
        CourseAggregate courseAggregate = new CourseAggregateImpl();
        courseAggregate.addCourse(course1);
        courseAggregate.addCourse(course2);
        courseAggregate.addCourse(course3);

        System.out.println("-----课程列表-----");
        printCourses(courseAggregate);
        //删除课程3(Java设计模式)
        courseAggregate.removeCourse(course3);
        System.out.println("-----删除操作之后的课程列表-----");
        printCourses(courseAggregate);
 }

  /**
   * 遍历迭代器并打印课程的名字
   */
  public static void printCourses(CourseAggregate courseAggregate){
        CourseIterator courseIterator= courseAggregate.getCourseIterator();
        while(!courseIterator.isLastCourse()){
            Course course=courseIterator.nextCourse();
            System.out.println(course.getName());
       }
  }

6.优点

• 分离了集合对象的遍历行为

7.缺点

• 类的个数成对增加

8.总结

本文只是对迭代器模式进行一个分享,接下来会从创建型模式,结构型模式,行为型模式,这三大类展开一个系列分享,大家可以持续进行关注,信仰年輕的设计模式,蟹蟹啦。