When working with generics in Java, it's important to understand the implications of using raw types. A raw type is simply a reference to a generic type without any type parameters specified.
The Problem
Consider the following code:
ArrayList<String> a = new ArrayList<>(); String[] s = a.toArray(new String[0]);
This code compiles successfully because toArray is a generic method that accepts an array of type
ArrayList a = new ArrayList(); String[] s = a.toArray(new String[0]);
The compiler will generate an error, indicating that a String[] is required but an Object[] was found. This is because the compiler interprets the generic method as returning Object[] despite receiving String[] as its argument.
Understanding Raw Types
To understand this behavior, it's crucial to realize that when you use a raw type, you lose the ability to specify type parameters. The Java Language Specification (JLS) states that for a raw type:
"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."
In other words, all generic methods and fields within a raw type are treated as if they were declared with raw types themselves.
Implications for Generic Methods
This means that when you use a raw type as the target of a generic method call, the compiler cannot infer the type parameter of the method. As a result, the method will be assumed to be generic only over the type parameter of the argument. In our case, since we passed a String[] argument, the toArray method is treated as
References for Further Reading
The above is the detailed content of Why does using raw types with generic methods lead to type errors in Java?. For more information, please follow other related articles on the PHP Chinese website!