HeadFirst设计模式（十） - 迭代器模式

时间  2019-11-17
标签 headfirst 设计 模式 迭代 繁體版
原文   原文链接

良好的管理集合

有许多种方法能够把对象堆起来成为一个集合。你能够把它们放进数据、堆栈、列表或者是散列表中，每一种都有它本身的优势和适合的使用时机。java

举个例子

加入如今有两个餐厅，披萨餐厅和煎饼餐厅，它们合并了，他们的菜单就须要合并在一块儿。数组

披萨餐厅是用ArrayList对象去存放餐单信息，而煎饼餐厅使用数组。他们两家餐厅都赞成让菜单对象实现MenuItem。让咱们看看具体的实现：数据结构

package cn.net.bysoft.iterator;

// 菜单对象，保存了菜单的信息
public class MenuItem {

	public MenuItem(String name, String description, boolean vegetarian, double price) {
		super();
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public boolean isVegetarian() {
		return vegetarian;
	}

	public void setVegetarian(boolean vegetarian) {
		this.vegetarian = vegetarian;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	private String name;
	private String description;
	private boolean vegetarian;
	private double price;
}
import java.util.ArrayList;

// 煎饼餐厅对象，用ArrayList保存了菜单。
public class PancakeHouseMenu {
	ArrayList<MenuItem> menuItems;
	
	public PancakeHouseMenu() {
		menuItems = new ArrayList<MenuItem>();
		addItem("煎饼1号", "牛肉煎饼", false, 2.99);
		addItem("煎饼2号", "素食煎饼", true, 1.49);
	}
	
	public void addItem(String name, String description, boolean vegetarian, double price) {
		MenuItem menu = new MenuItem(name, description, vegetarian, price);
		menuItems.add(menu);
	}

	public ArrayList<MenuItem> getMenuItems() {
		return menuItems;
	}
}
// 披萨餐厅对象，用数据保存了菜单信息。
public class PizzaHouseMenu {
	static final int MAX_ITEMS = 2;
	int numberOfItems = 0;
	MenuItem[] menuItems;

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

	public void addItem(String name, String description, boolean vegetarian, double price) {
		MenuItem menu = new MenuItem(name, description, vegetarian, price);
		if (numberOfItems >= MAX_ITEMS)
			System.out.println("对不起，菜单数量已满");
		else
			menuItems[numberOfItems++] = menu;
	}

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

    想了解为何有两种不一样的菜单表现方式会让事情变得复杂化，让咱们试着实现一个同事使用者两个菜单的客户代码。建立一个服务员对象。this

  • printMenu(); 打印出菜单上的每一项
  • printBreakfastMenu(); 只打印早餐
  • printLunchMenu(); 只打印午饭
  • printVegetarianMenu(); 打印全部的素食菜单
  • isItemVegetarian(name); 查询指定的菜品是不是素食

    先从实现printMenu()方法开始：spa

import java.util.ArrayList;

public class Client {
	public static void main(String[] args) {
		// 先得到煎饼餐厅的菜单集合
		PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
		ArrayList<MenuItem> menusOfPancake = pancakeHouseMenu.getMenuItems();

		// 在得到披萨餐厅的菜单数组
		PizzaHouseMenu pizzaHouseMenu = new PizzaHouseMenu();
		MenuItem[] menusOfPizza = pizzaHouseMenu.getMenuItems();

		for (int i = 0; i < menusOfPancake.size(); i++) {
			MenuItem menu = menusOfPancake.get(i);
			System.out.print(menu.getName() + ",价格:");
			System.out.print(menu.getPrice() + ",");
			System.out.print(menu.getDescription() + "\n");
		}

		System.out.println();

		for (int i = 0; i < menusOfPizza.length; i++) {
			MenuItem menu = menusOfPizza[i];
			System.out.print(menu.getName() + ",价格:");
			System.out.print(menu.getPrice() + ",");
			System.out.print(menu.getDescription() + "\n");
		}
	}
}

    打印每份菜单上的全部项，必须调用getMenuItem()方法，来取得他们各自的菜单。上面的例子中二者的返回类型是不一样的。.net

    接着，想打印出菜单须要将集合和数组循环并一一列出菜单。设计

    最后，咱们老是须要处理这两个菜单的遍历，若是还有第三家餐厅以不一样的方式实现菜单集合，咱们就须要有第三个循环。code

能够封装遍历吗？

    能够封装变化的部分。很明显，这里发生的变化是：由不一样的集合类型所形成的遍历。可是，这可以被封装吗？让咱们来看看这个想法……对象

  1. 要便利煎饼餐厅，咱们须要使用ArrayList的size()和get()方法；
  2. 要便利披萨餐厅，咱们须要使用数组的length字段和在中括号中输入索引；
  3. 如今咱们建立一个对象，将它称为迭代器(Iterator)，利用它来封装“遍历集合内的每一个对象的过程”；

     想要在餐厅菜单中加入一个迭代器，咱们须要先定义迭代器接口，而后为披萨餐厅建立一个迭代器类：索引

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

	MenuItem[] items;
	int position = 0;
	
	public PizzaIterator(MenuItem[] items) {
		this.items = items;
	}
	
	// 判断数组下一个索引是否还有元素
	public boolean hasNext() {
		if(position >= items.length || items[position] == null)
			return false;
		else return true;
	}
	
	// 得到当前索引位置的元素
	public Object next() {
		MenuItem item = items[position++];
		return item;
	}

}

import java.util.ArrayList;

public class PancakeIterator implements Iterator {

	ArrayList<MenuItem> items;
	int position = 0;
	
	public PancakeIterator(ArrayList<MenuItem> items) {
		this.items = items;
	}
	
	// 判断数组下一个索引是否还有元素
	public boolean hasNext() {
		if(position >= items.size() || items.get(position) == null)
			return false;
		else return true;
	}
	
	// 得到当前索引位置的元素
	public Object next() {
		MenuItem item = items.get(position);
		return item;
	}

}

    建立好迭代器后，改写披萨餐厅的代码，建立一个PizzaMenuIterator，并返回给客户：

public class PizzaHouseMenu {
	static final int MAX_ITEMS = 2;
	int numberOfItems = 0;
	MenuItem[] menuItems;

	public PizzaHouseMenu() {
		menuItems = new MenuItem[MAX_ITEMS];
		addItem("披萨1号", "素食披萨", true, 4.99);
		addItem("披萨2号", "海鲜蛤蜊披萨", true, 5.99);
	}

	public void addItem(String name, String description, boolean vegetarian, double price) {
		MenuItem menu = new MenuItem(name, description, vegetarian, price);
		if (numberOfItems >= MAX_ITEMS)
			System.out.println("对不起，菜单数量已满");
		else
			menuItems[numberOfItems++] = menu;
	}
	
	public Iterator createIterator() {
		return new PizzaIterator(menuItems);
	}
}

import java.util.ArrayList;

public class PancakeHouseMenu {
	ArrayList<MenuItem> menuItems;
	
	public PancakeHouseMenu() {
		menuItems = new ArrayList<MenuItem>();
		addItem("煎饼1号", "牛肉煎饼", false, 2.99);
		addItem("煎饼2号", "素食煎饼", true, 1.49);
	}
	
	public void addItem(String name, String description, boolean vegetarian, double price) {
		MenuItem menu = new MenuItem(name, description, vegetarian, price);
		menuItems.add(menu);
	}

	public Iterator createIterator() {
		return new PancakeIterator(menuItems);
	}
}

    咱们再也不须要getMenuItems()方法，而是用createIterator()方法代替，用来从菜单项数组建立一个迭代器，并把他返回给客户，返回迭代器接口。客户不须要知道餐厅菜单使如何实现维护的，也不须要知道迭代器是如何实现的。客户只需直接使用这个迭代器遍历菜单便可。下面修改一下客户类的调用：

public class Waitress {
	PancakeHouseMenu pancake;
	PizzaHouseMenu pizza;
	
	public Waitress(PancakeHouseMenu pancake, PizzaHouseMenu pizza) {
		this.pancake = pancake;
		this.pizza = pizza;
	}
	
	public void printMenu() {
		Iterator pizzaIterator = pizza.createIterator();
		printMenu(pizzaIterator);
		
		Iterator pancakeIterator = pancake.createIterator();
		printMenu(pancakeIterator);
	}
	
	private void printMenu(Iterator iterator) {
		while(iterator.hasNext()) {
			MenuItem menu = (MenuItem)iterator.next();
			System.out.print(menu.getName() + ",价格:");
			System.out.print(menu.getPrice() + ",");
			System.out.print(menu.getDescription() + "\n");
		}
	}
}
public class Client {
	public static void main(String[] args) {
		PancakeHouseMenu pancake = new PancakeHouseMenu();
		PizzaHouseMenu pizza = new PizzaHouseMenu();
		
		Waitress waitress = new Waitress(pancake, pizza);
		waitress.printMenu();
	}
}

    到目前为止，咱们将客户调用与餐厅的菜单数据接口解耦了，客户调用不再用为每个不一样数据结构的菜单编写一套遍历的代码了。

咱们有些什么……

    咱们如今使用一个共同的迭代器接口(Iteraotr)实现了两个具体类(PizzaIterator和PancakeIterator)。这两个具体类都实现了各自的hasNext()方法和next()方法。

    而后再PancakeHouseMenu和PizzaHouseMenu两个类中，建立一个createIterator()方法返回各自的迭代器，在Waitress类中，使用这两个餐厅对象返回的迭代器打印菜单。这时Waitress类和Client类不再须要关心存放菜单的数据结构，之关心能从迭代器中得到菜单就好。

    迭代器模式给你提供了一种方法，能够顺序访问一个汇集对象的元素，而又不用知道内部是如何表示的。你已经在前面的两个菜单实现中看到了这一点。在设计中使用迭代器的影响是明显的：若是你有一个统一的方法访问聚合中的每个对象，你就能够编写多态的代码和这些聚合搭配，使用如同前面的printMenu()方法同样，只要有了迭代器这个方法根本不用管菜单到底是由数组仍是集合或者其余的数据结构来保存的。

    另一个对你的设计形成重要影响的，是迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象。这不只让聚合的接口和实现变得更简洁，也可让聚合更专一它所应该专一的事情上面，而没必要去理会遍历的事情。

    让咱们检查类图，未来龙去脉拼凑出来……

    先看看Aggregate接口，有一个共同的接口提供全部的聚合使用，这对客户代码是很方便的，将客户代码从集合对象的实现解耦。

    接下来看看ConcreteAggregate类，这个具体聚合持有一个对象的集合，并实现一个方法，利用此方法返回集合的迭代器。每个具体聚合都要负责实例化一个具体的迭代器，次迭代器可以便利对象集合。

    接下来是Iterator接口，这是全部迭代器都必须实现的接口，它包含一些方法，利用这些方法能够在集合元素之间游走。你能够本身设计或者使用java.util.Iterator接口。

    最后是具体的迭代器，负责遍历集合。

单一职责

    若是咱们容许咱们的聚合实现他们内部的集合，以及相关的操做和遍历的方法，又会如何？咱们已经知道这回增长聚合中的方法个数，但又怎么样呢？为何这么作很差？

    想知道为何，首选须要认清楚，当咱们容许一个类不但要完成本身的事情，还同时要负担更多的责任时，咱们就给这个类两个变化的缘由。若是这个集合变化的话，这个类也必需要改变，若是咱们遍历的方式改变的话，这个类也必须跟着改变。因此，引出了设计原则的中心：

单一职责

一个类应该只有一个引发变化的缘由。

    类的每一个责任都有改变的潜在区域。超过一个责任，意味着超过一个改变区域。这个原则告诉咱们，尽可能让每个类保持单一责任。

    内聚(cohesion)这个术语你应该听过，它用来度量一个类或者模块紧密地达到单一目的或责任。

    当一个模块或一个类被设计成只支持一组相关的功能时，咱们说它具备高内聚；反之，当被设计成支持一组不相关的功能时，咱们说它具备低内聚。

    内聚是一个比单一职责更广泛的概念，但二者其实关系是很密切的。遵照这个原则的类更容易有很高的凝聚力，并且比背负许多职责的低内聚类更容易维护。

    以上就是迭代器模式的一些内容。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程