设计模式之九:迭代器与组合模式

这篇具有很好参考价值的文章主要介绍了设计模式之九:迭代器与组合模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

迭代器模式:

有许多方法可以把对象堆起来成为一个集合(Collection),比如放入数组、堆栈或散列表中。若用户直接从这些数据结构中取出对象,则需要知道具体是存在什么数据结构中(如栈就用peek,数组[])。迭代器能够让客户遍历你的对象而又无法窥视你存储对象的方式。

对象村餐厅和煎饼屋合并了,它们有着不同的菜单列表,但菜单项基础都是一样的。

class MenuItem
{
private:
	string name;
	string description;
	bool vegetarian;
	double price;

public:
	MenuItem(string name, string description, bool vegetarian, double price)
	{
		this->name = name;
		this->description = description;
		this->vegetarian = vegetarian;
		this->price = price;
	}

	string getName()
	{
		return name;
	}

	string getDescription()
	{
		return description;
	}

	bool isVegetarian()
	{
		return vegetarian;
	}

	double getpPrice()
	{
		return price;
	}
};

下面就写Java代码了,改成C++一时半会还是做不过来。

public class PancakeHouseMenu
{
	ArrayList menuItems;

	public PancakeHouseMenu()
	{
		menuItems = new ArrayList();

		addItem("K&B's Pancake Breakfast", "Pancakes with scrambled eggs, and toast", true, 2.99);
	}

	public void addItem(String name, String description, boolean vegetarian, double price)
	{
		MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
		menuItems.add(menuItem);
	}

	public ArrayList getMenuItems()
	{
		return menuItems;
	}
};


/ ********************************************************/
public class DinerMenu
{
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;

	public DinerMenu()
	{
		menuItems = new MenuItem[MAX_ITEMS];

		addItem("Vegetarian BLT", "Fakin Bacon", true, 2.99);
	}

	public void addItem(String name, String description, boolean vegetarian, double price)
	{
		MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
		if (numberOfItems >= MAX_ITEMS)
		{
			System.err.println("Sorry, menu is full! Can't add item to menu");
		}
		else
		{
			menuItems[numberOfItems++] = menuItem;
		}
	}

	public MenuItem[] getMenuItems()
	{
		return menuItems;
	}
};

这两种不同的菜单表现方式,会使得女招待需要知道菜单的实现细节,才能对菜单进行遍历。

PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
ArrayList breakfastItems = pancakeHouseMenu.getMenuItems();

for breakfastItems.size()
MenuItem menuItem = (MenuItem)breakfastItems.get(i);


/ ******************************************************************* /
DinerMenu dinerMenu = new DinerMenu();
MenuItem[] lunchItems = DinerMenu.getMenuItems();

for lunchItems.size()
MenuItem menuItem = lunchItems[i];

如果还有第三家餐厅以不同的实现出现,我们就需要有三个循环。

因此,我们需要创建一个对象(迭代器),封装“遍历集合内的每个对象的过程”。

Iterator iter = breakfastItems.createIterator();

while (iter.hasNext())
{
	MenuItem menuItem = (MenuItem)iter.next();
}

设计模式之九:迭代器与组合模式,设计模式,设计模式

 当我们拥有迭代器接口后,我们就可以为各种对象集合实现迭代器

设计模式之九:迭代器与组合模式,设计模式,设计模式

public interface Iterator
{
	boolean hasNext();
	Object next();
};

public class DinerMenuIterator implements Iterator
{
	MenuItem[] items;
	int position = 0;

	public DinerMenuIterator(MenuItem[] items)
	{
		this.items = items;
	}

	public Object next()
	{
		MenuItem menuItem = items[position++];
		return menuItem;
	}

	public boolean hasNext()
	{
		if (position >= items.length || items[position] == null) return false;
		else return true;
	}
};

有了DinerMenuIterator后就可以改造DinerMenu和PancakeHouseMenu。

public class DinerMenu
{
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;

	// public DinerMenu()

	// addItem()

	// 删除getMenuItems()
    
    public Iterator createIterator()
    {
        // 返回迭代器接口。客户不需要知道餐厅菜单如何维护菜单项
        return new DinerMenuIterator(menuItems);
    }
};
public class Waitress {
	PancakeHouseMenu pancakeHouseMenu;
	DinerMenu dinerMenu;
 
	public Waitress(PancakeHouseMenu pancakeHouseMenu, DinerMenu dinerMenu) {
		this.pancakeHouseMenu = pancakeHouseMenu;
		this.dinerMenu = dinerMenu;
	}
 
	public void printMenu() {
		Iterator pancakeIterator = pancakeHouseMenu.createIterator();
		Iterator dinerIterator = dinerMenu.createIterator();

		System.out.println("MENU\n----\nBREAKFAST");
		printMenu(pancakeIterator);
		System.out.println("\nLUNCH");
		printMenu(dinerIterator);

	}
 
