一、引言
23种设计模式大概分为三大类：
5种（创建型模式）：工厂方法模式、抽象工厂模式、单例模式、原型模式、建造者模式。
7种（结构型模式）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
11种（行为型模式）：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
行为型又可以通过类与类之间的关系进行划分 : 
迭代器模式基本介绍：
- 迭代器模式（Iterator Pattern）是常用的设计模式，属于行为型模式
- 如果我们的集合元素是用不同的方式实现的，有数组，还有 java 的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。
- 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。
对原理类图的说明：
- Iterator：迭代器接口，是由系统提供的，含有hasNext, next, remove方法
- ConcreteIterator：具体的迭代器类，实现迭代器接口，管理迭代
- Aggregate：一个统一的聚合接口，将客户端和具体的聚合解耦
- ConcreteAggreage：具体的聚合持有对象集合，并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合(因为每个迭代器都和聚合有对应关系)
- Client：客户端，通过 Iterator 和 Aggregate 来依赖它们的子类
编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院， 一个学院有多个系。(组合模式也使用了该案例，此处侧重于遍历) 如图：
思路：
传统方式的问题分析：
- 将学院看做是学校的子类，系看做学院的子类，这样实际上是站在组织大小来进行分层次的
- 实际上我们的要求是 ：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现的遍历的操作
- 假设：计算机学院是存放在数组中的，信息工程学院是存放在集合中的，怎样通过一个统一的方式来访问它们呢？解决方案：=> 迭代器模式
思路分析 - 类图 
将数据和遍历方式分开，左半部分是数据，右半部分是遍历
具体实现
// Department.java
public class Department {
private String name;
private String des;
public Department(String name, String des) {
this.name = name;
this.des = des;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getDes() { return des; }
public void setDes(String des) { this.des = des; }
}
// ComputerCollegeIterator.java
public class ComputerCollegeIterator implements Iterator {
//因为迭代器的迭代方式与集合内部的存放方式有关，因此需要知道Department是怎样存放的
Department[] departments;
int position = 0;//遍历的位置
public ComputerCollegeIterator(Department[] departments) {
this.departments = departments;
}
//判断是否还有下一个元素
@Override
public boolean hasNext() {
//数组
if(position >= departments.length || departments[position] == null) {
return false;
}else {
return true;
}
}
@Override
public Object next() {
Department department = departments[position];
position++;
return department;
}
//删除方法默认空实现
@Override
public void remove() {
}
}
// InfoCollegeIterator.java
public class InfoCollegeIterator implements Iterator {
//信息工程学院的系是以List形式存放的
List departmentList;
int index = -1;//索引
public InfoCollegeIterator(List departmentList) {
this.departmentList = departmentList;
}
//判断是否还有下一个元素
@Override
public boolean hasNext() {
if(index >= departmentList.size()-1) {
return false;
}else {
index+=1;
return true;
}
}
@Override
public Object next() {
return departmentList.get(index);
}
//删除方法默认空实现
@Override
public void remove() {
}
}
// College.java
public interface College {
public String getName();
//增加系
public void addDepartment(String name, String desc);
//返回一个迭代器
public Iterator createIterator();
}
// ComputerCollege.java
public class ComputerCollege implements College {
Department[] departments;
int numOfDepartment = 0;//保存当前数组的对象个数
public ComputerCollege() {
//先假定最多存放5个系
departments = new Department[5];
addDepartment("Java专业", "Java");
addDepartment("PHP专业", "PHP");
addDepartment("大数据专业", "大数据");
}
@Override
public String getName() { return "计算机学院"; }
@Override
public void addDepartment(String name, String desc) {
Department department = new Department(name, desc);
departments[numOfDepartment] = department;
numOfDepartment++;
}
@Override
public Iterator createIterator() {
return new ComputerCollegeIterator(departments);
}
}
// InfoCollege.java
public class InfoCollege implements College {
List departmentList;
public InfoCollege() {
departmentList = new ArrayList();
addDepartment("信息安全专业", "信息安全");
addDepartment("网络安全专业", "网络安全");
}
@Override
public String getName() { return "信息工程学院"; }
@Override
public void addDepartment(String name, String desc) {
Department department = new Department(name, desc);
departmentList.add(department);
}
@Override
public Iterator createIterator() {
return new InfoCollegeIterator(departmentList);
}
}
// OutputImpl.java
public class OutputImpl {
//学院集合
List collegeList;
public OutputImpl(List collegeList) {
this.collegeList = collegeList;
}
//遍历所有的学院，然后调用printDepartment,输出各个学院的系
public void printCollege() {
//从collegeList中取出所有学院
//Java中的List已经实现了Iterator接口,所以可以直接用
Iterator iterator = collegeList.iterator();
while(iterator.hasNext()) {
College college = iterator.next();
System.out.println("======"+college.getName()+"======");
printDepartment(college.createIterator());//得到对应的迭代器
}
}
//学院输出系
public void printDepartment(Iterator iterator) {
while(iterator.hasNext()) {
//因为取出来是Object，所以需要强转
Department d = (Department) iterator.next();
System.out.println(d.getName());
}
}
}
// Client.java
public class Client {
public static void main(String[] args) {
//创建学院
List collegeList = new ArrayList();
College computerCollege = new ComputerCollege();
InfoCollege infoCollege = new InfoCollege();
collegeList.add(computerCollege);
collegeList.add(infoCollege);
OutputImpl outputImpl = new OutputImpl(collegeList);
outputImpl.printCollege();
}
}
- 优点
- 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了
- 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成
- 提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来，集合改变的话，只影响到聚合对象；如果遍历方式改变的话，只影响到了迭代器
- 当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式
- 缺点
- 每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类
