提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。
类图
实现
1
2
3
4
5
| public interface Aggregate<E> {
public Iterator<E> createIterator();
}
|
1
2
3
4
5
6
7
| public interface Iterator<E> {
public boolean hasNext();
public E next();
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| import java.util.ArrayList;
import java.util.List;
public class ConcreteAggregate implements Aggregate<Object> {
private List<Object> items = new ArrayList<>();
public void add(Object item) {
items.add(item);
}
public Object get(int index) {
return items.get(index);
}
public int size() {
return items.size();
}
@Override
public Iterator<Object> createIterator() {
return new ConcreteIterator(this);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| public class ConcreteIterator implements Iterator<Object> {
private ConcreteAggregate aggregate;
private int index = 0;
public ConcreteIterator(ConcreteAggregate aggregate) {
this.aggregate = aggregate;
}
@Override
public boolean hasNext() {
if (index >= aggregate.size()) {
return false;
}
return true;
}
@Override
public Object next() {
return aggregate.get(index++);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class Client {
public static void main(String[] args) {
ConcreteAggregate aggregate = new ConcreteAggregate();
aggregate.add(1);
aggregate.add(2);
aggregate.add(3);
Iterator<Object> iterator = aggregate.createIterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
|