Why is the `super` keyword restricted to wildcards and not type parameters in Java generics?

Generics Bounding with 'super' Keyword

One might wonder why the super keyword is only applicable to wildcards and not type parameters in Java generics. Consider the following example in the Collection interface, where the toArray method is not declared like this:

interface Collection<t> {
    <s super t> S[] toArray(S[] a);
}</s></t>

This syntax would lead to an illegal declaration, and understanding the reason requires exploring the implications of using super with named type parameters.

The Limitation of 'super' in Type Parameters

Using super to bound a named type parameter () would not achieve the intended effect. Since Object is the ultimate superclass of all reference types, any array of reference type could be cast to an Object[]. This means that even with the hypothetical syntax, the following code would still compile and result in an ArrayStoreException at runtime:

List<integer> integerList;
integerList.toArray(new String[0]);  // should be disallowed, but compiles</integer>

Therefore, super is not allowed with named type parameters to prevent the illusion of enforcement that cannot be guaranteed.

Generics and Arrays: A Complex Relationship

Another aspect to consider is the complex interaction between generics and arrays. In Java, arrays are treated differently from other collection types, leading to limitations in enforcing type safety. This explains why generic type bounds cannot prevent ArrayStoreException in the given example.

Examples of Illegal Bounding with 'super'

To illustrate the issue further, consider a hypothetical method declaration:

<t super integer> void add(T number)  // hypothetical! currently illegal</t>

With this syntax, one might expect it to accept Integer and Number instances, but not String. However, since String is a subclass of Object and Object is a superclass of Integer, it would still be possible for add(aString) to compile, leading to potential errors.

Conclusion

In conclusion, the use of super with named type parameters is restricted to ensure type safety and prevent invalid assumptions. Generics and arrays in Java have unique characteristics that limit the effectiveness of bounding type parameters with super.

The above is the detailed content of Why is the `super` keyword restricted to wildcards and not type parameters in Java generics?. For more information, please follow other related articles on the PHP Chinese website!