迭代器模式:
有许多方法可以把对象堆起来成为一个集合(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模板网!