Bounding generics with ‘super’ keyword

by

super to bound a named type parameter (e.g. <S super T>) as opposed to a wildcard (e.g. <? super T>) is ILLEGAL simply because even if it’s allowed, it wouldn’t do what you’d hoped it would do, because since Object is the ultimate super of all reference types, and everything is an Object, in effect there is no bound.

In your specific example, since any array of reference type is an Object[] (by Java array covariance), it can therefore be used as an argument to <S super T> S[] toArray(S[] a) (if such bound is legal) at compile-time, and it wouldn’t prevent ArrayStoreException at run-time.

What you’re trying to propose is that given:

List<Integer> integerList;

and given this hypothetical super bound on toArray:

<S super T> S[] toArray(S[] a) // hypothetical! currently illegal in Java

the compiler should only allow the following to compile:

integerList.toArray(new Integer[0]) // works fine!
integerList.toArray(new Number[0])  // works fine!
integerList.toArray(new Object[0])  // works fine!

and no other array type arguments (since Integer only has those 3 types as super). That is, you’re trying to prevent this from compiling:

integerList.toArray(new String[0])  // trying to prevent this from compiling

because, by your argument, String is not a super of Integer. However, Object is a super of Integer, and a String[] is an Object[], so the compiler still would let the above compile, even if hypothetically you can do <S super T>!

So the following would still compile (just as the way they are right now), and ArrayStoreException at run-time could not be prevented by any compile-time checking using generic type bounds:

integerList.toArray(new String[0])  // compiles fine!
// throws ArrayStoreException at run-time

Generics and arrays don’t mix, and this is one of the many places where it shows.

A non-array example

Again, let’s say that you have this generic method declaration:

<T super Integer> void add(T number) // hypothetical! currently illegal in Java

And you have these variable declarations:

Integer anInteger
Number aNumber
Object anObject
String aString

Your intention with <T super Integer> (if it’s legal) is that it should allow add(anInteger), and add(aNumber), and of course add(anObject), but NOT add(aString). Well, String is an Object, so add(aString) would still compile anyway.

See also

Related questions

On generics typing rules:

On using super and extends:

More Related Contents:

  1. What is PECS (Producer Extends Consumer Super)?
  2. Why are arrays covariant but generics are invariant?
  3. Why doesn’t Java allow generic subclasses of Throwable?
  4. Why can’t you have multiple interfaces in a bounded wildcard generic?
  5. Java generic methods in generics classes
  6. Java generics type erasure: when and what happens?
  7. How to create a generic array? [duplicate]
  8. How to determine the class of a generic type?
  9. Java Generics – Bridge method?
  10. Lambda Expression and generic defined only in method
  11. Reflection type inference on Java 8 Lambdas
  12. Java8: ambiguity with lambdas and overloaded methods
  13. Use of ‘? extends ‘ and ‘? super ‘ in Collection generics [duplicate]
  14. Java Type Generic as Argument for GSON
  15. Java Generic Class – Determine Type
  16. How to have Java method return generic list of any type?
  17. How does Gson TypeToken work?
  18. Casting to generic type in Java doesn’t raise ClassCastException?
  19. What’s the difference between raw types, unbounded wild cards and using Object in generics
  20. Java generics issue: Class “not within bounds of type-variable” error.
  21. Nested wildcards
  22. Type erasure, overriding and generics
  23. How to create ArrayList (ArrayList) from array (int[]) in Java
  24. mocking a method that return generics with wildcard using mockito
  25. Generic method in Java without generic argument
  26. Using a generic type with Gson
  27. Java generics – ArrayList initialization
  28. How to write a generic method that takes two arguments of the same types in java?
  29. Java generics: wildcard vs type parameter?
  30. Provide an iterator over the contents of two lists simultaneously?

Leave a Comment