	private void printMenu(Iterator iterator) {
		while (iterator.hasNext()) {
			MenuItem menuItem = iterator.next();
			System.out.print(menuItem.getName() + ", ");
			System.out.print(menuItem.getPrice() + " -- ");
			System.out.println(menuItem.getDescription());
		}
	}
}

现在可以进一步对waitress进行优化,因为她还捆绑两个具体的菜单类。但在优化之前,我们先看下目前的设计。

设计模式之九:迭代器与组合模式,设计模式,设计模式

 除了使用自己构建的迭代器接口外,还可以直接使用java.util的迭代器接口,同时ArrayList也有一个返回迭代器的方法。

设计模式之九:迭代器与组合模式,设计模式,设计模式

// 煎饼屋的代码

public Iterator createIterator()
{
    return menuItems.iterator();
}


// 餐厅的代码

public class DinerMenuIterator implements Iterator {
	MenuItem[] list;
	int position = 0;
 
	public DinerMenuIterator(MenuItem[] list) {
		this.list = list;
	}
 
	public MenuItem next() {
		MenuItem menuItem = list[position];
		position = position + 1;
		return menuItem;
	}
 
	public boolean hasNext() {
		if (position >= list.length || list[position] == null) {
			return false;
		} else {
			return true;
		}
	}

	public void remove() {
		if (position <= 0) {
			throw new IllegalStateException
				("You can't remove an item until you've done at least one next()");
		}
		if (list[position-1] != null) {
			for (int i = position-1; i < (list.length-1); i++) {
				list[i] = list[i+1];
			}
			list[list.length-1] = null;
		}
	}

}

最后我们再给菜单一个共同的接口,然后修改下女招待。

public interface Menu
{
    public Iterator createIterator();
}


public class Waitress {
	Menu pancakeHouseMenu;
	Menu dinerMenu;
 
	public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
		this.pancakeHouseMenu = pancakeHouseMenu;
		this.dinerMenu = dinerMenu;
	}
 
	public void printMenu() {
		Iterator<MenuItem> pancakeIterator = pancakeHouseMenu.createIterator();
		Iterator<MenuItem> dinerIterator = dinerMenu.createIterator();

		System.out.println("MENU\n----\nBREAKFAST");
		printMenu(pancakeIterator);
		System.out.println("\nLUNCH");
		printMenu(dinerIterator);
	}
 
	private void printMenu(Iterator iterator) {
		while (iterator.hasNext()) {
			MenuItem menuItem = (MenuItem)iterator.next();
			System.out.print(menuItem.getName() + ", ");
			System.out.print(menuItem.getPrice() + " -- ");
			System.out.println(menuItem.getDescription());
		}
	}

}

设计模式之九:迭代器与组合模式,设计模式,设计模式

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内部的表示。(把游走的任务放在迭代器上,而不是聚合上。这样简化了聚合的接口和实现,也让责任各得其所)

设计模式之九:迭代器与组合模式,设计模式,设计模式

单一职责:一个类应该只有一个引起变化的原因。(随着系统的成长,随时观察有没有迹象显示某个类改变的原因超出一个)

组合模式:

是现在我们有一个新的需求,将一份甜点菜单作为餐厅菜单的菜单项(而不是做成一个新菜单,因为类型不同)

设计模式之九:迭代器与组合模式,设计模式,设计模式

(我们需要更有弹性的在菜单项之间游走,可能只需要遍历甜点菜单或者可以遍历餐厅的整个菜单。)

组合模式允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。

设计模式之九:迭代器与组合模式,设计模式,设计模式

菜单是节点,菜单项是叶节点。

使用组合结构,我们能把相同的操作应用在组合和个别对象上。换句话说,在大多数情况下,我们可以忽略对象组合和个别对象之间的差别。

设计模式之九:迭代器与组合模式,设计模式,设计模式

设计模式之九:迭代器与组合模式,设计模式,设计模式

菜单组件的角色是为叶节点和组合节点提供一个共同的接口(所有组件都必须实现MenuComponent接口,然而,叶节点和组合节点的角色不同,所以有些方法可能并不适合某些节点。面对这种情况,你最好是抛出运行时异常。这样如果菜单项或菜单不支持某个操作,他们就不需做任何事情,直接继承默认实现)。

设计模式之九:迭代器与组合模式,设计模式,设计模式

设计模式之九:迭代器与组合模式,设计模式,设计模式

设计模式之九:迭代器与组合模式,设计模式,设计模式

设计模式之九:迭代器与组合模式,设计模式,设计模式

设计模式之九:迭代器与组合模式,设计模式,设计模式

