将Collection和Iterator接口作为内部类实现

Question

I'm trying to implement a Collection interface with Iterator as inner class. An ArrayCollection class that implements collection has a generic array (is it a correct way to say that class members are generic?). a screenshot from IDE

public class ArrayCollection<T> implements Collection<T> {
private T[] m = (T[])new Object[10];

However when I'm implementing method next() for an Iterator interface I keep getting an Incompatible types error. However if make an ArrayIterator a non-generic class compiler doesn't have problems with array typecasting anymore. an error screenshot from IDE

    private class ArrayIterator<T> implements Iterator<T> {
    private int cursor = 0;

    @Override
    public boolean hasNext() {
        return this.cursor >= ArrayCollection.this.size();
    }

    @Override
    public T next() {
       return ArrayCollection.this.m[cursor++];
    }
}

So I have few questions:

1. How come the compiler can define the T[] m array type if I make an ArrayIterator non-generic?

2. Is it only the inner classes that implement/extend generic interfaces/classes can be non-generic?

Answer 1

You named your type variables similarly, ArrayIterator<T> has a different T than ArrayCollection<T> 's T is.

You can just remove the <T> from ArrayIterator (since it is a non-static inner class) and just have Iterator use the T from the parent class:

    private class ArrayIterator implements Iterator<T> {

This will fix the compile issue and your code.

Answer 2

In the second example, you are dealing with two different type variables. The outer class and the inner class each define a variable T , but they are not the same. There are several ways to solve this, one is to remove the T from the inner class declaration:

private class ArrayIterator implements Iterator<T> {

Now you are referencing the outer T only, without introducing a separate inner T

However, I would personally prefer to make the inner class static, in which case you can't use the outer type's variables. In this case you'd write

private static class ArrayIterator<T> implements Iterator<T> {

If you do this, you need to pass the type variable from the outer type to the inner:

return new ArrayIterator<T>();

The main difference is that a class that defines a type parameter shadows any existing type parameter of the same name, which leads to that strange error message.

Finally let me add that it's usually not a good idea to implement a Collection from scratch. Instead, you might want to extend AbstractCollection or AbstractList . This will let you focus on your core algorithm, but provide you with all the boilerplate methods for free.