Java通用类型推断奇怪的行为？

Question

Can someone explain this behaviour to me:

Note: That T is never used in SomeThingGeneric

   public static class SomeThingGeneric<T> {
        public List<String> getSomeList() {
            return null;
        }
    }

final SomeThingGeneric<Object> someThingGenericObject = new SomeThingGeneric<Object>();
final SomeThingGeneric<?> someThingGenericWildcard    = new SomeThingGeneric<Object>();
final SomeThingGeneric someThingGenericRaw            = new SomeThingGeneric<Object>();

for (final String s : someThingGenericObject.getSomeList()) { }   // 1 - compiles
for (final String s : someThingGenericWildcard.getSomeList()) { } // 2 - compiles
for (final String s : someThingGenericRaw.getSomeList()) { }      // 3 - does not compile!

(1) and (2) compiles but (3) fails with following message:

incompatible types
found   : java.lang.Object
required: java.lang.String

If anyone wants the full code, here it is . I have verified this in both Java 5 and 6.

Answer 1

Well, this is an interesting question despite the downvotes. I believe the answer to the question lies in this portion of the JLS :

The type of a constructor (§8.8), instance method (§8.4, §9.4), or non-static field (§8.3) M 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.

Effectively, your method public List<String> getSomeList gets an effective signature of public List getSomeList , in the scenario where you accessing it via a raw type. And as such, the list iterator for the resulting list then 'returns' objects instead of strings.

Answer 2

The code can be broken down to the following SSCCE:

public static class SomeThingGeneric<T> {
    public List<String> getSomeList() {
        return null;
    }
}

public static void main(final String[] args) {
    final SomeThingGeneric someThingGenericRaw = new SomeThingGeneric<Object>();
    for (final String s : someThingGenericRaw.getSomeList()) { }        //  SAD compiler.  WTF?
}

This results in the compiler error Type mismatch: cannot convert from element type Object to String .

The question is: why does this error occur? T is not used anywhere in SomeThingGeneric , and especially not in the signature of the getSomeList() method. So, when we call getSomeList() , we should get a List<String> . However, we obviously get a raw List type.

---

The reason is type erasure. From the JLS :

Type erasure also maps the signature (§8.4.2) of a constructor or method to a signature that has no parameterized types or type variables.

And, the definition of a raw type says:

To facilitate interfacing with non-generic legacy code, it is possible to use as a type the erasure (§4.6) of a parameterized type (§4.5) or the erasure of an array type (§10.1) whose element type is a parameterized type. Such a type is called a raw type .

So, when using a raw type , it is the generic type with type erasure applied. When applying type erasure, all method signatures are mapped to types with no type parameters or type variables. Hence, the method List<String> getSomeList() from the example becomes List getSomeList() which results in the shown compiler error.

Answer 3

Answer: When you instantiate a generic type as a raw type, ALL of it's type instantiations are removed, leaving raw types everywhere (even if they don't relate to Type parameters, such as T in your Q). ie raw types are 100% "generics-free".

Reason: backwards compatability with pre-generic code.

Answer 4

For my opinion is a bug. Because it must work. The signature of the method do not use the generic T type. So it must compile.

Mark the entire class as erasure, do not compiling the very well defined generic methods, is not good.

Please report it.