迭代器模式coding

业务场景源码,Test先不看,课程的集合抽象类,下面是课程集合的一个实现类,那CourseAggregate是一个接口,

接口也是类,可以把它理解成课程集合的抽象类,当然呢这里并不是AbstractClass,因为这里并没有具体的实现,

如果有的话我们可以把它声明成,abstract class,然后下面是具体的实现类,右侧是一个迭代器接口,下面是课程迭代器

的一个具体的实现,同时在迭代器里面通过组合的方式,一比一的关系,把Course作为Course迭代器的成员,那这个关系还是

非常清晰的,然后我们来到Test里边

package com.learn.design.pattern.behavioral.iterator;

/**
 * 业务场景是什么呢
 * 是网站的一个课程
 * 首先我们有一个课程的实体类
 * 这个课程有一个名字
 * 那在网站上有很多的课程
 * 我们可以对课程进行一些处理
 * 
 * 
 * @author Leon.Sun
 *
 */
public class Course {
    private String name;

    /**
     * 还有他的构造器
     * 
     * 
     * @param name
     */
    public Course(String name) {
        this.name = name;
    }

    /**
     * 还有getName这么一个方法
     * 
     * 
     * @return
     */
    public String getName() {
        return name;
    }

}

package com.learn.design.pattern.behavioral.iterator;

/**
 * CourseAggregate这么一个类
 * 这里面可以addCourse
 * 增加课程
 * 也可以removeCourse
 * 删除课程
 * 然后我们在这个接口下边
 * 又声明了一个方法
 * 获得这个课程的迭代器
 * 
 * 
 * @author Leon.Sun
 *
 */
public interface CourseAggregate {

    void addCourse(Course course);
    void removeCourse(Course course);

    /**
     * 注意返回值是CourseIterator
     * 那我们再看一下CourseIterator这个接口是什么呢
     * 
     * @return
     */
    CourseIterator getCourseIterator();



}

package com.learn.design.pattern.behavioral.iterator;

/**
 * 里边有两个方法
 * 一个是获取下一个课程
 * 还有判断是不是最后一个课程
 * 对应的实现我们看一下
 * 
 * 
 * @author Leon.Sun
 *
 */
public interface CourseIterator {
    Course nextCourse();
    boolean isLastCourse();

}

package com.learn.design.pattern.behavioral.iterator;

import java.util.List;

/**
 * 这个接口的实现
 * 
 * 
 * @author Leon.Sun
 *
 */
public class CourseIteratorImpl implements CourseIterator {

	/**
	 * 首先在里面声明一个private的List
	 * 这里面就是一个课程的集合
	 * 
	 * 
	 */
    private List courseList;
    /**
     * 权限可以使用private
     * 因为现在我们并没有对他进行开放
     * 
     * 
     */
    private int position;
    private Course course;
    /**
     * 传入的是课程的集合
     * 
     * 
     * @param courseList
     */
    public CourseIteratorImpl(List courseList){
        this.courseList=courseList;
    }

    /**
     * 我们主要关注实现的这两个方法
     * 首先第一个下一个课程
     * 
     * 然后继续来看这两个方法
     * 
     * 
     */
    @Override
    public Course nextCourse() {
    	/**
    	 * 这里直接输出返回课程是position
    	 * 而这个position就声明在迭代器里面的成员
    	 * 
    	 * 
    	 */
        System.out.println("返回课程,位置是: "+position);
        /**
         * 这里直接按位置取出对应的课程
         * 然后强转
         * 赋值到迭代器的course当中
         * 
         * 
         */
        course=(Course)courseList.get(position);
        /**
         * 然后位置++
         * 返回对应的Course
         * 
         * 
         */
        position++;
        return course;
    }

    /**
     * 然后看一下下边
     * 是最后一个课程吗
     * 
     * 
     */
    @Override
    public boolean isLastCourse(){
    	/**
    	 * 如果当前的位置小于集合的size的话
    	 * 我们就认为不是最后一个课程
    	 * 反之就会走到return true
    	 * 如果当前的位置大于等于size
    	 * 就会返回true
    	 * 那这两个实现都非常的简单
    	 * 我们通过这么一个业务场景呢
    	 * 来实现了一个迭代器模式
    	 * 自己来实现了一个迭代器
    	 * 这个迭代器是课程的迭代器
    	 * 那我们现在来看一下UML图
    	 * 
    	 * 
    	 */
        if(position< courseList.size()){
            return false;
        }
        return true;
    }
}

package com.learn.design.pattern.behavioral.iterator;

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

/**
 * 他实现了CourseAggregate接口
 * 
 * 
 * @author Leon.Sun
 *
 */
public class CourseAggregateImpl implements CourseAggregate {

	/**
	 * 这里面调用的正是list的add和remove方法
	 * 
	 * 
	 */
    private List courseList;

