基于JAVA的设计模式之迭代器模式

• 介绍

　　　　迭代器模式及通过一种顺序访问聚合对象中的内容，不必考虑聚合对象的内部表示。即通过一个接口遍历该聚会对象的所有内容，不用考虑底层实现，是链表还是数组；是delete()还是remove()等等。

　　　　容器角色：一个定义标准的接口，List、Set。

　　　　具体容器角色：具体底层实现，LinkedList链表具体实现，ArrayList数组具体实现。#示例代码以数组实现，且内置元素为自定义对象，因此以泛型与反射底层实现

　　　　迭代器角色：next()、hasNext()

　　　　具体迭代器角色

• 类图

　　

• 代码

public interface Iterator<T>{
    public T Next();
    public boolean hasNext();
}

public class ConcreteIterator<T> implements Iterator<T> {
    private Aggregate<T>list;
    private int index;
    public ConcreteIterator(Aggregate<T>list){
        this.list=list;
        index=0;
    }
    public T Next() {
        return list.get(index++);
    }

    public boolean hasNext() {
        if(index>=list.size()){
            return false;
        }else{
            return true;
        }
    }
}

public interface Aggregate<T> {
    public void add(T object);
    public T get(int index);
    public Iterator<T>iterator();
    public int size();
}

import java.lang.reflect.Array;

public class ConcreteAggregate<T>implements Aggregate<T> {
    private T[] list;
    private int size=0;
    private int index=0;
    public ConcreteAggregate(Class<T> type, int size){
        list=(T[]) Array.newInstance(type,size);
    }
    public void add(T object) {
        list[index++]=object;
        size++;
    }

    public T get(int index) {
        return list[index];
    }

    public Iterator<T> iterator() {
        return new ConcreteIterator<T>(this);
    }

    public int size() {
        return size;
    }
}

public class Main {
    public static void main(String[] args) {
        Aggregate<Item>television=
                new ConcreteAggregate<Item>(Item.class,10);
        television.add(new Item("CCTV1"));
        television.add(new Item("天津卫视"));
        television.add(new Item("金鹰卡通"));
        television.add(new Item("卡酷动画"));
        Iterator<Item>iterator=television.iterator();
        while(iterator.hasNext()){
            Item item=iterator.Next();
            System.out.println(item.getName());
        }
    }
}