software-architecture-review-4: Programming to Interface (Iterator)

Iter.java

import java.util.*;

public class Iter {
  public static void main(String[] args) {
    Aggregate<Integer, Integer, Integer> ag = new DataList<Integer, Integer, Integer>();
    ((DataList)ag).add(new ThreeD<Integer, Integer, Integer>(1, 2, 3));
    ((DataList)ag).add(new ThreeD<Integer, Integer, Integer>(1, 2, 3));
    ((DataList)ag).add(new ThreeD<Integer, Integer, Integer>(1, 2, 3));
    Iterator<Integer> ia = ag.createIteratorA();
    while (ia.next() != null) {
      System.out.println(ia.currentItem());
    }
    Iterator<Integer> ib = ag.createIteratorB();
    while (ib.next() != null) {
      System.out.println(ib.currentItem());
    }
    Iterator<Integer> ic = ag.createIteratorC();
    while (ic.next() != null) {
      System.out.println(ic.currentItem());
    }
  }
}

class ThreeD<T, V, W> {

  private T t;
  private V v;
  private W w;

  public ThreeD(T t, V v, W w) {
    this.t = t;
    this.v = v;
    this.w = w;
  }

  public T getA() { return t;}
  public V getB() { return v;}
  public W getC() { return w;}
}

interface Aggregate<T, V, W> {
  public Iterator<T> createIteratorA();
  public Iterator<V> createIteratorB();
  public Iterator<W> createIteratorC();
}

interface Iterator<T> {
  public T first();
  public T next();
  public boolean isDone();
  public T currentItem();
}

abstract class IteratorABC<T> implements Iterator<T>{
  protected DataList ag;
  protected int i;
  public IteratorABC(DataList ag) {
    this.ag = ag;
    i = -1;
  }
  public T first() { i = 0; return currentItem();}
  public T next() {i += 1; return currentItem();}
  public boolean isDone() {return i >= ag.size() ;}
  public abstract T currentItem();
}


class IteratorA<T> extends IteratorABC<T>{
  public IteratorA(DataList ag) {
    super(ag);
  }
  public T currentItem() { if (isDone()) return null; return (T)ag.get(i).getA();}
}

class IteratorB<T> extends IteratorABC<T>{
  public IteratorB(DataList ag) {
    super(ag);
  }
  public T currentItem() { if (isDone()) return null; return (T)ag.get(i).getB();}
}

class IteratorC<T> extends IteratorABC<T>{
  public IteratorC(DataList ag) {
    super(ag);
  }
  public T currentItem() { if (isDone()) return null; return (T)ag.get(i).getC();}
}

class DataList<T, V, W> implements Aggregate<T, V, W> {

  private ArrayList<ThreeD<T, V, W>> list = new ArrayList<ThreeD<T, V, W>>();
  private IteratorA<T> ia = new IteratorA<T>(this);
  private IteratorB<V> ib = new IteratorB<V>(this);
  private IteratorC<W> ic = new IteratorC<W>(this);

  public void add(ThreeD<T, V, W> d) { list.add(d); }
  public ThreeD<T, V, W> get(int index) { return list.get(index); }
  public int size() {return list.size();}

  public Iterator<T> createIteratorA() { return ia; }
  public Iterator<V> createIteratorB() { return ib; }
  public Iterator<W> createIteratorC() { return ic; }
}