Question

I have an interface for a variety of classes, all of which should implement Iterator, so I have something like

public interface A extends Iterable<A> { ...otherMethods()... }

For the concrete classes, however, this means I must use

public class B implements A { public Iterator<A> iterator() {...} }

when I’d prefer (or at least, think I’d prefer) to use public Iterator<B> iterator() {...} so that concrete use of the class could have the explicit type (in case I wanted methods that weren’t in the interface to be available, or some such. Maybe that should never come up? Or it’s poor design if it does?

The flipside is that using the Iterator interface

public interface A extends Iterator<A> { ...otherMethods()... }

the concrete classes compile just fine with

public class B implements A { public B next() {...} }

What gives?

Answer 1

The concrete class compiles fine because B extends A, and since Java 5 a return type on a subclass can be a subclass of the return type on the superclass.

As for the generic, I have hit the same wall, and you have two options that I know of.

One is to paramaterize A:

 public interface A<T extends A> extends Iterable<T>

then:

public class B implements A<B>

However, that has a disadvantage that you will need to give a parameter of A, instead of having it fixed, even if you want A:

private class NoOneSees implements A<A>

As to the question of if you actually want Iterator<B>, in the case of an Iterable, most likely that is preferable, and considering that these are interfaces, the need to redeclare the parameter is probably reasonable. It gets a little more complicated if you start inheriting concrete classes, and for things that have meaning other than an Iterable, where you may want covariance. For example:

public interface Blah<T> {
    void blah(T param);
}

public class Super implements Blah<Super> {
    public void blah(Super param) {}
}

public class Sub extends Super {
    public void blah(Super param) {}
   //Here you have to go with Super because Super is not paramaterized
   //to allow a Sub here and still be overriding the method.
}

Similarly for covariance, you can’t declare a variable of type Iterator<A> and then assign an Iterator<B> in it, even if B extends A.

The other option is live with the fact that further implementation/subclasses will still reference A.