有一个项目，要求对电视机的电视台频道，电影频道的菜单进行统一管理，建立一个统一的菜单管理界面，能够看到所有的电视台界面和电影界面。该项目由两位开发人员进行开发。
主菜单JavaBean，用于显示每个模块的菜单
public class MenuItem {
//频道号
private int channel;
//名称
private String name;
//描述
private String description;
//省略无参构造、代参构造，各个属性的setter和getter方法
}
人员一负责电视台频道菜单的实现，他使用List实现，他认为这样可方便的扩展菜单
public class TvChannelMenu {
List<MenuItem> menuItems;
//构造函数初始化
public TvChannelMenu() {
menuItems = new MenuItem();
addItem(1,"CCTV1","中央电视台综合频道");
addItem(2,"CCTV3","中央电视台综艺频道");
addItem(3,"CCTV4","中央电视台中文国际频道");
addItem(4,"CCTV6","中央电视台电影频道");
addItem(5,"CCTV9","中央电视台记录频道");
addItem(6,"CCTV10","中央电视台科教频道");
}
//将电视台频道节目添加到菜单集合中
public void addItem(int channel,String name,String description) {
MenuItem menuItem = new MenuItem(channel,name,description);
menuItems.add(menuItem);
}
//获取菜单集合
public List<MenuItem> getMenuItems() {
return menuItems;
}
}
人员二负责电影频道菜单的实现，他使用数组完成，他认为数组的效率要高一些，而且可以控制菜单长度
public class MovieChannelMenu {
//菜单(数组最大长度)
static final int MAX_LENGTH = 6;
int numOfItems = 1;
MenuItem[] menuItems;
//构造函数初始化
public MovieChannelMenu() {
menuItems = new MenuItem[MAX_LENGTH];
addItem(1,"城市猎人","主演：成龙，邱淑贞，王祖贤");
addItem(2,"超级警察","主演：成龙，元华，杨紫琼");
addItem(3,"功夫","主演：周星驰，梁小龙，陈国坤");
addItem(4,"少林寺","主演：李连杰，于承惠，计春华");
addItem(5,"大内密探零零狗","主演：古天乐，吴君如，樊少皇");
addItem(6,"X战警","主演：休杰克曼，伊恩麦克莱恩，帕特里克斯图尔特");
}
//将电影频道添加到菜单中
public void addItem(int channel,String name,String description) {
MenuItem menuItem = new MenuItem(channel,name,description);
//判断数组是否越界
if(numOfItems < MEX_LENGTH) {
menuItems[numOfItems] = menuItem;
} else {
System.out.println("菜单已满！！");
}
}
//获取电影菜单
public MenuItem[] getMenuItems() {
return menuItems;
}
}
当做两个菜单的统一显示时，须调用他们的getMenuItems()方法，来取得各个菜单里面的值，但它们的返回值都不同，要想展示须这样
public class MainMenu {
public void printMenu() {
//打印电视菜单
TvChannelMenu tvChannelMenu = new TvChannelMenu();
List<MenuItem> menuItems = tvChannelMenu.getMenuItems();
System.out.println("电视节目有：");
for(int i = 0;i < menuItems.size();i++) {
MenuItem menuItem = menuItems.get(i);
printMenu(menuItem);
}
System.out.println("==========================");
//打印电影菜单
MovieChannelMenu movieChannelMenu = new MovieChannelMenu();
MenuItem[] menuItems2 = movieChannelMenu.getMenuItems();
System.out.println("电影节目有：");
for(int i = 0;i < menuItems.length;i++) {
MenuItem menuItem = menuItems2[i];
printMenu(menuItem);
}
//打印菜单方法
private void printMenu(MenuItem menuItem) {
System.out.print("频道：" menuItem.getChannel() + "----");
System.out.print("名称：" menuItem.getName() + "----");
System.out.println("描述：" + menuItem.getDescription());
}
}
}
测试类
public class Test {
public static void main(String[] args) {
MainMenu mainMenu = new MainMenu();
mainMenu.printMenu();
}
}
打印结果
从上面的代码可以看出，需要两个循环遍历这些菜单选项。
可以封装遍历，也就是迭代器模式的动机–能够游走于聚合内的每个元素，同时还可以提供多种不同的遍历方式。
概述
迭代器模式(Iterator Pattern)，时Java和.Net编程环境常用的设计模式。该模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。属于行为型模式。
实际开发中，可能需要针对不同的需求，以不同的方式来遍历整个对象，但不希望在聚合对象的抽象接口层中充斥着各种不同的遍历操作。这时，就需要这样一种东西，它应具备如下三个功能：
能够遍历一个聚合对象；
不需要知道聚合对象的内部结构；
能够提供多种不同的遍历方式。
上面三个功能就是迭代器模式需要解决的问题。迭代器模式把在元素间游走的责任交给迭代器，而非聚合对象。这样做就简化了聚合的接口和实现，也可以让聚合更专注于其应该专注的事情上，更加符合单一责任原则。
迭代器模式有如下几个角色
Iterator：抽象迭代器。所有迭代器都需要实现的接口，提供了游走聚合对象元素之间(遍历元素)的方法，一般来说会有三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()和移除当前对象的方法remove()。
ConcreteIterator：具体迭代器。实现抽象迭代器中定义的方法。利用具体迭代器能够对具体的聚合对象进行遍历。每个聚合对象都应对应一个具体迭代器。
Aggregate：抽象聚合类。一般是一个接口，提供一个createIterator()方法，如Java中的Cellection接口，List接口，Set接口等。
ConcreteAggregate：具体聚合类。实现Aggregate中的createIterator()方法，返回该聚合对象的迭代器。如List接口的有序列表实现ArrayList，List接口的链表实现LinkedList，Set接口的哈希列表的实现HashSet等。
实例
利用迭代器模式对上面的案例进行优化整改
定义迭代器接口(抽象迭代器)
public interface Iterator {
boolean hasNext();
Object next();
}
具体迭代器，分别用于遍历电视界面和电影界面
电视频道迭代器
public class TvChannelMenuIterator implements Iterator {
List<MenuItem> menuItems;
int position = 0;
//构造方法
public TvChannelMenuIterator(List<MenuItem> menuItems) {
this.menuItems = menuItems;
}
//判断是否还有下一元素
public boolean hasNext() {
if(position > menuItems.size() -1 || menuItems.get(position) == null) {
return false;
} else {
return true;
}
}
//获取下一元素
public Object next() {
return menuItems.get(position++);
}
}
电影频道迭代器
public class MovieChennelIterator implements Iterator {
MenuItem[] menuItems;
int position = 0;
//构造方法
public MovieChannelIterator(MenuItem[] menuItems) {
this.menuItems = menuItems;
}
//是否还有下个元素
public boolean hasNext() {
if(position > menuItems.length -1 || menuItems[position] == null) {
return false;
} else {
return true;
}
}
//获取下一元素
public Object next() {
return menuItems[position++];
}
}
两个具体聚合类TvChannelMenu和MovieChannelMenu实现菜单接口，在类中实现createIterator()方法
TvChannelMenu类中，其他不变，新增createIterator()方法
public Iterator createIterator() {
return new TvChannelIterator(menuItems);
}
MovieChannelMenu类中，其他不变，新增createIterator()方法
public Iterator createIterator() {
return new MovieChannelIterator(menuItems);
}
主菜单类，用于遍历、显示所有的电视、电影界面
public class MainMenu {
TvChannelMenu tvChannelMenu;
MovieChannelMenu movieChannelMenu;
//构造方法
public MainMenu(TvChannelMenu tvChannelMenu,MovieChannelMenu movieChannelMenu) {
this.tvChannelMenu = tvChannelMenu;
this.movieChannelMenu = movieChannelMenu;
}
public void printMenu() {
Iterator tvIterator = tvChannelMenu.createIterator();
Iterator movieIterator = movieChannelMenu.createIterator();
System.out.println("电视节目有：");
printMenu(tvIterator);
System.out.println("---------------------");
System.out.println("电影节目有：");
printMenu(movieIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext) {
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print("频道：" + menuItem.getChannel() + "----");
System.out.print("频道名称：" + menuItem.getName() + "----");
System.out.println("频道描述：" + menuItem.getDescription());
}
}
}
测试类
public class IteratorPatternDemo {
public static void main(String[] args) {
TvChannelMenu tvChannelMenu = new TvChannelMenu();
MovieChannelMenu movieChannelMenu = new MovieChannelMenu();
MainMenu mainMenu = new MainMenu(tvChannelMenu,movieChannelMenu);
mainMenu.printMenu();
}
}
打印结果
总结
优点：支持以不同的方式遍历一个聚合对象；迭代器简化了聚合类；在同一个聚合上可有多个遍历；增加新的聚合类和迭代器类都很方便，无须修改原有代码。
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类须增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统复杂性。
使用场景：方法一个聚合对象的内容而无需暴露其内部表示；需要为聚合对象提供多种遍历方式；为遍历不同的聚合结构提供一个统一的接口。
将遍历聚合对象中数据的行为分离出来，封装到一个迭代器中，通过专门的迭代器来遍历聚合对象的内部数据，这就是迭代器模式的本质。该模式是"单一职责原则"的经典体现。
迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器来负责，这样既可以做到不暴露集合内部结构，又可让外部代码透明的访问集合内部数据。
使用迭代器时，依赖聚合提供遍历。
一般来说，只要实现一个集合，就需同时提供该集合的迭代器，像java中的Collection、List、Set、Map等，这些集合都有自己的迭代器。
抽象迭代器设计难度较大，需充分考虑到系统将来的扩展，如JDK内置迭代器Iterator就无法实现逆向遍历，若需实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator无法用于Set类型的聚合对象，在自定义迭代器时，创建一个考虑全面的抽象迭代器不是件容易的事。
扫一扫
3414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
