Question

我正在开发一个Design Patterns项目，我正在尝试在我的复合基类中实现一个迭代器。但问题是我从编译器得到错误而不知道符号T是什么。我在迭代器的界面中使用泛型。

以下是Iterator界面的代码：

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

这是我的Composite基类代码：

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％确定我是以正确的方式实现它，但我知道对于项目我们需要在复合基类中实现迭代器。非常感谢任何帮助。

Answer 1

Iter<T>定义了一个通用类型T，它适用于抽象情况，但您的Composite类使用的是特定类型Component，需要宣称：

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

Component课程同样如此：

abstract public Iter<Component> makeIter();

迭代器模式在复合模式

1 个答案: