迭代器模式——HeadFirst设计模式学习笔记

迭代器模式:提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内部表示

特点:

  • 将客户端与对象集合的存储方式解耦,即客户遍历对象时无需知道对象的具体存储方式
  • 封装变化的部分,即多个不同的集合的不同遍历方式,创建迭代器封装遍历每个对象集合的过程
  • 客户不需要知道具体对象集合是如何存储的,也无需知道迭代器是如何实现的,只需通过迭代器进行遍历
  • 封装了遍历
  • 解决了依赖具体对象集合存储方式和依赖具体对象类型的问题

注意:

  • 对于不支持remove方法的迭代器,可以抛出java.lang.UnsupportedOperationException
  • 迭代器不意味着有次序
  • 可以实现previous()方法向前调取对象

外部迭代器vs内部迭代器:

  • 外部:客户通过next()调取下一个元素
  • 内部:客户将具体操作传给迭代器,具体的调取由迭代器自己控制

单一责任原则:一个类应该只有一个变化的原因

  • 将一个责任指派给一个类
  • 类的每个责任都有改变的潜在区域,超过一个责任意味着超过一个改变区域
  • 为了便于维护,设计单一责任的高内聚类(设计成完成一个或一组相关性高的功能)

举例:

餐厅对于早餐和午餐菜单的菜单项的底层存储方式不同,如果不进行任何优化,服务员遍历菜单时需要根据具体菜单的存储方式使用不同的遍历办法,也对于修改开放的方式不便于维护,不利于扩展

我们将变化的部分拿出来,创建具有单一责任的迭代器对象实现遍历菜单,并封装菜单的存储方式,使服务员无需知道,与服务员解耦

迭代器接口:

1 public interface Iterator {
2     boolean hasNext();
3     Object next();
4 }  

晚餐菜单迭代器实现,针对其底层数组存储方式:

 1 public class DinerMenuIterator implements Iterator {
 2     MenuItem[] items;
 3     int position = 0;
 4
 5     public DinerMenuIterator(MenuItem[] items) {
 6         this.items = items;
 7     }
 8
 9     public Object next() {
10         MenuItem menuItem = items[position];
11         position = position + 1;
12         return menuItem;
13     }
14
15     public boolean hasNext() {
16         if (position >= items.length || items[position] == null) {
17             return false;
18         } else {
19             return true;
20         }
21     }
22 }  

