Why Does Using a Raw Type for a List Reference Prevent Generic Method Usage?

Combining Raw Types and Generic Methods

Consider the following code snippet:

ArrayList<String> a = new ArrayList<String>();
String[] s = a.toArray(new String[0]);

This code compiles successfully in both Java 6 and 7. However, if the List reference is declared as a raw type:

ArrayList a = new ArrayList();
String[] s = a.toArray(new String[0]);

It results in a compiler error, stating that String[] is required but Object[] was found. This behavior is unexpected, given that the toArray method signature is:

<T> T[] toArray(T[] a);

which indicates that the method is parameterized and its type parameter has no relation to that of the List.

To understand why this code does not compile, it is important to note that using a raw type for an instance reference invalidates the ability to use generics for any of its instance members. This behavior is not limited to generic methods, as illustrated by the following snippet:

public class MyContainer<T> {
    public List<String> strings() {
        return Arrays.asList("a", "b");
    }
}

MyContainer container = new MyContainer<Integer>();
List<String> strings = container.strings(); // This line will produce an unchecked warning!

This restriction is specified in the Java Language Specification (4.8):

"The type of a constructor, instance method, or non-static field 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."

The above is the detailed content of Why Does Using a Raw Type for a List Reference Prevent Generic Method Usage?. For more information, please follow other related articles on the PHP Chinese website!