复合模式内部实现的迭代器模式

Question

我正在做一个设计模式项目，我正在尝试在我的复合基础中实现一个迭代器 class。但问题是我从不知道符号 T 是什么的编译器那里得到错误。我在我的迭代器的接口中使用泛型。

这是我的 Iterator 接口代码：

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

这是我的复合基础代码 class:

abstract class Composite extends Component {

  public Iter<T> makeIter() {
    return new Iter<T>() {
      private Component component = Composite.this;
      private int _count = 0;

      public void first() {
        // position the iterator to the first element
        _count = 0;
      }

      public void next() {
        // advances the current element
        _count += 1;
      }

      public boolean isDone() {
        // returns true if iterator has cycled all the way through
        return _count >= component.getSize();
      }

      public Component currentItem() {
        // returns current item iterator is positioned on
        return component.getChild(_count);
      }
    };
  }

  //abstract primitive methods to implement
  @Override
  public abstract Component getChild(int number);
  @Override
  protected abstract void doAdd(Component part);
  @Override
  protected abstract void doRemove(Component part);


}

组件代码：

abstract class Component {
  //member variables, in this case a reference to parent
  private Component parent = null;
  protected int instanceID = 0;

  //composite methods
  final public Component add(Component part) {
    try {
      // let composites define how children are managed
      doAdd(part);

      // set this Component as the parent of the added part
      part.parent = this;
    } catch(RuntimeException e) {
      throw e;
    }
    return this;
  }

  final public Component remove(Component part) {
    try {
      // let composites define how children are managed
      doRemove(part);

      //remove this Component as the parent of the added parent
      part.parent = null;
    } catch(RuntimeException e) {
      throw e;
    }
    return this;
  }

  protected Component getParent() {
    return parent;
  }

  // Methods that Composites need to Override
  abstract public Iter<T> makeIter();

  public int getSize() {
    return 1;
  }

  public Component getChild(int number) {
    return null;
  }

  protected void doAdd(Component part) {
    throw new RuntimeException("add() not supported");
  }

  protected void doRemove(Component part) {
    throw new RuntimeException("remove() not supported");
  }

  //toString
  final public String toString() {
    return (parent == null) ?
      instanceID + " is the root." :
      instanceID + " is the child of " + parent;
  }
}

这是我收到的错误消息：

Component.java:38: error: cannot find symbol
  abstract public Iter<T> makeIter();
                   ^
  symbol:   class T
  location: class Component
Composite.java:5: error: cannot find symbol
  public Iter<T> makeIter() {

我不是 100% 确定我以正确的方式实现它，但我知道对于这个项目，我们需要在复合基 class 中实现迭代器。非常感谢任何帮助。

Answer 1

Iter<T> 定义了一个通用类型 T，这对于抽象情况来说很好，但是你的 Composite class 使用的是特定类型，Component，需要声明的是：

public Iter<Component> makeIter() {
  return new Iter<Component>() {
    ...
  }
}

你的Component也是如此 class:

abstract public Iter<Component> makeIter();

复合模式内部实现的迭代器模式

Iterator Pattern implemented inside of Composite Pattern

java

design-patterns

iterator

composite