当前位置: 萬仟网 > IT编程>软件设计>设计模式 > 设计模式-行为型-迭代器模式

设计模式-行为型-迭代器模式

2019年10月08日 17:42  | 萬仟网IT编程  | 我要评论

迭代器模式(iterator):

  迭代器模式允许你访问一个数据项序列中的所有元素,而无须关心序列是什么类型(数组、链表、列表或任何其他类型)。它能有效地构建一个数据管道,经过一系列不同的转换或过滤后再从管道的另一端出来。迭代器模式就是提供一种遍历集合元素的统一接口,用一致的方法遍历集合元素,不需要知道集合对象的底层表示。

迭代器模式的角色:

    

  1)抽象迭代器(iterator):接口声明了遍历集合所需的操作(获取下一个元素、获取当前位置和重新开始迭代等)。

  2)具体迭代器(concreteiterator):实现遍历集合的一种特定算法。迭代器对象必须跟踪自身遍历的进度。这使得多个迭代器可以相互独立地遍历同一个集合。

  3)抽象聚合(aggregate):接口声明一个或多个方法来获取与集合兼容的迭代器。返回方法的类型必须被声明为迭代器接口。

  4)具体聚合(concreteaggregate):会在客户端请求迭代器时返回一个特定的具体迭代器类实体

  5)客户端(client):通过集合和迭代器的接口与两者进行交互 这样一来客户端无需与具体类进行耦合 允许同一客户端代码使用各种不同的集合和迭代器

示例:

  先假设有两家餐厅,主营业务不同,一家是早餐店,一家是晚餐店。 

  1 /// <summary>
  2 /// 菜单明细项
  3 /// </summary>
  4 public class menuitem
  5 {
  6     private string name;
  7     private string description;
  8     private bool vegetarin;
  9     private double price;
 10 
 11     public menuitem(string name, string description, bool vegetarin, double price)
 12     {
 13         this.name = name;
 14         this.description = description;
 15         this.vegetarin = vegetarin;
 16         this.price = price;
 17     }
 18 
 19     public string getname()
 20     {
 21         return this.name;
 22     }
 23 
 24     public double getprice()
 25     {
 26         return price;
 27     }
 28 
 29     public bool isvegetarian()
 30     {
 31         return vegetarin;
 32     }
 33 
 34     public string getdescription()
 35     {
 36         return description;
 37     }
 38 }
 39 
 40 /// <summary>
 41 /// 早餐菜单
 42 /// </summary>
 43 public class breakfastmenu
 44 {
 45     private list<menuitem> menuitems;
 46 
 47     public breakfastmenu()
 48     {
 49         menuitems = new list<menuitem>();
 50         additem("牛奶", "牛奶description", false, 3.0);
 51         additem("油条", "油条description", false, 1.0);
 52         additem("馒头", "馒头description", true, 1.0);
 53         additem("豆浆", "doujiangdescription", true, 1.5);
 54     }
 55 
 56     public void additem(string name, string description, bool vegetarian, double price)
 57     {
 58         menuitem menuitem = new menuitem(name, description, vegetarian, price);
 59         menuitems.add(menuitem);
 60     }
 61 
 62     public list<menuitem> getmenuitems()
 63     {
 64         return menuitems;
 65     }
 66 }
 67 
 68 /// <summary>
 69 /// 晚餐菜单
 70 /// </summary>
 71 public class dinnermenu
 72 {
 73     private static readonly int max_items = 6;
 74     private int numberofitems = 0;
 75     private menuitem[] menuitems;
 76 
 77     public dinnermenu()
 78     {
 79         menuitems = new menuitem[max_items];
 80         additem("香菇豆腐饭", "香菇豆腐", false, 10.5);
 81         additem("蛋炒饭", "哈哈", false, 8.5);
 82         additem("鱼香肉丝", "你猜", true, 15.5);
 83     }
 84 
 85     public void additem(string name, string description, bool vegetarian, double price)
 86     {
 87         menuitem menuitem = new menuitem(name, description, vegetarian, price);
 88         if (numberofitems > max_items)
 89         {
 90             console.writeline("菜单已满");
 91         }
 92         else
 93         {
 94             menuitems[numberofitems] = menuitem;
 95             numberofitems++;
 96         }
 97     }
 98 
 99     public menuitem[] getmenuitems()
100     {
101         return menuitems;
102     }
103 }

  现在两家合并了,服务员那菜单的时候就要拿两份菜单。

 1 public static void main(string[] args)
 2 {
 3     breakfastmenu breakfastmenu = new breakfastmenu();
 4     list<menuitem> breakfastitems = breakfastmenu.getmenuitems();
 5 
 6     dinnermenu dinermenu = new dinnermenu();
 7     menuitem[] lunchitems = dinermenu.getmenuitems();
 8 
 9     for (int i = 0; i < breakfastitems.count; i++)
10     {
11         menuitem menuitem = breakfastitems[i] as menuitem;
12         console.writeline(menuitem.getname() + " " + menuitem.getprice().tostring() + " " + menuitem.getdescription().tostring());
13     }
14 
15     for (int j = 0; j < lunchitems.length; j++)
16     {
17         menuitem lunchitem = lunchitems[j];
18         if (lunchitem != null)
19         {
20             console.writeline(lunchitem.getname() + " " + lunchitem.getprice().tostring() + " " + lunchitem.getdescription().tostring());
21         }
22     }
23 }

  我们发现,由于两份菜单数据结构的不同,我们不得不重写多余的代码,显得很臃肿。我们会想:能不能有一个东西能够让我们不需要知道菜单的数据结构,直接就可以获取其内部元素呢?答案是肯定的,这就是我们本节所说的迭代器模式。

  先定义一个接口迭代器并实现晚餐菜单迭代器和晚餐菜单迭代器。

 1 /// <summary>
 2 /// 接口迭代器
 3 /// </summary>
 4 public interface iterator
 5 {
 6     /// <summary>
 7     /// 用来判断下一个元素是否为空
 8     /// </summary>
 9     /// <returns></returns>
10     bool hasnext();
11 
12     /// <summary>
13     /// 用来获取当前元素
14     /// </summary>
15     /// <returns></returns>
16     object next();
17 }
18 
19 /// <summary>
20 /// 早餐菜单迭代器
21 /// </summary>
22 public class breakfastiterator : iterator
23 {
24     private list<menuitem> items;
25     private int position = 0;
26 
27     public breakfastiterator(list<menuitem> items)
28     {
29         this.items = items;
30     }
31 
32     public bool hasnext()
33     {
34         return position <= items.count - 1 && items[position] != null;
35     }
36 
37     public object next()
38     {
39         menuitem item = items[position];
40         position++;
41         return item;
42     }
43 }
44 
45 /// <summary>
46 /// 晚餐菜单迭代器
47 /// </summary>
48 public class dinneriterator : iterator
49 {
50     private menuitem[] items;
51     private int position = 0;
52 
53     public dinneriterator(menuitem[] items)
54     {
55         this.items = items;
56     }
57 
58     public bool hasnext()
59     {
60         return position <= items.length && items[position] != null;
61     }
62 
63     public object next()
64     {
65         menuitem item = items[position];
66         position++;
67         return item;
68     }
69 }

  修改菜单。

 1 /// <summary>
 2 /// 抽象聚合对象,用于创建一个迭代器对象
 3 /// </summary>
 4 public interface imenu
 5 {
 6     iterator createiterator();
 7 }
 8 
 9 /// <summary>
