- 浏览: 56627 次
- 性别:
- 来自: 北京
文章分类
最新评论
迭代器模式:提供一种方法顺序访问一个聚合对象中的各个元素,而有不暴露起内部的表示。 【Head First design pattern】
下面来分析一个Demo:
这个就是"聚合对象中的元素"。
ClassA 中使用数组来存储“元素”。
ClassB 中使用List来存储“元素”。
测试代码:
现在我们看看用迭代器模式怎么做:
1.定义接口:
classA对应的迭代器。
下面来分析一个Demo:
这个就是"聚合对象中的元素"。
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
--> class ItemFir:IItem
{
string name;
ItemFlag flag;
public ItemFlag Flag
{
get { return flag; }
set { flag = value; }
}
public ItemFir(string name, string des,ItemFlag itemflag)
{
this.des = des;
this.name = name;
this.flag = itemflag;
}
public string Name
{
get { return name; }
set { name = value; }
}
string des;
public string Des
{
get { return des; }
set { des = value; }
}
}
{
string name;
ItemFlag flag;
public ItemFlag Flag
{
get { return flag; }
set { flag = value; }
}
public ItemFir(string name, string des,ItemFlag itemflag)
{
this.des = des;
this.name = name;
this.flag = itemflag;
}
public string Name
{
get { return name; }
set { name = value; }
}
string des;
public string Des
{
get { return des; }
set { des = value; }
}
}
ClassA 中使用数组来存储“元素”。
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
--> class ClassA
{
IItem[] myitemlist = new ItemFir[10];
#region
public ClassA()
{
ItemFlag flag = ItemFlag.LOW;
for (int i = 0; i < myitemlist.Length; i++)
{
flag = (ItemFlag)System.Enum.Parse(typeof(ItemFlag), "" + (i - (myitemlist.Length / 2)) % 2 + "");
// 获得 -1,0,1对应的枚举
myitemlist[i] = new ItemFir(String.Format("ClassA{0}",i),String.Format("ClassA{0}Des",i),flag);
}
}
public string GetDes()
{
return "I'am ClassA";
}
public void Add(IItem item)
{
}
public void Remove(IItem item)
{
}
public IItem Get(int i)
{
return myitemlist[i];
}
#endregion
public IItem[] GetAll()
{
return myitemlist;
}
//public IIterator CreateIterator()
//{
// return new ClassAIterator(myitemlist);
//}
}
{
IItem[] myitemlist = new ItemFir[10];
#region
public ClassA()
{
ItemFlag flag = ItemFlag.LOW;
for (int i = 0; i < myitemlist.Length; i++)
{
flag = (ItemFlag)System.Enum.Parse(typeof(ItemFlag), "" + (i - (myitemlist.Length / 2)) % 2 + "");
// 获得 -1,0,1对应的枚举
myitemlist[i] = new ItemFir(String.Format("ClassA{0}",i),String.Format("ClassA{0}Des",i),flag);
}
}
public string GetDes()
{
return "I'am ClassA";
}
public void Add(IItem item)
{
}
public void Remove(IItem item)
{
}
public IItem Get(int i)
{
return myitemlist[i];
}
#endregion
public IItem[] GetAll()
{
return myitemlist;
}
//public IIterator CreateIterator()
//{
// return new ClassAIterator(myitemlist);
//}
}
ClassB 中使用List来存储“元素”。
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
--> class ClassB
{
List<IItem> myitemlist = new List<IItem>();
#region
public ClassB()
{
myitemlist.Add(new ItemFir("ClassB Item1", "ClassB Item1 Des", ItemFlag.HIGH));
myitemlist.Add(new ItemFir("ClassB Item2", "ClassB Item3 Des", ItemFlag.LOW));
myitemlist.Add(new ItemFir("ClassB Item3", "ClassB Item3 Des", ItemFlag.HIGH));
myitemlist.Add(new ItemFir("ClassB Item4", "ClassB Item4 Des", ItemFlag.MEDIAL));
myitemlist.Add(new ItemFir("ClassB Item5", "ClassB Item5 Des", ItemFlag.LOW));
}
public string GetDes()
{
return "I'am ClassB";
}
public void AddItem(IItem item)
{
}
public void RemoveItem(IItem item)
{
}
public IItem GetItem(int i)
{
return myitemlist[i];
}
#endregion
public List<IItem> GetAllItem()
{
return myitemlist;
}
//public IIterator CreateIterator()
//{
// return new ClassBIterator(myitemlist);
//}
}
ItemFlag 源码:{
List<IItem> myitemlist = new List<IItem>();
#region
public ClassB()
{
myitemlist.Add(new ItemFir("ClassB Item1", "ClassB Item1 Des", ItemFlag.HIGH));
myitemlist.Add(new ItemFir("ClassB Item2", "ClassB Item3 Des", ItemFlag.LOW));
myitemlist.Add(new ItemFir("ClassB Item3", "ClassB Item3 Des", ItemFlag.HIGH));
myitemlist.Add(new ItemFir("ClassB Item4", "ClassB Item4 Des", ItemFlag.MEDIAL));
myitemlist.Add(new ItemFir("ClassB Item5", "ClassB Item5 Des", ItemFlag.LOW));
}
public string GetDes()
{
return "I'am ClassB";
}
public void AddItem(IItem item)
{
}
public void RemoveItem(IItem item)
{
}
public IItem GetItem(int i)
{
return myitemlist[i];
}
#endregion
public List<IItem> GetAllItem()
{
return myitemlist;
}
//public IIterator CreateIterator()
//{
// return new ClassBIterator(myitemlist);
//}
}
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
-->enum ItemFlag
{
LOW = -1,
MEDIAL = 0,
HIGH = 1,
}
{
LOW = -1,
MEDIAL = 0,
HIGH = 1,
}
测试代码:
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
--> static void Main(string[] args)
{
ClassA classA = new ClassA();
IItem[] itemlistA = classA.GetAll();
Console.Write("ClassA\n");
for (int i = 0; i < itemlistA.Length; i++)
{
if (itemlistA[i].Flag == ItemFlag.LOW)
Console.Write(itemlistA[i].Name + " " + itemlistA[i].Flag + "\n");
}
Console.Write("ClassB\n");
ClassB classB = new ClassB();
List<IItem> itemlistB = classB.GetAllItem();
for (int j = 0; j < itemlistB.Count; j++)
{
if (itemlistB[j].Flag == ItemFlag.LOW)
Console.Write(itemlistB[j].Name + " " + itemlistB[j].Flag + "\n");
}
}
我们希望把 ClassA 中和ClassB 中所有ItemFalg 值为LOW的元素选择出来。其实对于客户来说没必要知道你用数组还是list来保存的。客户需要用不同的方式来访问聚合,也显得不够优雅。( itemlistB.Count ,itemlistA.Length)还有像上面如果有10个类就得用十个循环。{
ClassA classA = new ClassA();
IItem[] itemlistA = classA.GetAll();
Console.Write("ClassA\n");
for (int i = 0; i < itemlistA.Length; i++)
{
if (itemlistA[i].Flag == ItemFlag.LOW)
Console.Write(itemlistA[i].Name + " " + itemlistA[i].Flag + "\n");
}
Console.Write("ClassB\n");
ClassB classB = new ClassB();
List<IItem> itemlistB = classB.GetAllItem();
for (int j = 0; j < itemlistB.Count; j++)
{
if (itemlistB[j].Flag == ItemFlag.LOW)
Console.Write(itemlistB[j].Name + " " + itemlistB[j].Flag + "\n");
}
}
现在我们看看用迭代器模式怎么做:
1.定义接口:
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
--> interface IIterator
{
bool HasNext();
IItem Next();
}
2. 实现迭代器:{
bool HasNext();
IItem Next();
}
classA对应的迭代器。
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
--> class ClassAIterator : IIterator
{
int posion;
IItem[] item;
public ClassAIterator(IItem[] item)
{
this.item = item;
}
public bool HasNext()
{
return posion <= item.Length - 1;
}
public IItem Next()
{
return item[posion++];
}
}
ClassB的迭代器:{
int posion;
IItem[] item;
public ClassAIterator(IItem[] item)
{
this.item = item;
}
public bool HasNext()
{
return posion <= item.Length - 1;
}
public IItem Next()
{
return item[posion++];
}
}
<!--<br />
<br />
Code highlighting produced by Actipro CodeHighlighter (freeware)<br />
http://www.CodeHighlighter.com/<br />
<br />
-->
Code
<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --> class ClassBIterator:IIterator
{
int posion;
List< IItem> item;
public ClassBIterator( List< IItem> item)
a
<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --> class ClassBIterator:IIterator
{
int posion;
List< IItem> item;
public ClassBIterator( List< IItem> item)
a
发表评论
-
观察者模式
2008-06-04 16:19 734观察者模式是实现一个对象对多个对象通知的解决方案( ... -
桥接模式 bridge
2008-06-06 11:33 655桥接模式: 将抽象和行为划分开来,各自独立,但能动态的结合。 ... -
设计模式之抽象工厂(AbstractFactory)---用抽象工厂实现网页样式生成器
2008-06-10 17:29 783意图[gof 设计模式]:提供一个创建一系列相关或相互依赖对 ... -
设计模式之命令模式(Command)
2008-06-13 18:08 756定义: 将一个请求封装为一个对象,从而使你可用不同的请 ... -
单件模式 singleton
2008-06-19 09:35 711概述:我们很多时候需要一个类只产生一个实例。类似双击 ... -
适配器模式 adapter
2008-06-19 13:49 740适配器模式:将一个类的接口,转换成客户期望的另一个接口。适配器 ... -
外观模式 facade
2008-06-20 12:09 681外观模式 f ... -
策略模式 strategy
2008-06-24 12:48 657策略模式:定义算法族,分别封装起来,让他们可以互相替换,从而使 ... -
状态模式 state
2008-06-28 01:48 682状态模式:允许对象的内部状态改变时改变它的行为,对想看起来好像 ...
相关推荐
迭代器模式(Iterator Pattern)是Java设计模式中的行为模式之一,它提供了一种方法来顺序访问聚合对象的元素,而又不暴露其底层表示。在Java中,迭代器模式被广泛应用于集合类,如ArrayList、LinkedList等,通过...
迭代器模式是软件设计模式中的一种行为模式,它在C#等面向对象编程语言中有着广泛的应用。这个模式的主要目标是允许用户遍历一个聚合对象(如数组、集合或列表)的所有元素,而无需了解底层的实现细节。下面将详细...
例如,在Java中,`Iterable`接口和`Iterator`接口就是实现迭代器模式的关键。`Iterable`接口定义了获取迭代器的方法`iterator()`,而`Iterator`接口提供了`hasNext()`和`next()`方法,分别用于检查是否还有下一个...
迭代器模式(Iterator Pattern)是设计模式中的一种行为模式,它允许顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示。迭代器模式提供了一种方法,可以顺序地访问一个聚合对象中的各个元素,而又...
C#面向对象设计模式 (行为型模式) Iterator 迭代器模式 视频讲座下载
在迭代器模式中,存在三个主要角色:迭代器(Iterator)、聚合对象(Aggregate)和客户端(Client)。迭代器负责遍历聚合对象中的元素,聚合对象提供了元素的集合,而客户端则使用迭代器来遍历聚合对象中的元素。 ...
迭代器模式是软件设计模式中的行为模式之一,它在C++编程中有着广泛的应用。这个模式提供了一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。通过迭代器,用户可以遍历集合中的所有元素,而无需知道如何...
迭代器模式是一种常用的设计模式,它允许我们以一种顺序访问集合对象的方式遍历其元素,而无需暴露该对象的内部表示。接下来,我们将详细讨论这一模式的关键概念、结构及其在Java集合框架中的具体实现。 ### 一、...
迭代器模式是一种设计模式,它提供了一种方法来顺序访问聚合对象的元素,而又不暴露其底层表示。在C++中,迭代器模式通常通过定义一个接口,该接口允许访问和遍历聚合对象的元素,而无需暴露其内部结构。这种模式在...
迭代器模式是一种设计模式,属于行为设计模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、C#等面向对象语言中,迭代器模式被广泛应用于容器类,如ArrayList、LinkedList等,使得我们可以...
迭代器模式是软件设计模式中的一种行为模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、C#等面向对象语言中,迭代器模式被广泛应用于容器类,如ArrayList、LinkedList等,使得我们可以方便...
迭代器模式是一种行为设计模式,它提供了一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。在Java中,迭代器模式是通过接口实现的,这使得我们可以遍历任何实现了`Iterable`接口的对象,例如集合框架中的`...
在Java编程语言中,迭代器模式(Iterator Pattern)是一种常用的设计模式,用于顺序访问集合对象中的元素,而无需暴露其底层表示。这种模式提供了一种方法来访问一个聚合对象的元素,而无需暴露该对象的内部结构。在...
迭代器模式是一种设计模式,它在软件工程中扮演着重要的角色,特别是在处理集合或容器类对象的遍历操作时。这种模式提供了一种方法来顺序访问聚合对象的元素,而无需暴露其底层表示。在Java、C#等面向对象语言中,...
在Java、C#等面向对象语言中,迭代器模式的应用非常广泛,例如Java中的`Iterable`接口和`Iterator`接口,C#中的`IEnumerable`接口和`IEnumerator`接口。这些接口为实现迭代器模式提供了标准的方式。 迭代器模式的...
迭代器模式是面向对象设计中的一种行为模式,它允许我们顺序访问聚合对象的元素,而无需暴露其底层结构。在PHP中,迭代器模式通过提供一个接口,使得客户端可以遍历任何类型的集合,如数组、关联数组或自定义的数据...
迭代器模式是设计模式中的一种行为模式,它提供了一种顺序访问聚合对象的元素而无需暴露其底层表示的方法。在Android开发中,迭代器模式的应用可以帮助我们更好地管理和遍历集合数据,尤其在处理复杂的逻辑或者需要...
迭代器模式(IteratorPattern)是设计模式中的一种行为模式,它提供了一种顺序访问聚合对象元素的方法,同时又不暴露其底层表示。这种模式允许我们遍历集合对象的元素,而无需暴露其内部结构。在Java、C#等面向对象...