服务生通过迭代器遍历菜单:

 1 public class Waitress {
 2     Menu dinerMenu;
 3     public Waitress( Menu dinerMenu) {
 4         this.dinerMenu = dinerMenu;
 5     }
 6     public void printMenu() {
 7         Iterator dinerIterator = dinerMenu.createIterator();
 8
 9         System.out.println("/nLUNCH");
10         printMenu(dinerIterator);
11     }
12     private void printMenu(Iterator iterator) {
13         while (iterator.hasNext()) {
14             MenuItem menuItem = (MenuItem)iterator.next();
15             System.out.print(menuItem.getName() + ", ");
16             System.out.print(menuItem.getPrice() + " -- ");
17             System.out.println(menuItem.getDescription());
18         }
19     } 
时间: 2024-10-14 05:07:39

迭代器模式——HeadFirst设计模式学习笔记的相关文章

组合模式——HeadFirst设计模式学习笔记

组合模式:允许将对象组合成树形结构来表现"整体/部分"层次结构.组合让客户用一致的方式处理个别对象和组合对象 特点: 树形结构表示对象组合 忽略对象组合和对象个体之间的差别,即相同的操作既可以作用于对象组合,也可以作用与对象个体 注意: 因为继承方法中,有些方法只有对叶子节点有意义,而有些方法只对非叶子节点有意义,我们可以将基类的方法默认实现为抛出UnsupportedOperationException,如果方法无意义,则无需修改默认继承就可以了 透明性: 组合模式以单一责任原则换取

代理模式——HeadFirst设计模式学习笔记

代理模式:为另一个对象提供一个替身或占位符控制这个对象的访问 特点: 让代理对象控制对象的访问,被代理对象可以是远程对象(远程代理),创建开销较大对象(虚拟代理),或需要安全控制的对象(保护代理) 代理分类: 远程代理:好比远程对象(在不同JVM虚拟机的对象)的本地代表(本地方法的行为转移到远程),帮助我们处理网络上的细节 代理假装自己是远程对象,不过只是一个中间角色,处理访问远程对象 Java RMI提供了客户辅助对象stub和服务辅助对象skeleton,并为其提供相同的方法 注意方法返回值

原型模式——HeadFirst设计模式学习笔记

原型模式:通过复制一个已经存在的实例来返回新的实例,而不是新建实例.被复制的实例就是我们所称的原型,这个原型是可定制的(clone) 特点: 向用户隐藏了创建新实例的复杂性 让用户可以产生未知类型的对象,即只需知道对象实现了哪些接口,而无需知道具体是哪种实现 在某些情况下,复制对象比创建对象更高效 Prototype类需要具备以下两个条件: 实现Cloneable接口.在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone

状态模式——HeadFirst设计模式学习笔记

状态模式:允许对象在内部状态改变时改变它的行为,对象看起来好像修改了它的类 --将状态封装成独立的类,将动作委托给当前状态对象,所以行为会随着内部状态的变化而变化 状态转换图:为每一个状态创建一个实现一组相同操作接口的对象,实体对象包含所有状态并有一个当前状态接口的引用 特点: 允许一个对象基于不用的状态有不同的行为 把变化的东西取出来,局部化每个状态的行为,每个状态的行为局部化到自己的类中,遵守"封装变化"原则,减少了繁琐的if语句,满足"对修改关闭,对扩展开放"

装饰者模式——HeadFirst 设计模式学习笔记

装饰者模式:动态的将责任附加到对象上,若要扩展功能,装饰者提供了更有弹性的替代方案. 设计原则: 类的设计应该对拓展开放,对修改关闭.允许类容易拓展,在不修改现有代码的情况下添加新的行为 特点: 装饰者和被装饰对象有相同的超类型,我们利用继承达到"类型匹配",而不是利用继承获得"行为". 装饰者模式动态地将责任附加到对象上.若要扩展功能,装饰者提供了比继承更有弹性的替代方案.如果依赖继承,那么类的行为只能在编译时静态决定,行为不是来自超类就是子类覆盖后的版本,每当需

策略模式——HeadFirst 设计模式学习笔记

策略模式:策略模式定义了算法族,分别封装起来,让他们可以相互替换,此模式让算法的变化独立于使用算法的客户. 设计原则: 找出应用中可能需要变化之处,把他们独立出来,不要和那些不需要变化的代码混在一起.以便以后轻松的更改或扩充此部分,而不影响不需要变化的其他部分 针对接口编程而不是针对实现编程.实际的实现不会被绑定,调用时只知道调用的接口,而无需知道具体的实现方式 多用组合,少用继承.使用组合有很大的弹性,可以在运行时动态改变行为 要点: 良好的OO设计必须遵循可复用,可拓展,可维护 大部分模式允

中介者模式——HeadFirst设计模式学习笔记

中介者模式:集中管理相关对象之间的复杂沟通和控制     ------>>>>    特点: 关系复杂的对象之间解耦了(对象之间必须相互认识 -> 对象只认识中介者) 中介者包含了整个系统的控制逻辑,控制逻辑集中可以简化维护 每个对象在自己状态改变时告诉中介者,每个对象对中介者发出的请求给予回应 中介者常常被用来协调GUI组建 中介者需要包含所有被中介对象的引用,被中介对象可以选择是否包含中介者引用(可以在方法调用时传入) 缺点: 中介者自身可能过于复杂

解释器模式——HeadFirst设计模式学习笔记

解释器模式:给定一种语言,定义他的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中句子 特点: 每一种语法设置为一个类,便于实现 便于扩展语言的语法 用与处理重复发生的交叉问题或解析一种语言 缺点: 解释器模式会引起类膨胀 效率不高 解释器模式采用递归调用方法 举例: 1 //解释器接口 2 public interface Expression { 3 public boolean interpret(String context); 4 } 5 6 //实现Or解释器 7 p

生成器模式——HeadFirst设计模式学习笔记

生成器模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 builder:为创建一个产品对象的各个部件指定抽象接口 ConcreteBuilder:实现Builder的接口以构造和装配该产品的各个部件,定义并明确它所创建的表示,并提供一个产品的引用 Director:构造一个使用Builder接口的对象(可选) Product:表示被构造的复杂对象 优点: 将一个复杂对象的创建过程封装起来 允许对象通过多个步骤来创建,并且可以改变过程(这和只有一个步骤的工厂模式不同)