10 /// 早餐菜单
11 /// </summary>
12 public class breakfastmenu : imenu
13 
14 {
15     private list<menuitem> menuitems;
16 
17     public breakfastmenu()
18     {
19         menuitems = new list<menuitem>();
20         additem("牛奶", "牛奶description", false, 3.0);
21         additem("油条", "油条description", false, 1.0);
22         additem("馒头", "馒头description", true, 1.0);
23         additem("豆浆", "doujiangdescription", true, 1.5);
24     }
25 
26     public void additem(string name, string description, bool vegetarian, double price)
27     {
28         menuitem menuitem = new menuitem(name, description, vegetarian, price);
29         menuitems.add(menuitem);
30     }
31 
32     //public list<menuitem> getmenuitems()
33     //{
34     //    return menuitems;
35     //}
36 
37     public iterator createiterator()
38     {
39         return new breakfastiterator(menuitems);
40     }
41 }
42 
43 /// <summary>
44 /// 晚餐菜单
45 /// </summary>
46 public class dinnermenu : imenu
47 
48 {
49     private static readonly int max_items = 6;
50     private int numberofitems = 0;
51     private menuitem[] menuitems;
52 
53     public dinnermenu()
54     {
55         menuitems = new menuitem[max_items];
56         additem("香菇豆腐饭", "香菇豆腐", false, 10.5);
57         additem("蛋炒饭", "哈哈", false, 8.5);
58         additem("鱼香肉丝", "你猜", true, 15.5);
59     }
60 
61     public void additem(string name, string description, bool vegetarian, double price)
62     {
63         menuitem menuitem = new menuitem(name, description, vegetarian, price);
64         if (numberofitems > max_items)
65         {
66             console.writeline("菜单已满");
67         }
68         else
69         {
70             menuitems[numberofitems] = menuitem;
71             numberofitems++;
72         }
73     }
74 
75     //public menuitem[] getmenuitems()
76     //{
77     //    return menuitems;
78     //}
79 
80     public iterator createiterator()
81     {
82         return new dinneriterator(menuitems);
83     }
84 }

  这个时候,两份餐单的输出是这样的。

 1 public static void main(string[] args)
 2 {
 3     imenu breakfastmenu = new breakfastmenu();
 4     imenu dinnermenu = new dinnermenu();
 5     breakfastmenu.createiterator();
 6     iterator dinneriterator = dinnermenu.createiterator();
 7     iterator breakfastiterator = breakfastmenu.createiterator();
 8 
 9     print(breakfastiterator);
10     print(dinneriterator);
11 
12     static void print(iterator iterator)
13     {
14         while (iterator.hasnext())
15         {
16             menuitem menuitem = (menuitem)iterator.next();
17             console.writeline(menuitem.getname() + " " + menuitem.getprice().tostring() + " " + menuitem.getdescription().tostring());
18         }
19     }
20 }

