Question

I have a class with the following definition:

public abstract class A<T> implements Iterator<B> {}

The following call to next() will return an Object rather than a B:

A a = new SomethingThatExtendsA();
B b = a.next();

I’ve searched for quite awhile and haven’t been able to figure out why this next() call fails to compile. Is anyone able to describe this behavior for me?

Edited original to be templated, as this seems to matter.

Edit for additional clarification: This is a compile-time issue, not a runtime issue. The implementation of SomethingThatExtendsA(); should be irrelevant in this case at compile-time.

Answer 1

So we have this code:

public abstract class A<T> implements Iterator<B> {}
[...]
A a = new SomethingThatExtendsA();
a.next();

A is a generic type, but you have defined a with a raw type. Ignore the right hand side of the =, we are only interested in the static type:

A/*<Something>*/ a = ...;

The compiler should give you warnings here. (At least relatively recent versions of javac will do – rawtypes warning in Oracle javac.) Take notice of your compiler’s warnings. (Wasn’t it nice when javac didn’t give warnings?)

So now we are in a situation that a has a type that is both raw and is a Iterator<B>. This is a really confusing situation with just mind-blowingly difficult implications. We shouldn’t even be doing this – we should be avoiding mixing generic and raw types. So the Java Language Specification takes the simple way out and discards the partial generic type information.

So, don’t mix raw and generic types. Just use all generics and you should be fine.