    /**
     * 然后我们在无参构造器里面初始化一下
     * 
     * 
     */
    public CourseAggregateImpl() {
        this.courseList = new ArrayList();
    }

    /**
     * 一个是增加课程
     * 当然这个是比较简单的业务场景
     * 放到构造器
     * 或者外部
     * 显示的编写都OK
     * 
     * 
     */
    @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);
    }
}

package com.learn.design.pattern.behavioral.iterator;

/**
 * 
 * @author Leon.Sun
 *
 */
public class Test {


    public static void main(String[] args) {
    	/**
    	 * 这里首先创建6个课程
    	 * 现在网站上有这6个课程
    	 * 
    	 * 
    	 */
        Course course1 = new Course("Java电商一期");
        Course course2 = new Course("Java电商二期");
        Course course3 = new Course("Java设计模式精讲");
        Course course4 = new Course("Python课程");
        Course course5 = new Course("算法课程");
        Course course6 = new Course("前端课程");


        /**
         * 然后我们声明一个集合CourseAggregate
         * 
         * 
         */
        CourseAggregate courseAggregate = new CourseAggregateImpl();

        /**
         * 然后往里面添加课程
         * 而这个添加正是courseList的add方法
         * 那这6个课程添加完成之后呢
         * 输出一下课程的列表是什么
         * 
         * 
         */
        courseAggregate.addCourse(course1);
        courseAggregate.addCourse(course2);
        courseAggregate.addCourse(course3);
        courseAggregate.addCourse(course4);
        courseAggregate.addCourse(course5);
        courseAggregate.addCourse(course6);

        System.out.println("-----课程列表-----");
        /**
         * 这里有一个printCourses
         * 看一下下边的实现
         * 
         * 
         */
        printCourses(courseAggregate);

        /**
         * 然后在集合里面remove两个课程
         * 分别是4和5
         * 4和5对应的是python课程和算法课程
         * 然后接着往下看
         * 
         * 
         */
        courseAggregate.removeCourse(course4);
        courseAggregate.removeCourse(course5);

        /**
         * 这里输出一下删除操作之后的课程列表
         * 
         * 
         */
        System.out.println("-----删除操作之后的课程列表-----");
        /**
         * 又把这个集合打印了一下
         * 这个逻辑非常的简单
         * 我们run一下看一下结果就OK了
         * 结果已经出来了
         * 从最上面开始
         * 首先课程列表
         * 对应一下代码
         * printCourses这个方法
         * 就打印了
         * 返回课程位置是0
         * 我们迭代器也是从第0个位置开始
         * JAVA电商一期
         * 然后返回JAVA电商二期
         * 设计模式精讲
         * 还有Python课程
         * 算法课程
         * 前端课程
         * 然后进行了remove操作
         * 删除之后的课程列表是JAVA电商一期
         * JAVA电商二期
         * JAVA设计模式精讲
         * 注意我们删除的是原来的4和5
         * 那6就排在了第6位
         * 位置是3
         * 返回的正是前端课程
         * 那这个就是我们自己实现的一个课程迭代器
         * 那在前面也说了
         * 迭代器设计模式呢
         * 应用广泛
         * 使用率高
         * 但是我们几乎不会自己去写迭代器
         * 比如JDK里面的集合里面
         * 也都写好了迭代器
         * 我们直接使用就可以了
         * 那相信通过这一段的讲解
         * 能自己写出一个迭代器出来了
         * 
         * 
         */
        printCourses(courseAggregate);
    }


    /**
     * 这里面就使用迭代器了
     * 首先把这堆课程传过来
     * 然后获取这个课程的课程迭代器
     * 这里面可以直接getIterator
     * 只不过为了强调他是课程的迭代器
     * 也是为了强调这个业务场景
     * 那如果真的自己写迭代器的时候
     * 只要把这个方法声明成getIterator就可以了
     * 为什么
     * 因为我们是从CourseAggregate里面去获取迭代器
     * 获取的自然是Course的迭代器
     * 继续来看
     * 
     * 
     * 
     * @param courseAggregate
     */
    public static void printCourses(CourseAggregate courseAggregate){
        CourseIterator courseIterator= courseAggregate.getCourseIterator();
        /**
         * 拿到这个迭代器之后呢
         * 进行一个while循环
         * 判断他是不是最后一个课程
         * 前面有一个非
         * 如果判断出来迭代器前面的位置
         * 并不是最后一个课程的话
         * 那通过迭代器获取下一个课程实例
         * 然后输出出来
         * 那这里面就使用了这个迭代器
         * 声明成static
         * 为了在main里面调用
         * 
         * 
         */
        while(!courseIterator.isLastCourse()){
            Course course=courseIterator.nextCourse();
            System.out.println(course.getName());
        }
    }
}