迭代器模式适用性:

  1)当集合背后为复杂的数据结构,且你希望对客户端隐藏其复杂性时(出于使用便利性或安全性的考虑),可以使用迭代器。

  2)可以减少程序中重复的遍历代码。

  3)如果你希望代码能够遍历不同的甚至是无法预知的数据结构,可以使用迭代器。

迭代器模式的优缺点:

  优点:

    1)它支持以不同的方式遍历一个聚合对象。

    2)迭代器简化了聚合类。

    3)在同一个聚合上可以有多个遍历。

    4)在迭代器模式中,增加新的聚合类和迭代器类都很方便,无须修改原有代码。符合ocp原则

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

参考:

您可能感兴趣的文章:

如对本文有疑问,请在下面进行留言讨论,广大热心网友会与你互动!! 点击进行留言回复

相关文章:

  • 行为型设计模式(中)

    行为型设计模式(中)

    中介者模式: 1、定义:用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用, 从而使其耦合松散,而且可以独立地改变它们之间的交... [阅读全文]
  • 设计模式 - 单例模式(详解)看看和你理解的是否一样?

    一、概述 单例模式是设计模式中相对简单且非常常见的一种设计模式,但是同时也是非常经典的 高频 面试题,相信还是有很多人在面试时会挂在这里。本篇文章主... [阅读全文]
  • 设计模式-行为型-迭代器模式

    设计模式-行为型-迭代器模式

    迭代器模式(Iterator): 迭代器模式允许你访问一个数据项序列中的所有元素,而无须关心序列是什么类型(数组、链表、列表或任何其他类型)。它能有... [阅读全文]
  • 创建型设计模式(上)

    创建型设计模式(上)

    单例模式: 1、定义:单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类 2、实现过程要点: (1)单例类的... [阅读全文]
  • 结构型设计模式(上)

    结构型设计模式(上)

    适配器模式: 类适配器: 对象适配器: 1、定义:将一个接口转换成客户希望的另一个接口,适配器模式使接口不兼容的那些类可以一起工作 2、模型结构: ... [阅读全文]
  • 行为型设计模式(上)

    行为型设计模式(上)

    责任链模式: 下图为责任链 1、定义:为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前一对象 记住其下一个对象的引用而连成一条... [阅读全文]
  • 设计模式-行为型-观察者模式

    设计模式-行为型-观察者模式

    观察者模式(Observer): 指多个对象间存在一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 观察者模... [阅读全文]
  • 结构型设计模式(下)

    结构型设计模式(下)

    装饰模式: 1、定义:动态地给一个对象增加一些额外的职责,就增加对象功能来说,装饰模式比生成子类实现更为灵活 2、模型结构: (1)抽象构件(Com... [阅读全文]
  • 设计模式-行为型-状态模式

    设计模式-行为型-状态模式

    状态模式(State): 在软件开发过程中,应用程序可能会根据不同的情况作出不同的处理。最直接的解决方案是将这些所有可能发生的情况全都考虑到,然后使... [阅读全文]
  • 设计模式-行为型-职责链模式

    设计模式-行为型-职责链模式

    职责链模式(Chain of Responsibility): 在现实生活中,常常会出现这样的事例:一个请求需要多个对象处理,但每个对象的处理条件或... [阅读全文]

◎已有 0 人评论

Copyright © 2019  萬仟网 保留所有权利. 粤ICP备17035492号-1
站长QQ:2386932994 | 联系邮箱:2386932994@qq.com