组合模式以单一职责设计原则换取透明性。什么是透明性?通过让组件接口同时包含一些管理子节点和叶节点的操作,客户酒可以将组合和叶节点一视同仁。也就是说,一个元素究竟是组合还是叶节点,对客户是透明的。

设计模式之九:迭代器与组合模式,设计模式,设计模式

上面代码先看next逻辑,清楚后再看hasNext(从上层往下层打印)

设计模式之九:迭代器与组合模式,设计模式,设计模式

设计模式之九:迭代器与组合模式,设计模式,设计模式

当你有数个对象的集合,它们彼此之间有“整体/部分”的关系,并且你想用一致的方法对待这些对象时,就可以使用组合模式。文章来源地址https://www.toymoban.com/news/detail-688174.html

到了这里,关于设计模式之九:迭代器与组合模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式——迭代器模式

    它提供一种方法访问一个容器对象中各个元素,而又不需要暴露该对象的内部细节。 迭代器是为容器服务的,能容纳元素的对象可以称为容器,例:List、Set、Map 迭代器模式(Iterator Pattern)已经是没落的设计模式,常用的容器基本都有成熟稳定的实现,基本不会再去单独写一

    2024年02月13日
    浏览(40)
  • 设计模式:迭代器模式

    迭代器模式的示例可以涵盖各种数据结构的遍历,包括数组、列表、树、图等。下面是一些不同场景下迭代器模式的示例及其代码实现。 示例 1: 数组遍历 使用迭代器模式遍历数组。 示例 2: 二叉树的深度优先遍历 二叉树的深度优先遍历(使用栈实现)。 示例 3: 分页遍历 在

    2024年04月11日
    浏览(48)
  • 设计模式-迭代器模式

      迭代器模式(Iterator Design Pattern),也叫作游标模式(Cursor Design Pattern)。它用来遍历集合对象。这里说的“集合对象”也可以叫“容器”“聚合对象”,实际上就是包含一组对象的对象,比如数组、链表、树、图、跳表。迭代器模式将集合对象的遍历操作从集合类中拆

    2024年02月05日
    浏览(52)
  • 设计模式——迭代器模式15

    迭代器模式提供一种方法访问一个容器对象中各个元素,而又不需暴露该对象的内部细节。 设计模式,一定要敲代码理解 迭代器模式将数据存储和数据遍历的职责进行分离。但针对不同结构的迭代对象,迭代方式需进行添加。 代码下载

    2024年04月15日
    浏览(46)
  • 设计模式行为型——迭代器模式

    目录 迭代器模式的定义 迭代器模式的实现 迭代器模式角色 迭代器模式类图 迭代器模式代码实现 迭代器模式的特点 优点 缺点 使用场景 注意事项         迭代器模式(Iterator Pattern)属于行为型模式,其提供一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对

    2024年02月14日
    浏览(35)
  • Java 设计模式——迭代器模式

    迭代器模式 (Iterator Pattern) 是一种行为型设计模式, 它提供一种顺序访问聚合对象(如列表、集合等)中的元素,而无需暴露聚合对象的内部表示 。迭代器模式将遍历逻辑封装在一个 迭代器对象 中,使得我们可以使用统一的方式遍历不同类型的聚合对象,同时也可以简化客

    2024年02月16日
    浏览(37)
  • 行为型设计模式——迭代器模式

    迭代器模式也是非常的简单, 定义如下: 提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。 相信大家都使用过类似下面的迭代器: 如果在你的项目中需要对一个自定义的集合进行迭代遍历,那么迭代器模式是非常需要学习的。迭代器模式主

    2024年01月18日
    浏览(42)
  • 设计模式学习笔记 - 设计模式与范式 -行为型:9.迭代器模式(上):相比直接遍历集合数据,使用迭代器模式有哪些优势?

    上篇文章,我们学习了状态模式。状态模式是状态机的一种实现方式。它通过将事件触发的状态转移和动作执行,拆分到不同的状态类中,以此来避免状态机类中的分支判断逻辑,应对状态机类代码的复杂性。 本章,学习另外一种行为型设计模式,迭代器模式。它用来遍历集

    2024年04月15日
    浏览(56)
  • C#设计模式之---迭代器模式

    迭代器模式(Iterator Pattern)是一种对象行为模式,提供一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对象的内部表示。支持在聚集中移动游标,使得访问聚合中的元素变得简单,简化了聚集的接口,封装了聚合的对象。 迭代器模式还可以应用于对树结构的访

    2024年02月13日
    浏览(49)
  • 《设计模式的艺术》笔记 - 迭代器模式

            迭代器模式提供一种方法来访问聚合对象,而不用暴露这个对象的内部表示,其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。 myclass.h myclass.cpp main.cpp         1. 支持以不同的方式遍历一个聚合对象,在同一个聚合对象上可以定义多种遍历方式。在迭代

    2024年01月24日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包