24种设计模式--迭代模式【Iterator Pattern】
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了24种设计模式--迭代模式【Iterator Pattern】，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6760字，纯文字阅读大概需要10分钟。
内容图文
周五下午，我正在看技术网站，第六感官发觉有人在身后，扭头一看，我 C，老大站在背后，赶忙站起来，“王经理，你找我？” 我说。
“哦，在看技术呀。有个事情找你谈一下，你到我办公室来一下。” 老大说。
到老大办公室，“是这样，刚刚我在看季报，我们每个项目的支出费用都很高，项目情况复杂，人员情况也不简单，我看着也有点糊涂，你看，这是我们现在还在开发或者维护的 103 个项目，你能不能先把这些项目信息重新打印一份给我，咱们好查查到底有什么问题。”老大说。
“这个好办，我马上去办”我爽快的答复道。很快我设计了一个类图，并开始实施：
类图非常简单，是个程序员都能实现，我们来看看简单的东西：
1
package
com.pattern.iterator;
2
3
/**
4
* 定义一个接口，所有的项目都是一个接口
5
*
@author
http://www.cnblogs.com/initial-road/
6
*
7
*/
8
public
interface
IProject {
9
10
//
从老板这里看到的就是项目信息
11
public
String getProjectInfo();
12
13
}
14
15
//
定义了一个接口，面向接口编程嘛，当然要定义接口了，然后看看实现类：
16
17
package
com.pattern.iterator;
18
19
import
java.util.ArrayList;
20
21
/**
22
* 所有的项目信息类
23
*
@author
http://www.cnblogs.com/initial-road/
24
*
25
*/
26
public
class Project implements IProject {
27// 项目名称28private String name = "";
2930// 项目成员数量31privateint num = 0;
3233// 项目费用34privateint cost = 0;
3536public Project(){
3738 }
3940// 定义一个构造函数，把所有老板需要看到的信息存储起来41public Project(String name, int num, int cost){
42// 赋值到类的成员变量中43this.name = name;
44this.num = num;
45this.cost = cost;
46 }
4748// 得到项目的信息49public String getProjectInfo() {
50 String info = "";
5152// 获得项目的名称53 info = info + "项目名称是：" + this.name;
54// 获得项目人数55 info = info + "\t 项目人数：" + this.num;
56// 项目费用57 info = info + "\t 项目费用：" + this.cost;
5859return info;
60 }
6162 }
实现类也是比较简单的，通过构造函数传递过来要显示的数据，然后放到 getProjectInfo 中显示，这太easy 了！，然后我们老大要看看结果了：
1
package
com.pattern.iterator;
2
3
import
java.util.ArrayList;
4
5
/**
6
* 老板来看项目信息了
7
*
@author
http://www.cnblogs.com/initial-road/
8
*
9
*/
10
public
class
Boss {
11
12
public
static
void
main(String[] args) {
13
//
定义一个List，存放所有的项目对象
14 ArrayList<IProject> projectList = new ArrayList<IProject>();
1516// 增加星球大战项目17 projectList.add(new Project("星球大战项目", 10, 100000));
1819// 增加扭转时空项目20 projectList.add(new Project("扭转时空项目", 100, 100000));
2122// 增加超人改造项目23 projectList.add(new Project("超人改造项目", 10000, 1000000000));
2425// 这边100个项目26for(int i=4;i<104;i++){
27 projectList.add(new Project("第" + i + "个项目", 1*5, 1*100000));
28 }
2930// 遍历一下ArrayList，把所有的数据都取出31for(IProject project : projectList){
32 System.out.println(project.getProjectInfo());
33 }
34 }
3536 }
老大一看，非常 Happy，这么快就出结果了，大大的把我夸奖了一番，然后就去埋头去研究那堆枯燥的报表了，然后我回到座位上，又看了一遍程序（心里很乐，就又想看看自己的成果），想想了，应该还有另外一种实现方式，因为是遍历嘛，让我想到的就是迭代器模式，我先把类图画出来：
看着是不是复杂了很多？是的，是有点复杂了，这个我等会说明原因，我们看代码实现，先 IProject 接口：
1
package
com.pattern.iterator;
2
3
/**
4
* 定义一个接口，所有的项目都是一个接口
5
*
@author
http://www.cnblogs.com/initial-road/
6
*
7
*/
8
public
interface
IProject {
9
10
//
增加项目
11
public
void add(String name, int num, int cost);
1213// 从老板这里看到的就是项目信息14public String getProjectInfo();
1516// 获得一个可以被遍历的对象17public IProjectIterator iterator();
18 }
这里多了两个方法，一个是 add 方法，这个方法是增加项目，也就是说产生了一个对象后，直接使用 add方法增加项目信息。我们再来看实现类：
1
package
com.pattern.iterator;
2
3
import
java.util.ArrayList;
4
5
/**
6
* 所有的项目信息类
7
*
@author
http://www.cnblogs.com/initial-road/
8
*
9
*/
10
public
class Project implements IProject {
11// 定义一项项目列表，所有的项目都放在这里12private ArrayList<IProject> projectList = new ArrayList<IProject>();
1314// 项目名称15private String name = "";
1617// 项目成员数量18privateint num = 0;
1920// 项目费用21privateint cost = 0;
2223public Project(){
2425 }
2627// 定义一个构造函数，把所有老板需要看到的信息存储起来28public Project(String name, int num, int cost){
29// 赋值到类的成员变量中30this.name = name;
31this.num = num;
32this.cost = cost;
33 }
3435// 得到项目的信息36public String getProjectInfo() {
37 String info = "";
3839// 获得项目的名称40 info = info + "项目名称是：" + this.name;
41// 获得项目人数42 info = info + "\t 项目人数：" + this.num;
43// 项目费用44 info = info + "\t 项目费用：" + this.cost;
4546return info;
47 }
4849 @Override
50publicvoid add(String name, int num, int cost) {
51this.projectList.add(new Project(name, num, cost));
52 }
5354 @Override
55public IProjectIterator iterator() {
56returnnew ProjectIterator(this.projectList);
57 }
5859}
6061// 项目信息类已经产生，我们再来看看我们的迭代器是如何实现的，先看接口：6263package com.pattern.iterator;
6465import java.util.Iterator;
6667 @SuppressWarnings("all")
68publicinterface IProjectIterator extends Iterator {
6970 }
大家可能很奇怪，你定义的这个接口方法、变量都没有，有什么意义呢？有意义，所有的 Java 书上都一直说是面向接口编程，你的接口是对一个事物的描述，也就是说我通过接口就知道这个事物有哪些方法， 哪些属性，我们这里的 IProjectIterator 是要建立一个指向 Project 类的迭代器，目前暂时定义的就是一个通用的迭代器，可能以后会增加 IProjectIterator 的一些属性或者方法。当然了，你也可以在实现类上实现两个接口，一个是 Iterator, 一个是 IProjectIterator（这时候，这个接口就不用继承 Iterator），杀猪杀尾巴，各有各的杀发。我的习惯是：如果我要实现一个容器或者其他 API 提供接口时，我一般都自己先写一个接口继承，然后再继承自己写的接口，保证自己的实现类只用实现自己写的接口（接口传递，当然也要实现顶层的接口），程序阅读也清晰一些。我们继续看迭代器的实现类：
1
package
com.pattern.iterator;
2
3
import
java.util.ArrayList;
4
5
/**
6
* 定义一个迭代器
7
*
@author
http://www.cnblogs.com/initial-road/
8
*
9
*/
10
public
class ProjectIterator implements IProjectIterator {
11// 所有的项目都放在这里ArrayList中12private ArrayList<IProject> projectList = new ArrayList<IProject>();
1314privateint currentItem = 0;
1516// 构造函数传入projectList17public ProjectIterator(ArrayList<IProject> projectList){
18this.projectList = projectList;
19 }
2021// 判断是否还有元素，必须实现22publicboolean hasNext() {
23// 定义一个返回值24boolean b = true;
25if(this.currentItem >= this.projectList.size()
26 || this.projectList.get(this.currentItem)==null){
27 b = false;
28 }
29return b;
30 }
3132// 获取下一个值33public Object next() {
34return (IProject) this.projectList.get(this.currentItem++);
35 }
3637// 删除一个对象38publicvoid remove() {
39// 暂时没有使用到40 }
4142 }
都写完毕了，然后看看我们的 Boss 类有多少改动：
1
package
com.pattern.iterator;
2
3
import
java.util.ArrayList;
4
5
/**
6
* 老板来看项目信息了
7
*
@author
http://www.cnblogs.com/initial-road/
8
*
9
*/
10
public
class
Boss {
11
12
public
static
void
main(String[] args) {
13
//
定义一个List，存放所有的项目对象
14 IProject project = new Project();
1516// 增加星球大战项目17 project.add("星球大战项目dddd", 10, 100000);
1819// 增加扭转时空项目20 project.add("扭转时空项目", 100, 1000000);
2122// 增加超人改造项目23 project.add("超人改造项目", 10000, 100000000);
2425// 这边100个项目26for(int i=4;i<104;i++){
27 project.add("第" + i + "个项目", i*5, i*1000000);
28 }
2930// 遍历一下ArrayList，把所有的数据都取出31 IProjectIterator projectIterator = project.iterator();
32while(projectIterator.hasNext()){
33 IProject p = (IProject) projectIterator.next();
34 System.out.println(p.getProjectInfo());
35 }
36 }
3738 }
上面的程序增加了复杂性，但是从面向对象的开发上来看， project.add() 增加一个项目是不是更友好一些？
上面的例子就使用了迭代器模式，我们来看看迭代器的通用类图：
类图是很简单，但是你看用起来就很麻烦，就比如上面例子的两个实现方法，你觉的那个简单？当然是第一个了！ 23 个设计模式是为了简化我们代码和设计的复杂度、耦合程度，为什么我们用了这个迭代器模式程序会复杂了一些呢？这是为什么？因为从 JDK 1.2 版本开始增加 java.util.Iterator 这个接口，并逐步把Iterator 应用到各个聚集类(Collection) 中，我们来看 JDK 1.5 的 API 帮助文件，你会看到有一个叫java.util.Iterable 的接口，看看有多少个接口继承了它：
java.util.Iterable 接口只有一个方法： iterator() ，也就说通过 iterator() 这个方法去遍历聚集类中的所有方法或属性，基本上现在所有的高级的语言都有 Iterator 这个接口或者实现， Java 已经把迭代器给我们准备了，我们再去写迭代器，是不是“六指儿抓痒，多一道子”？所以呀，这个迭代器模式也有点没落了，基本上很少有项目再独立写迭代器了，直接使用 List 或者 Map 就可以完整的解决问题。
原文：http://www.cnblogs.com/initial-road/p/Iterator_pattern.html
内容总结
以上是互联网集市为您收集整理的24种设计模式--迭代模式【Iterator Pattern】全部内容，希望文章能够帮你解决24种设计模式--迭代模式【Iterator Pattern】所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。