【设计模式】—— 迭代模式Iterator

　　前言：【模式总览】——————————by xingoo

　　模式意图

　　提供一个方法按顺序遍历一个集合内的元素，而又不需要暴露该对象的内部表示。

　　应用场景

　　1 访问一个聚合的对象，而不需要暴露对象的内部表示

　　2 支持对聚合对象的多种遍历

　　3 对遍历不同的对象，提供统一的接口。

　　模式结构

　　Iterator 定义访问的接口

/**
 * 抽象的迭代，有判断结束和下一个，获取当前元素等函数
 * @author xingoo
 *
 */
interface Iterator{
    void first();
    void next();
    boolean isDone();
    Object currentItem();
}

　　ConcreteIterator 具体的迭代器，跟踪聚合内的元素

/**
 * 具体的迭代类
 * @author xingoo
 *
 */
class ConcreteIterator implements Iterator{
    private ConreteAggregate agg;
    private int index = ;
    private int size = ;

    public ConcreteIterator(ConreteAggregate agg) {
        this.agg = agg;
        size = agg.size();
        index = ;
    }

    public void first() {
        index = ;
    }

    public void next() {
        if(index < size){
            index++;
        }
    }

    public boolean isDone() {
        return (index >= size);
    }

    public Object currentItem() {
        return agg.getElement(index);
    }

}

　　Aggregate 提供聚合的接口

/**
 * 聚合的类
 * @author xingoo
 *
 */
abstract class Aggregate{
    public Iterator createIterator(){
        return null;
    }
}

　　ConcreteAggregate 具体的聚合

/**
 * 具体的聚合对象，拥有大小，创建迭代子等函数
 * @author xingoo
 *
 */
class ConreteAggregate extends Aggregate{
    private Object[] obj = {"test1","test2","test3","test4"};
    public Iterator createIterator(){
        return new ConcreteIterator(this);
    }
    public Object getElement(int index){
        if(index < obj.length){
            return obj[index];
        }else{
            return null;
        }
    }
    public int size(){
        return obj.length;
    }
}

　　全部代码

 package com.xingoo.Iterator;
 /**
  * 聚合的类
  * @author xingoo
  *
  */
 abstract class Aggregate{
     public Iterator createIterator(){
         return null;
     }
 }
 /**
  * 抽象的迭代，有判断结束和下一个，获取当前元素等函数
  * @author xingoo
  *
  */
 interface Iterator{
     void first();
     void next();
     boolean isDone();
     Object currentItem();
 }
 /**
  * 具体的聚合对象，拥有大小，创建迭代子等函数
  * @author xingoo
  *
  */
 class ConreteAggregate extends Aggregate{
     private Object[] obj = {"test1","test2","test3","test4"};
     public Iterator createIterator(){
         return new ConcreteIterator(this);
     }
     public Object getElement(int index){
         if(index < obj.length){
             return obj[index];
         }else{
             return null;
         }
     }
     public int size(){
         return obj.length;
     }
 }
 /**
  * 具体的迭代类
  * @author xingoo
  *
  */
 class ConcreteIterator implements Iterator{
     private ConreteAggregate agg;
     private int index = ;
     private int size = ;

     public ConcreteIterator(ConreteAggregate agg) {
         this.agg = agg;
         size = agg.size();
         index = ;
     }

     public void first() {
         index = ;
     }

     public void next() {
         if(index < size){
             index++;
         }
     }

     public boolean isDone() {
         return (index >= size);
     }

     public Object currentItem() {
         return agg.getElement(index);
     }

 }
 /**
  * 客户端 使用方法
  * @author xingoo
  *
  */
 public class Client {
     private Iterator it;
     private Aggregate agg = new ConreteAggregate();
     public void operation(){
         it = agg.createIterator();
         while(!it.isDone()){
             System.out.println(it.currentItem().toString());
             it.next();
         }
     }
     public static void main(String[] args) {
         Client client = new Client();
         client.operation();
     }
 }

　　运行结果

test1
test2
test3
test4