Java学习-设计模式-迭代器模式

Java学习-设计模式-迭代器模式

概述：

迭代器模式是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

**缺点：**由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

使用场景： 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。

理解：

简单理解，就是遍历对象，就像for循环遍历一样，不过这个有点区别就是你申请一个，那边给你一个。

理解代码：
1. 这个歌你首先得有要迭代遍历的对象（测试中使用学生类）
2. 还要有存储这些对象的类（定义一个接口，包含新增、删除、返回存储迭代对象的类的当前对象（这里有点不好说，就是返回自己））（容器）
3. 还要有迭代类（定义一个接口，包含 取第一个对象的方法、去下一个对象的方法、判断是否存在下一个对象的方法、返回当前位置对象的方法）

1. 首先创建一个学生类标准类，
	属性包括姓名、性别、年级；
	有参构造方法初始化属性；
	重写好tostring方法
2. 创建一个容器接口，包含一个新增方法、一个移除方法、一个返回当前对象的方法
3. 创建一个实现类实现容器接口，
	包含一个类型为list<Object>属性（因为你不知道你用于迭代的对象是什么样）
	有参构造方法中初始化这个属性，
	重写接口的方法，新增：使用list.add()方法新增；移除：使用list.remove()方法移除元素，返回当前对象					的方法：新建一个迭代器对象，将属性传给它
4.创建一个迭代器接口，包含定位到第一个迭代对象的方法、取得下一个迭代对象的方法、判断取下一个存不存在的方法、返回当前位置的迭代元素的方法
5. 创建一个迭代器实现类实现迭代器接口
	包含一个类型为list<Object>属性（用于存储需要遍历的迭代对象），一个类型为int用于记录当前位置的属性，索引值初始化为0
	有参构造初始化list集合
	重写接口中的方法，定位到第一个迭代对象的方法：判断list集合中是否有元素，有则将索引置为1，取第一个迭代对象，没有则返回对应的提示
	取得下一个迭代对象的方法：判断索引位置是否有值（索引永远都是指向下一个的），有则去取当前索引指向的值，并使索引值加一，没有则返回对应的提示
	判断取下一个存不存在的方法：判断索引的值是否大于list.size() 的值，是则没有，不是则由
	返回当前位置的迭代元素的方法：判断索引时候为0，为0则判断当前位置是否有值，还有则返回当前索引(0)所指迭代对象，没有则返回对应的提示，如果索引不为0，则判断索引的上一个位置时候有值，有则放回对应的迭代对象，没有则返回对应的提示
	
6. 测试

示例：

package Practices.Mode.Iterator_Pattern;
// 1. 先建一个迭代测试类
public class Student {
    private String name;
    private String sex;
    private String class_num;

    public Student(String name, String sex, String class_num) {
        this.name = name;
        this.sex = sex;
        this.class_num = class_num;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", class_num='" + class_num + '\'' +
                '}';
    }
}

package Practices.Mode.Iterator_Pattern;
// 2. 创建容器接口
public interface Container {
    public void add(Object ob);
    public void remove(Object ob);
    public Iterator iterator();
}

package Practices.Mode.Iterator_Pattern;

import java.util.List;
// 3. 创建容器的实现类
public class ConcreteAggregate implements Container {
    private List<Object> list;

    public ConcreteAggregate(List<Object> list) {
        this.list = list;
    }


    public void add(Object ob) {
        list.add(ob);
    }

    public void remove(Object ob) {
        list.remove(ob);
    }

    public Iterator iterator() {
        return new ConcreteIterator(list);
    }
}

package Practices.Mode.Iterator_Pattern;
// 4. 创建迭代器接口
public interface Iterator {
    public Object getFirst();
    public Object getNext();
    public boolean hasNext();
    public Object getPresent();
}

package Practices.Mode.Iterator_Pattern;

import java.util.List;
// 5. 创建迭代器的实现类
public class ConcreteIterator implements Iterator {
    private List<Object> list;
    private int index = 0;

    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }

    public Object getFirst() {
        if(list.size() == 0){
            System.out.println("迭代对象已经全部被移除");
            return null;
        }else{
            index = 1;      // 索引指向0 的后一个元素
            return list.get(0);
        }
    }

    public Object getNext() {
        if(hasNext()){
            index += 1;
            return  list.get(index-1);
        }else{
            System.out.println("没有下一个元素");
            return null;
        }
    }

    public boolean hasNext() {
        if(index >= list.size()){
            return false;
        }else {
            return true;
        }
    }

    public Object getPresent() {
        if(index == 0){
            if(list.get(0) == null){
                System.out.println("没有迭代的对象");
                return null;
            }else{
                return list.get(0);
            }
        }else{
            if(index -1 >= list.size()){
                System.out.println("当前索引位置没有元素");
                return null;
            }else{
                return list.get(index - 1);
            }
        }
    }
}

package Practices.Mode.Iterator_Pattern;

import java.util.ArrayList;
import java.util.List;
// 6. 测试
public class Test_main {
    public static void main(String[] args) {
        List<Object> students = new ArrayList<Object>();

        Student jack = new Student("jack", "m", "1");
        Student rose = new Student("rose", "w", "2");
        Student locy = new Student("locy", "w", "1");

        students.add(jack);
        students.add(rose);

        ConcreteAggregate aggregate = new ConcreteAggregate(students);
        aggregate.add(locy);

        Iterator iterator = aggregate.iterator();

        while(iterator.hasNext()){
            Object next = iterator.getNext();
            System.out.println(next.toString());
        }
    }
}