Menu
Looking into another question I bumped into this intriguing behavior of the 1.8.0_112 Sun-Oracle compiler (I have not tested with others):
import java.util.List;
interface Alpha<T> {
List<Integer> intList();
}
interface Beta {
List<Integer> intList();
}
class Main {
public static void main(String[] args) {
Alpha rawAlpha = null;
Alpha<Character> charAlpha = null;
Alpha<?> qmAlpha = null;
Beta beta = null;
for (Integer i : charAlpha.intList()) {}
for (Integer i : qmAlpha.intList()) {}
for (Integer i : beta.intList()) {}
for (Integer i : rawAlpha.intList()) {}
}
}
The compiler only fails at the last for loop:
error: incompatible types: Object cannot be converted to Integer
for (Integer i : rawAlpha.intList()) {}
^
1 error
So despite that intList() return list type List<Integer> in Alpha does not depend on the type parameter T, it seems that the <Integer> is erased at compilation time.
Notice that if we declare a non-generic interface Beta that would be, in theory, equivalent to making reference to the raw Alpha, there is no issues.
Is this the expected behavior? can some one point out the paragraph on the language spec that would cover this point? If this is not a bug at the very least it seem rather anti-intuitive and non-productive; perhaps is done for the sake of back-comparability?.
591
The warning shows that raw types bypass generic type checks, deferring the catch of unsafe code to runtime. Therefore, you should avoid using raw types. The Type Erasure section has more information on how the Java compiler uses raw types.
In summary, raw types should NEVER be used in new code. You should always use parameterized types.
A raw type is a name for a generic interface or class without its type argument: List list = new ArrayList(); // raw type. Instead of: List<Integer> listIntgrs = new ArrayList<>(); // parameterized type. List<Integer> is a parameterized type of interface List<E> while List is a raw type of interface List<E>.
The JLS bit that says this (a bit unclearly) is in JLS 4.8:
The type of a constructor (§8.8), instance method (§8.4, §9.4), or non-static field (§8.3) of a raw type C that is not inherited from its superclasses or superinterfaces is the raw type that corresponds to the erasure of its type in the generic declaration corresponding to C.
So, since rawAlpha is a raw type, the type of rawAlpha.intList is the erasure of List<Integer> intList(). That erasure is List intList().
As for why, I don't have a citation handy, but raw types are only really in Java for backwards compatibility. That means they only need to work as well as they did before generics; what you're asking for is for code that works just a little bit better that it used to. It's not unreasonable, but it's not what they decided on. :-)
134
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
