设计模式 -- 迭代器模式(Iterator)
---------------------------------------------------------------------
1、场景问题
考虑这样一个问题: 9个学生对象分别通过数组存储5个和List存储4个来进行记录，如何以一种统一的方式来对它们进行访问。把这个问题抽象一下就是: 如何能够以一个统一的方式来访问内部实现不同的聚合对象。（所谓聚合是指一组对象的组合结构，比如：Java中的集合、数组等）
通过代码进行简单的示例:
/**
* 学生描述模型对象
*/
public class Student { private int stuId; //学生编号
private String name; //学生姓名
private int age; //学生年龄 public int getStuId() {
return stuId;
}
public void setStuId(int stuId) {
this.stuId = stuId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [stuId=" + stuId + ", name=" + name + ", age=" + age
+ "]";
}
} /**
* 通过数组来存储学生对象
*/
public class ArrayStoreStudent {
//用数组来管理
private Student[] stus = null; /**
* 获取学生列表
* @return
*/
public Student[] getStus(){
return stus;
} /**
* 初始化数据
*/
public void initData(){
Student stu1 = new Student();
stu1.setStuId(1);
stu1.setName("学生1");
stu1.setAge(11); Student stu2 = new Student();
stu2.setStuId(2);
stu2.setName("学生2");
stu2.setAge(12); Student stu3 = new Student();
stu3.setStuId(3);
stu3.setName("学生3");
stu3.setAge(13); Student stu4 = new Student();
stu4.setStuId(4);
stu4.setName("学生4");
stu4.setAge(14); Student stu5 = new Student();
stu5.setStuId(5);
stu5.setName("学生5");
stu5.setAge(15); stus = new Student[5];
stus[0] = stu1;
stus[1] = stu2;
stus[2] = stu3;
stus[3] = stu4;
stus[4] = stu5;
}
} import java.util.ArrayList;
import java.util.List; /**
* 通过List来存储学生对象
*/
public class ListStoreStudent { /**
* 聚合对象,这里是Java的集合对象
*/
private List<Student> list = new ArrayList<Student>(); /**
* 获取学生列表
* @return
*/
public List<Student> getStuList(){
return list;
} /**
* 初始化数据
*/
public void initData(){
Student stu6 = new Student();
stu6.setStuId(6);
stu6.setName("学生6");
stu6.setAge(16); Student stu7 = new Student();
stu7.setStuId(7);
stu7.setName("学生7");
stu7.setAge(17); Student stu8 = new Student();
stu8.setStuId(8);
stu8.setName("学生8");
stu8.setAge(18); Student stu9 = new Student();
stu9.setStuId(9);
stu9.setName("学生9");
stu9.setAge(19); list.add(stu6);
list.add(stu7);
list.add(stu8);
list.add(stu9);
}
} import java.util.Collection;
import java.util.Iterator; public class Client {
public static void main(String[] args) {
//访问数组存储的学生列表
ArrayStoreStudent arrayStoreStudent = new ArrayStoreStudent();
//先初始化数据
arrayStoreStudent.initData();
Student[] stus = arrayStoreStudent.getStus();
System.out.println("数组存储的学生列表:");
for(int i = 0;i < stus.length;i++){
System.out.println(stus[i]);
} //访问List存储的学生列表
ListStoreStudent listStoreStudent = new ListStoreStudent();
//先初始化数据
listStoreStudent.initData();
Collection stuList = listStoreStudent.getStuList();
Iterator it = stuList.iterator();
System.out.println("List存储的学生列表:");
while(it.hasNext()){
Student stu = (Student)it.next();
System.out.println(stu);
}
}
}
---------------------------------------------------------------------
2、解决方案
2.1、使用迭代器模式来解决问题
迭代器模式的定义: 提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。（所谓聚合是指一组对象的组合结构，比如：Java中的集合、数组等）
2.2、使用迭代器模式来解决问题的思路
要以一个统一的方式来访问内部实现不同的聚合对象，首先需要把这个统一的访问方式定义出来 ---> Iterator接口。
迭代器迭代的是具体的聚合对象，那么不同的聚合对象就应该有不同的迭代器，为了让迭代器以一个统一的方式来操作聚合对象，因此给所有的聚合对象抽象出一个公共的父类--->Aggregate，让它提供操作聚合对象的公共接口。
2.3、迭代器模式的结构和说明
(1) Iterator : 迭代器接口。定义访问和遍历元素的接口。
(2) ConcreteIterator : 具体的迭代器实现对象。实现对聚合对象的遍历，并跟踪遍历时的当前位置。
(3) Aggregate : 聚合对象。定义创建相应迭代器对象的接口。
(4) ConcreteAggregate : 具体聚合对象。实现创建相应的迭代器对象。
2.4、迭代器模式的示例代码
/**
* 迭代器接口,定义访问和遍历元素的操作
*/
public interface Iterator {
/**
* 移动到聚合对象的第一个位置
*/
public void first(); /**
* 移到到聚合对象的下一个位置
*/
public void next(); /**
* 判断是否已经移动到聚合对象的最后一个位置
* @return true表示已经移动到聚合对象的最后一个位置
* false表示还没有移动到聚合对象的最后一个位置
*/
public boolean isDone(); /**
* 获取迭代的当前元素
* @return 迭代的当前元素
*/
public Object currentItem();
} /**
* 具体的迭代器实现对象，示意的是聚合对象为数组的迭代器
* （不同的聚合对象相应的迭代器实现是不一样的）
*/
public class ConcreteIterator implements Iterator { /**
* 持有被迭代的具体的聚合对象
*/
private ConcreteAggregate aggregate; /**
* 内部索引,记录当前迭代到的索引位置
* -1表示刚开始的时候,迭代器指向聚合对象第一个对象之前
*/
private int index = -1; /**
* 构造方法,传入被迭代的具体的聚合对象
* @param aggregate 被迭代的具体的聚合对象
*/
public ConcreteIterator(ConcreteAggregate aggregate) {
this.aggregate = aggregate;
} @Override
public void first() {
index = 0;
} @Override
public void next() {
if(index < this.aggregate.size()){
index = index + 1;
}
} @Override
public boolean isDone() {
if(index == this.aggregate.size()){
return true;
}
return false;
} @Override
public Object currentItem() {
return this.aggregate.get(index);
}
} /**
* 聚合对象的接口,定义创建相应迭代器对象的接口
* @author Administrator
*
*/
public abstract class Aggregate { /**
* 工厂方法,创建相应迭代器对象的接口
* @return 相应迭代器对象的接口
*/
public abstract Iterator createIterator();
} /**
* 具体的聚合对象，实现创建相应迭代器对象的功能
* @author Administrator
*
*/
public class ConcreteAggregate extends Aggregate {
/**
* 表示聚合对象具体的内容
*/
private String[] ss = null; /**
* 构成方法,传入聚合对象具体的内容
* @param ss 聚合对象具体的内容
*/
public ConcreteAggregate(String[] ss) {
this.ss = ss;
} @Override
public Iterator createIterator() {
return new ConcreteIterator(this);
} /**
* 获取索引对应的元素
* @param index 索引
* @return 索引对应的元素
*/
public Object get(int index){
Object retObj = null;
if(index < ss.length){
retObj = ss[index];
}
return retObj;
} /**
* 获取聚合对象的大小
* @return 聚合对象的大小
*/
public int size(){
return this.ss.length;
}
} public class Client { public void someOperation(){
String[] names = {"张三","李四","王五"}; //创建聚合对象
Aggregate aggregate = new ConcreteAggregate(names); //循环输出聚合对象中的值
Iterator it = aggregate.createIterator();
//首先设置迭代器到第一个元素
it.first();
while(!it.isDone()){
//取出当前的元素来
Object obj = it.currentItem();
System.out.println("the obj == " + obj);
//如果还没有迭代到最后,那么就向下迭代一个
it.next();
}
} public static void main(String[] args) {
Client client = new Client();
client.someOperation();
}
} 运行结果:
the obj == 张三
the obj == 李四
the obj == 王五
---------------------------------------------------------------------
3、使用迭代器模式来解决场景问题
要使用迭代器模式来解决场景问题，那就需要先定义出抽象的聚合对象和迭代器接口，然后再提供相应的实现。
（1）为了让客户端能够以一个统一的方式进行访问，需要为它们定义一个统一的接口，通过统一的接口来访问： /**
* 迭代器接口,定义访问和遍历元素的操作
*/
public interface MyIterator {
/**
* 移动到聚合对象的第一个位置
*/
public void first(); /**
* 移动到聚合对象的下一个位置
*/
public void next(); /**
* 判断是否已经移动到聚合对象的最后一个位置
* @return true表示已经移动到聚合对象的最后一个位置
* false表示还没有移动到聚合对象的最后一个位置
*/
public boolean isDone(); /**
* 获取迭代的当前元素
* @return 迭代的当前元素
*/
public Object currentItem();
} （2）定义好了统一的接口，下面分别提供对List和数组的实现
/**
* 用来实现访问数组的迭代接口
*/
public class ArrayIteratorImpl implements MyIterator { /**
* 用来存放被迭代的聚合对象
*/
private ArrayStoreStudent aggregate = null; /**
* 用来记录当前迭代到的位置的所有
* -1表示刚开始的时候,迭代器指向聚合对象第一个对象之前
*/
private int index = -1; public ArrayIteratorImpl(ArrayStoreStudent aggregate) {
this.aggregate = aggregate;
} @Override
public void first() {
index = 0;
} @Override
public void next() {
if(index < this.aggregate.size()){
index = index + 1;
}
} @Override
public boolean isDone() {
if(index == this.aggregate.size()){
return true;
}
return false;
} @Override
public Object currentItem() {
return this.aggregate.get(index);
}
} /**
* 用来实现访问List集合的迭代接口,为了外部统一访问方式
*/
public class ListIteratorImpl implements MyIterator { /**
* 用来存放被迭代的聚合对象
*/
private ListStoreStudent aggregate = null; /**
* 用来记录当前迭代到的位置索引
* -1表示刚开始的时候,迭代器指向聚合对象第一个对象之前
*/
private int index = -1; public ListIteratorImpl(ListStoreStudent aggregate) {
this.aggregate = aggregate;
} @Override
public void first() {
index = 0;
} @Override
public void next() {
if(index < this.aggregate.size()){
index = index + 1;
}
} @Override
public boolean isDone() {
if(index == this.aggregate.size()){
return true;
}
return false;
} @Override
public Object currentItem() {
return this.aggregate.get(index);
}
}
（3）学生模型对象
/**
* 学生描述模型对象
*/
public class Student { private int stuId; //学生编号
private String name; //学生姓名
private int age; //学生年龄 public int getStuId() {
return stuId;
}
public void setStuId(int stuId) {
this.stuId = stuId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [stuId=" + stuId + ", name=" + name + ", age=" + age
+ "]";
}
}
（4）聚合对象统一接口
/**
* 聚合对象的接口,定义创建相应迭代器对象的接口
*/
public abstract class Aggregage {
/**
* 工厂方法,创建相应迭代器对象的接口
* @return 相应迭代器对象的接口
*/
public abstract MyIterator createMyIterator();
}
（5）聚合对象ArrayStoreStudent和ListStoreStudent
public class ArrayStoreStudent extends Aggregage {
/**
* 用数组来管理
*/
private Student[] stus; public ArrayStoreStudent() {
} @Override
public MyIterator createMyIterator() {
return new ArrayIteratorImpl(this);
} /**
* 获取学生列表
* @return 学生列表
*/
public Student[] getStus() {
return stus;
} public Object get(int index){
Object retObj = null;
if(index < this.stus.length){
retObj = stus[index];
}
return retObj;
} public int size(){
return this.stus.length;
} /**
* 初始化数据
*/
public void initData(){
Student stu1 = new Student();
stu1.setStuId(1);
stu1.setName("学生1");
stu1.setAge(11); Student stu2 = new Student();
stu2.setStuId(2);
stu2.setName("学生2");
stu2.setAge(12); Student stu3 = new Student();
stu3.setStuId(3);
stu3.setName("学生3");
stu3.setAge(13); Student stu4 = new Student();
stu4.setStuId(4);
stu4.setName("学生4");
stu4.setAge(14); Student stu5 = new Student();
stu5.setStuId(5);
stu5.setName("学生5");
stu5.setAge(15); stus = new Student[5];
stus[0] = stu1;
stus[1] = stu2;
stus[2] = stu3;
stus[3] = stu4;
stus[4] = stu5;
}
} import java.util.ArrayList;
import java.util.List; public class ListStoreStudent extends Aggregage { private List<Student> list = new ArrayList<Student>(); public ListStoreStudent() {
} @Override
public MyIterator createMyIterator() {
return new ListIteratorImpl(this);
} /**
* 获取学生列表
* @return 学生列表
*/
public List<Student> getStusList() {
return list;
} public Object get(int index){
Object retObj = null;
if(index < this.list.size()){
retObj = this.list.get(index);
}
return retObj;
} public int size(){
return this.list.size();
} /**
* 初始化数据
*/
public void initData(){
Student stu6 = new Student();
stu6.setStuId(6);
stu6.setName("学生6");
stu6.setAge(16); Student stu7 = new Student();
stu7.setStuId(7);
stu7.setName("学生7");
stu7.setAge(17); Student stu8 = new Student();
stu8.setStuId(8);
stu8.setName("学生8");
stu8.setAge(18); Student stu9 = new Student();
stu9.setStuId(9);
stu9.setName("学生9");
stu9.setAge(19); list.add(stu6);
list.add(stu7);
list.add(stu8);
list.add(stu9);
}
} （5）测试类
public class Client { public static void main(String[] args) {
//访问数组存储的学生列表:
ArrayStoreStudent arrayStoreStudent = new ArrayStoreStudent();
//先初始化数据
arrayStoreStudent.initData();
System.out.println("数组存储的学生列表:");
printInfo(arrayStoreStudent.createMyIterator()); //访问List存储的学生列表:
ListStoreStudent listStoreStudent = new ListStoreStudent();
//初始化数据
listStoreStudent.initData();
System.out.println("List存储的学生列表:");
printInfo(listStoreStudent.createMyIterator());
} public static void printInfo(MyIterator it){
//循环输出聚合对象中的值
//首先设置迭代器到第一个元素
it.first();
while(!it.isDone()){
//取出当前的元素来
Object obj = it.currentItem();
System.out.println("the obj == " + obj);
//如果还没有迭代到最后,那么就向下迭代一个
it.next();
}
}
} 运行结果:
数组存储的学生列表:
the obj == Student [stuId=1, name=学生1, age=11]
the obj == Student [stuId=2, name=学生2, age=12]
the obj == Student [stuId=3, name=学生3, age=13]
the obj == Student [stuId=4, name=学生4, age=14]
the obj == Student [stuId=5, name=学生5, age=15]
List存储的学生列表:
the obj == Student [stuId=6, name=学生6, age=16]
the obj == Student [stuId=7, name=学生7, age=17]
the obj == Student [stuId=8, name=学生8, age=18]
the obj == Student [stuId=9, name=学生9, age=19]
---------------------------------------------------------------------
4、模式讲解
4.1、迭代器模式的功能
迭代器模式的功能主要在于提供对聚合对象的迭代访问。围绕"访问"延伸出很多的功能来，比如:
- 以不同的方式遍历聚合对象，比如向前、向后等
- 对同一个聚合同时进行多个遍历
- 以不同的遍历策略来遍历聚合，比如是否需要过滤等
- 多态迭代，含义是: 为不同的聚合结构提供统一的迭代接口，也就是说通过一个迭代接口可以访问不同的聚合结构，这就叫做多态迭代。
4.2、迭代器模式的关键思想
迭代器模式的关键思想是把对聚合对象的遍历和访问从聚合对象中分离出来，放入单独的迭代器中，这样聚合对象会变得简单一些;而且迭代器和聚合对象可以独立地变化和发展,会大大加强系统的灵活性。
4.3、 使用Java的迭代器
在java.util包里面有一个Iterator接口，在Java中实现迭代器模式是非常简单的，而且Java的集合框架中对聚合对象基本上都提供了迭代器的。
下面就通过使用Java中的迭代器来实现场景问题：
(1)Student类
/**
* 学生描述模型对象
*/
public class Student { private int stuId; //学生编号
private String name; //学生姓名
private int age; //学生年龄 public int getStuId() {
return stuId;
}
public void setStuId(int stuId) {
this.stuId = stuId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [stuId=" + stuId + ", name=" + name + ", age=" + age
+ "]";
}
} （2）抽象的Aggregate类
import java.util.Iterator; /**
* 聚合对象的接口,定义创建相应迭代器对象的接口
*/
public abstract class Aggregate { /**
* 工厂方法,创建相应迭代器对象的接口
* @return 相应迭代器对象的接口
*/
public abstract Iterator createIterator();
} （3）ArrayIteratorImpl类
import java.util.Iterator;
public class ArrayIteratorImpl implements Iterator { /**
* 用来存放被迭代的聚合对象
*/
private ArrayStoreStudent aggregate = null; /**
* 用来记录当前迭代到的位置的索引
*/
private int index = 0; public ArrayIteratorImpl(ArrayStoreStudent aggregate) {
this.aggregate = aggregate;
} @Override
public boolean hasNext() {
//判断是否还有下一个元素
if(aggregate != null && index < aggregate.size()){
return true;
}
return false;
} @Override
public Object next() {
Object retObj = null;
if(hasNext()){
retObj = aggregate.get(index);
//每取走一个值,就把已访问索引加1
index++;
}
return retObj;
} @Override
public void remove() {
//暂时可以不实现
}
} （4）ArrayStoreStudent类
import java.util.Iterator; public class ArrayStoreStudent extends Aggregate { /**
* 用数组来管理
*/
private Student[] stus; public ArrayStoreStudent() {
} @Override
public Iterator createIterator() {
return new ArrayIteratorImpl(this);
} /**
* 获取学生列表
* @return 学生列表
*/
public Student[] getStus() {
return stus;
} public Object get(int index){
Object retObj = null;
if(index < this.stus.length){
retObj = stus[index];
}
return retObj;
} public int size(){
return this.stus.length;
} /**
* 初始化数据
*/
public void initData(){
Student stu1 = new Student();
stu1.setStuId(1);
stu1.setName("学生1");
stu1.setAge(11); Student stu2 = new Student();
stu2.setStuId(2);
stu2.setName("学生2");
stu2.setAge(12); Student stu3 = new Student();
stu3.setStuId(3);
stu3.setName("学生3");
stu3.setAge(13); Student stu4 = new Student();
stu4.setStuId(4);
stu4.setName("学生4");
stu4.setAge(14); Student stu5 = new Student();
stu5.setStuId(5);
stu5.setName("学生5");
stu5.setAge(15); stus = new Student[5];
stus[0] = stu1;
stus[1] = stu2;
stus[2] = stu3;
stus[3] = stu4;
stus[4] = stu5;
}
} （5）ListStoreStudent类
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; public class ListStoreStudent extends Aggregate { private List<Student> list = new ArrayList<Student>(); public ListStoreStudent() {
} @Override
public Iterator createIterator() {
return list.iterator();
} /**
* 获取学生列表
* @return 学生列表
*/
public List<Student> getStusList() {
return list;
} public Object get(int index){
Object retObj = null;
if(index < this.list.size()){
retObj = this.list.get(index);
}
return retObj;
} public int size(){
return this.list.size();
} /**
* 初始化数据
*/
public void initData(){
Student stu6 = new Student();
stu6.setStuId(6);
stu6.setName("学生6");
stu6.setAge(16); Student stu7 = new Student();
stu7.setStuId(7);
stu7.setName("学生7");
stu7.setAge(17); Student stu8 = new Student();
stu8.setStuId(8);
stu8.setName("学生8");
stu8.setAge(18); Student stu9 = new Student();
stu9.setStuId(9);
stu9.setName("学生9");
stu9.setAge(19); list.add(stu6);
list.add(stu7);
list.add(stu8);
list.add(stu9);
}
}
（6）Client类
import java.util.Iterator; public class Client { public static void main(String[] args) {
//访问数组存储的学生列表:
ArrayStoreStudent arrayStoreStudent = new ArrayStoreStudent();
//初始化数据
arrayStoreStudent.initData();
System.out.println("数组存储的学生列表:");
printInfo(arrayStoreStudent.createIterator()); //访问List存储的学生列表:
ListStoreStudent listStoreStudent = new ListStoreStudent();
//初始化数据
listStoreStudent.initData();
System.out.println("List存储的学生列表:");
printInfo(listStoreStudent.createIterator());
} public static void printInfo(Iterator it) {
while (it.hasNext()) {
Student pm = (Student) it.next();
System.out.println(pm);
}
}
} 运行结果:
数组存储的学生列表:
Student [stuId=1, name=学生1, age=11]
Student [stuId=2, name=学生2, age=12]
Student [stuId=3, name=学生3, age=13]
Student [stuId=4, name=学生4, age=14]
Student [stuId=5, name=学生5, age=15]
List存储的学生列表:
Student [stuId=6, name=学生6, age=16]
Student [stuId=7, name=学生7, age=17]
Student [stuId=8, name=学生8, age=18]
Student [stuId=9, name=学生9, age=19]
4.4、带迭代策略的迭代器
由于迭代器模式把聚合对象和访问聚合的机制实现了分离,所以可以在迭代器上实现不同的迭代策略，最为典型的就是实现过滤功能的迭代器。在实现过滤功能的迭代器中，又有两种常见的需要过滤的情况，一种是对数据进行整条过滤，另一种是对数据进行部分过滤。使用带迭代策略的迭代器实现的一个基本思路，就是先把聚合对象的聚合数据获取到，并存储到迭代器中，主要迭代器就可以按照不同的策略来迭代数据了。
（1）带迭代策略的迭代器示例
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; /**
* 带过滤功能的迭代器
*/
public class ArrayIteratorImpl implements Iterator { /**
* 用来存放被迭代的数组
*/
private Student[] stus; /**
* 用来记录当前迭代到的位置的索引
*/
private int index = 0; public ArrayIteratorImpl(ArrayStoreStudent aggregate) {
//在这里先对集合对象的数据进行过滤,比如年龄必须在14岁以下
Collection<Student> tmepCol = new ArrayList<Student>();
for(Student stu : aggregate.getStus()){
if(stu.getAge() < 14){
tmepCol.add(stu);
}
}
//然后把符合要求的数据存放到用来迭代的数组中
this.stus = new Student[tmepCol.size()];
int i = 0;
for(Student stu : tmepCol){
this.stus[i] = stu;
i++;
}
} @Override
public boolean hasNext() {
//判断是否还有下一个元素
if(stus != null && index <= (stus.length-1)){
return true;
}
return false;
} @Override
public Object next() {
Object retObj = null;
if(hasNext()){
retObj = stus[index];
//每取走一个值,就把已访问索引加1
index++;
}
//可以在这里进行过滤,比如不让查看姓名
((Student)retObj).setName("***");
return retObj;
} @Override
public void remove() {
//暂时可以不实现
}
}
（2）谁定义遍历算法的问题
在实现迭代器模式的时候，一个常见的问题就是: 谁来定义遍历算法? 常见的有两个地方可以来定义遍历算法：一个是聚合对象本身，另外一个就是迭代器负责遍历算法。
- 在聚合对象本身定义遍历算法，通常会在遍历过程中，用迭代器来存储当前迭代的状态，这种迭代器被称为游标，因为它仅用来指示当前的位置。
- 在迭代器中定义遍历算法，会比在相同的聚合上使用不同的迭代算法容易，同时也易于在不同的聚合上重用相同的算法。但是如果实现遍历算法需要访问聚合对象的私有变量，那么将遍历算法放入迭代器中会破坏聚合对象的封装性。
4.5、迭代器模式的优点
- 更好的封装性。
- 迭代器模式可以让你访问一个聚合对象的内容，而无须暴露该聚合对象的内部表示，从而提高聚合对象的封装性。
- 可以以不同的遍历方式来遍历一个聚合。
- 使用迭代器模式，使得聚合对象的内容和具体的迭代算法分离开。这样就可以通过使用不同的迭代器的实例、不同的遍历方式来遍历一个聚合对象了。
- 迭代器简化了聚合的接口。
- 有了迭代器的接口，则聚合本身就不需要再定义这些接口了，从而简化了聚合的接口定义。
4.6、 思考迭代器模式
迭代器模式的本质： 控制访问聚合对象中的元素。迭代器能实现：无须暴露聚合对象的内部实现，就能够访问到聚合对象中的各个元素。
---------------------------------------------------------------------
---------------------------------------------------------------------
---------------------------------------------------------------------
---------------------------------------------------------------------
---------------------------------------------------------------------
设计模式 -- 迭代器模式(Iterator)的更多相关文章
- 设计模式 - 迭代器模式(iterator pattern) 具体解释
迭代器模式(iterator pattern) 详细解释 本文地址: http://blog.csdn.net/caroline_wendy 迭代器模式(iterator pattern) : 提供一 ...
- javascript设计模式-迭代器模式(Iterator)
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- C#设计模式——迭代器模式(Iterator Pattern)
一.概述在软件开发过程中,我们可能会希望在不暴露一个集合对象内部结构的同时,可以让外部代码透明地访问其中包含的元素.迭代器模式可以解决这一问题.二.迭代器模式迭代器模式提供一种方法顺序访问一个集合对象 ...
- 设计模式(十)：从电影院中认识"迭代器模式"(Iterator Pattern)
上篇博客我们从醋溜土豆丝与清炒苦瓜中认识了“模板方法模式”,那么在今天这篇博客中我们要从电影院中来认识"迭代器模式"(Iterator Pattern).“迭代器模式”顾名思义就是 ...
- 深入浅出设计模式——迭代器模式（Iterator Pattern）
模式动机 一个聚合对象,如一个列表(List)或者一个集合(Set),应该提供一种方法来让别人可以访问它的元素,而又不需要暴露它的内部结构.针对不同的需要,可能还要以不同的方式遍历整个聚合对象,但是我 ...
- 设计模式 ( 十四 ) 迭代器模式Iterator（对象行为型）
设计模式 ( 十四 ) 迭代器模式Iterator(对象行为型) 1.概述 类中的面向对象编程封装应用逻辑.类,就是实例化的对象,每个单独的对象都有一个特定的身份和状态.单独的对象是一种组织代码的 ...
- 乐在其中设计模式(C#) - 迭代器模式(Iterator Pattern)
原文:乐在其中设计模式(C#) - 迭代器模式(Iterator Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 迭代器模式(Iterator Pattern) 作者:weba ...
- 迭代器模式 Iterator 行为型 设计模式（二十）
迭代器模式(Iterator) 走遍天下,世界那么大,我想去看看 在计算机中,Iterator意为迭代器,迭代有重复的含义,在程序中,更有“遍历”的含义 如果给定一个数组,我们可以通过for循 ...
- Java 设计模式系列（十五）迭代器模式(Iterator)
Java 设计模式系列(十五)迭代器模式(Iterator) 迭代器模式又叫游标(Cursor)模式,是对象的行为模式.迭代子模式可以顺序地访问一个聚集中的元素而不必暴露聚集的内部表象(interna ...
随机推荐
- Linux启动时显示Grub命令行及修改
1.在启动Linux系统时,如果/boot/grub/grub.cfg文件损坏或者不存在时,启动Linux时,就会有Grub命令行的提示. 如下操作,将系统自带的grub.cfg文件改名.重新启动系统 ...
- Tomcat配置文件Host元素属性介绍
1.属性名:appBase.使用对象:all.含义:这一Host的Web应用程序目录的路径(Web应用程序和/或WAR文件驻留的目录).可以是CATALINA_HOME的相对路径,或者是绝对路径.默认 ...
- HTML 学习笔记 JQuery（表单,表格 操作）
表单应用 一个表单有3个基本组成部分 (1)表单标签:包含处理表单数据所用的服务器端程序URL 以及数据提交到服务器的方法 (2)表单域:包含文本框 密码框 隐藏框 多行文本框 复选框 单选框 下拉选 ...
- 横向滚动视图scroll-into-view不起作用
横向视图scroll-into-view指定的id为hpink,但是效果图中显示的还是第1个view(未达到效果); 纵向视图scroll-into-view指定的id为yellowgreen,效果图 ...
- SQLite用法
SQLite语法:http://blog.csdn.net/ejzhang/article/details/6224915#08 SQLite查询优化:1.http://www.eoeandroid. ...
- 那些年我们一起改过的bug
ORA-01861: 文字与格式字符串不匹配 ORA-00936: 缺失表达式 ORA-01810 格式代码出现两次 ORA-01722: 无效数字 无效的列索引
- Linux_System2
1.从服务器下载http*.tar.gz源码包,安装到/usr/local/apache目录下,要求安装时指定能够动态加载模块,能够支持地址回写功能,能够使用ssl加密功能../configure — ...
- 利用DIV+CSS制作网页过程中常用的基本概念及标签使用细节
CSS主要用于对HTML文件功能的补充及扩展,其作用就是对HTML文件中各种排版进行设置,达到对网页中字体.颜色.背景.图片等的控制,使网页能够完全依照设计者的想法来显示. CSS可以控制网页的显示, ...
- PHPcms 把盛大登陆换成人人网登陆
首先要确保你的 phpcms是比较新的版本, v9.3以后的吧 这里说明一个函数 rawurlencode() 本函数将字符串编码成 URL 的字符串专用格式,特殊的字符会转换成百分比符号后面加上二个 ...
- jquery换肤
<script src="script/jquery-2.1.0.js"></script> <link href="style/ ...