迭代器模式：
有许多方法可以把对象堆起来成为一个集合（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
当你有数个对象的集合，它们彼此之间有“整体/部分”的关系，并且你想用一致的方法对待这些对象时，就可以使用组合模式。文章来源地址https://www.toymoban.com/news/detail-688174.html
到了这里，关于设计模式之九：迭代器与组合模式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
