patrón de diseño (10) - el modo iterativo

Iterator modo (Iterator) proporciona un método secuencial para cada elemento de un objeto polimérico, sin mostrar el interior de la misma está expuesta.

Si usted tiene un método uniforme para acceder a la polimerización de cada objeto, puede escribir código polimórfico y estos polimerización con el uso. el modo iterativo entre los elementos de la responsabilidad de la migración de los iteradores, en lugar de los objetos agregados. Esto no sólo permite la agregación de la interfaz y la implementación vuelto más concisa, sino que también permite la polimerización se centre más en las cosas de arriba, debemos centrarnos en (es decir, una colección de objetos gestionados) sin tener que atravesar para ignorar cosas.

A continuación con referencia a un ejemplo específico se describirá.

Hemos simulado un restaurante, una crepería y una cafetería, ahora queremos que los clientes en el mismo lugar y al mismo tiempo ser capaz de señalar el plato tres restaurantes.

En la implementación menú original, el menú del restaurante con 数组los elementos de menú registrados, menú crepería con ArrayListelementos de menú registrados, mientras que la cafetería con un menú Hashtablea la opción del menú de grabación.

Se extrajo la interfaz de menú

import java.util.Iterator;

public interface Menu {
	public Iterator createIterator();
}

elemento de menú clase es

public class MenuItem {
	String name;
	String description;
	boolean vegetarian;
	double price;
 
	public MenuItem(String name, 
	                String description, 
	                boolean vegetarian, 
	                double price) 
	{
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}
  
	public String getName() {
		return name;
	}
  
	public String getDescription() {
		return description;
	}
  
	public double getPrice() {
		return price;
	}
  
	public boolean isVegetarian() {
		return vegetarian;
	}
}

Tenemos que crear una versión Java de la camarera, ella tiene que ser capaz de responder a la necesidad del cliente para imprimir menús personalizados, e incluso le dirá si es un elemento de menú vegetariano, sin tener que pedir el chef.

Tenemos que encontrar una manera de dejar que estos menús de restaurantes lograr una misma interfaz. En el artículo anterior mencionado, tenemos un importante principio de diseño es parte del paquete de cambios . Claramente, los cambios aquí son atravesadas por un conjunto de diferentes tipos causados. Necesitamos la ayuda del iterador para resolver este problema.

el modo iterativo se basa en un iterador interfaz llamada

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

Para la crepería ArrayListmenú y café Hashtablemenú, Java han logrado su iterador por defecto, y para el restaurante de 数组menú, tiene que darse cuenta de que poseemos un iterador:

import java.util.Iterator;
  
public class DinerMenuIterator implements Iterator {
	MenuItem[] list;
	int position = 0;
 
	public DinerMenuIterator(MenuItem[] list) {
		this.list = list;
	}
 
	public Object 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;
		}
	}
}

Los correspondientes implementadas como los menús de restaurantes

import java.util.Iterator;

public class DinerMenu implements Menu {
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;
  
	public DinerMenu() {
		menuItems = new MenuItem[MAX_ITEMS];
 
		addItem("Vegetarian BLT",
			"(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
		addItem("BLT",
			"Bacon with lettuce & tomato on whole wheat", false, 2.99);
		addItem("Soup of the day",
			"Soup of the day, with a side of potato salad", false, 3.29);
		addItem("Hotdog",
			"A hot dog, with saurkraut, relish, onions, topped with cheese",
			false, 3.05);
		addItem("Steamed Veggies and Brown Rice",
			"A medly of steamed vegetables over brown rice", true, 3.99);
		addItem("Pasta",
			"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
			true, 3.89);
	}
  
	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;
			numberOfItems = numberOfItems + 1;
		}
	}
 
	public MenuItem[] getMenuItems() {
		return menuItems;
	}
  
	public Iterator createIterator() {
		return new DinerMenuIterator(menuItems);
		//return new AlternatingDinerMenuIterator(menuItems);
	}
 
	// other menu methods here
}

Principios de diseño - Principio de Responsabilidad Individual

Si permitimos que podamos lograr el conjunto de la polimerización dentro de ellos, así como las operaciones y métodos para atravesar relacionados, por lo que no sólo permite a una clase completa su propia cosa (una especie de polimerización), también al mismo tiempo para dar más responsabilidad (por ejemplo, de recorrido), nos dio dos razones para este tipo de cambio:

• Si cambia esta colección, entonces esta clase debe cambiar con él
• Si se recorre el camino del cambio, esta categoría también debe cambiar con él

Por lo tanto, nuestro viejo amigo "cambio", ha vuelto a ser el centro de nuestros principios de diseño - el único principio de responsabilidad: una clase debe ser sólo una de las razones para cualquier cambio.