软件设计模式与体系结构 实验九 迭代器模式
【实验内容和要求】
某软件公司为某商场开发了一套销售管理系统,在对该系统进行分析和设计时,开发人员发现经常需要对系统中的商品数据、客户数据等进行遍历,为了复用这些遍历代码,开发人员设计了一个抽象的数据集合类AbstractObjectList,将存储商品和客户等数据的类作为其子类,AbstractObjectList类结构如下图所示:
在图中,List类型的对象objects用于存储数据,其方法与说明如下表所示:
AbstractObjectList类的子类ProductList和CustomerList分别用于存储商品数据和客户数据。
现使用迭代器模式设计该销售管理系统。
用JAVA语言实现 (或C#控制台应用程序实现)。绘制该模式的UML图。
一、实验目的:
1) 掌握迭代器模式(Iterator)的特点
2) 分析具体问题,使用迭代器模式进行设计。
二、实验环境:
Eclipse
【模式UML图】
三、实验内容:
public interface AbstractIterator {
public void next();//移至下一个元素
public boolean isLast();//判断是否为最后一个元素
public void previous();//移至上一个元素
public boolean isFirst();//判断是否为第一个元素
public Object getNextItem();//获取下一个元素
public Object getPreviousItem();//获取上一个元素
}
import java.util.List;
public class ProductIterator implements AbstractIterator {
private ProductList productList;
private List products;
private int cursor1;//定义一个游标用于记录正向遍历位置
private int cursor2;//定义一个游标用于记录逆向遍历位置
public ProductIterator(ProductList list) {
this.productList = list;
this.products = list.getObjects();//获取集合对象
cursor1 = 0;//设置正向遍历游标的初始值
cursor2 = products.size()-1;//设置逆向游标的初始值
}
@Override
public void next() {
if(cursor1 < products.size()){
cursor1++;
}
}
@Override
public boolean isLast() {
return (cursor1 == products.size());
}
@Override
public void previous() {
if(cursor2 > -1){
cursor2--;
}
}
@Override
public boolean isFirst() {
return (cursor2 == -1);
}
@Override
public Object getNextItem() {
return products.get(cursor1);
}
@Override
public Object getPreviousItem() {
return products.get(cursor2);
}
}
import java.util.List;
public class CustomerIterator implements AbstractIterator {
private CustomerList customerList;
private List customers;
private int cursor1;//定义一个游标用于记录正向遍历位置
private int cursor2;//定义一个游标用于记录逆向遍历位置
public CustomerIterator(CustomerList list) {
this.customerList = list;
this.customers = list.getObjects();//获取集合对象
cursor1 = 0;//设置正向遍历游标的初始值
cursor2 = customers.size()-1;//设置逆向游标的初始值
}
@Override
public void next() {
if(cursor1 < customers.size()){
cursor1++;
}
}
@Override
public boolean isLast() {
return (cursor1 == customers.size());
}
@Override
public void previous() {
if(cursor2 > -1){
cursor2--;
}
}
@Override
public boolean isFirst() {
return (cursor2 == -1);
}
@Override
public Object getNextItem() {
return customers.get(cursor1);
}
@Override
public Object getPreviousItem() {
return customers.get(cursor2);
}
}
import java.util.ArrayList;
import java.util.List;
//抽象聚合类
abstract class AbstractObjectList {
protected List<Object> objects = new ArrayList<Object>();
public AbstractObjectList(List objects){
this.objects = objects;
}
public void addObject(Object obj){
this.objects.add(obj);
}
public void removeObject(Object obj){
this.objects.remove(obj);
}
public List getObjects(){
return this.objects;
}
public abstract AbstractIterator createIterator();
}
import java.util.List;
//客户数据类:具体聚合类
public class CustomerList extends AbstractObjectList {
public CustomerList(List customers) {
super(customers);
}
@Override
public AbstractIterator createIterator() {
return new CustomerIterator(this);
}
}
import java.util.List;
//商品数据类:具体聚合类
public class ProductList extends AbstractObjectList {
public ProductList (List products){
super(products);
}
@Override
public AbstractIterator createIterator() {
// TODO Auto-generated method stub
return new ProductIterator(this);
}
}
import java.util.ArrayList;
import java.util.List;
public class Client {
public static void main(String[] args) {
List products = new ArrayList();
products.add("倚天剑");
products.add("屠龙刀");
products.add("断肠草");
products.add("葵花宝典");
products.add("四十二章经");
AbstractObjectList list;
AbstractIterator iterator;
list = new ProductList(products);
iterator = list.createIterator();
System.out.println("正向遍历:");
while(!iterator.isLast()){
System.out.print(iterator.getNextItem()+",");
iterator.next();
}
System.out.println();
System.out.println("------------------------------------");
System.out.println("逆向遍历");
while(!iterator.isFirst()){
System.out.print(iterator.getPreviousItem()+",");
iterator.previous();
}
}
}
【运行截图】
四、心得体会:
通过本次实验,学会了使用迭代器模式。迭代器模式的适用性如下:
1)访问一个聚合对象的内容而无须暴露它的内部表示。
2)需要为聚合对象提供多种遍历方式。
3)为遍历不同的聚合结构提供一个统一的接口。