What is ? super T syntax?
super in Generics is the opposite of extends. Instead of saying the comparable's generic type has to be a subclass of T, it is saying it has to be a superclass of T. The distinction is important because extends tells you what you can get out of a class (you get at least this, perhaps a subclass). super tells you what you can put into the class (at most this, perhaps a superclass).
In this specific case, what it is saying is that the type has to implement comparable of itself or its superclass. So consider java.util.Date. It implements Comparable<Date>
. But what about java.sql.Date? It implements Comparable<java.util.Date>
as well.
Without the super signature, SortedList would not be able accept the type of java.sql.Date, because it doesn't implement a Comparable of itself, but rather of a super class of itself.
Difference between ? super T and ? extends T in Java
extends
The wildcard declaration of List<? extends Number> foo3
means that any of these are legal assignments:
List<? extends Number> foo3 = new ArrayList<Number>(); // Number "extends" Number (in this context)
List<? extends Number> foo3 = new ArrayList<Integer>(); // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>(); // Double extends Number
Reading - Given the above possible assignments, what type of object are you guaranteed to read from
List foo3
:- You can read a
Number
because any of the lists that could be assigned tofoo3
contain aNumber
or a subclass ofNumber
. - You can't read an
Integer
becausefoo3
could be pointing at aList<Double>
. - You can't read a
Double
becausefoo3
could be pointing at aList<Integer>
.
- You can read a
Writing - Given the above possible assignments, what type of object could you add to
List foo3
that would be legal for all the above possibleArrayList
assignments:- You can't add an
Integer
becausefoo3
could be pointing at aList<Double>
. - You can't add a
Double
becausefoo3
could be pointing at aList<Integer>
. - You can't add a
Number
becausefoo3
could be pointing at aList<Integer>
.
- You can't add an
You can't add any object to List<? extends T>
because you can't guarantee what kind of List
it is really pointing to, so you can't guarantee that the object is allowed in that List
. The only "guarantee" is that you can only read from it and you'll get a T
or subclass of T
.
super
Now consider List <? super T>
.
The wildcard declaration of List<? super Integer> foo3
means that any of these are legal assignments:
List<? super Integer> foo3 = new ArrayList<Integer>(); // Integer is a "superclass" of Integer (in this context)
List<? super Integer> foo3 = new ArrayList<Number>(); // Number is a superclass of Integer
List<? super Integer> foo3 = new ArrayList<Object>(); // Object is a superclass of Integer
Reading - Given the above possible assignments, what type of object are you guaranteed to receive when you read from
List foo3
:- You aren't guaranteed an
Integer
becausefoo3
could be pointing at aList<Number>
orList<Object>
. - You aren't guaranteed a
Number
becausefoo3
could be pointing at aList<Object>
. - The only guarantee is that you will get an instance of an
Object
or subclass ofObject
(but you don't know what subclass).
- You aren't guaranteed an
Writing - Given the above possible assignments, what type of object could you add to
List foo3
that would be legal for all the above possibleArrayList
assignments:- You can add an
Integer
because anInteger
is allowed in any of above lists. - You can add an instance of a subclass of
Integer
because an instance of a subclass ofInteger
is allowed in any of the above lists. - You can't add a
Double
becausefoo3
could be pointing at anArrayList<Integer>
. - You can't add a
Number
becausefoo3
could be pointing at anArrayList<Integer>
. - You can't add an
Object
becausefoo3
could be pointing at anArrayList<Integer>
.
- You can add an
PECS
Remember PECS: "Producer Extends, Consumer Super".
"Producer Extends" - If you need a
List
to produceT
values (you want to readT
s from the list), you need to declare it with? extends T
, e.g.List<? extends Integer>
. But you cannot add to this list."Consumer Super" - If you need a
List
to consumeT
values (you want to writeT
s into the list), you need to declare it with? super T
, e.g.List<? super Integer>
. But there are no guarantees what type of object you may read from this list.If you need to both read from and write to a list, you need to declare it exactly with no wildcards, e.g.
List<Integer>
.
Example
Note this example from the Java Generics FAQ. Note how the source list src
(the producing list) uses extends
, and the destination list dest
(the consuming list) uses super
:
public class Collections {
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i = 0; i < src.size(); i++)
dest.set(i, src.get(i));
}
}
Also see
How can I add to List<? extends Number> data structures?
Can someone explain what does ? super T mean and when should it be used and how this construction should cooperate with T and ? extends T?
This construct is used when you want to consume items from a collection into another collection. E.g. you have a generic Stack
and you want to add a popAll
method which takes a Collection as parameter, and pops all items from the stack into it. By common sense, this code should be legal:
Stack<Number> numberStack = new Stack<Number>();
Collection<Object> objects = ... ;
numberStack.popAll(objects);
but it compiles only if you define popAll
like this:
// Wildcard type for parameter that serves as an E consumer
public void popAll(Collection<? super E> dst) {
while (!isEmpty())
dst.add(pop());
}
The other side of the coin is that pushAll
should be defined like this:
// Wildcard type for parameter that serves as an E producer
public void pushAll(Iterable<? extends E> src) {
for (E e : src)
push(e);
}
Update: Josh Bloch propagates this mnemonic to help you remember which wildcard type to use:
PECS stands for producer-extends, consumer-super.
For more details, see Effective Java 2nd Ed., Item 28.
What does T extends ComparableT mean?
First, you have the Comparable
interface which roughly looks like:
public interface Comparable<T> {
int compareTo(T other);
}
As you can see, the type parameter of Comparable
is used as the parameter of the compareTo
method. Typically, the type argument for T
is the same class which is implementing the Comparable
interface. This generic setup facilitates comparing instances of the same type with each other. Here's an example:
public class Name implements Comparable<Name> {
@Override
public int compareTo(Name other) {
// compute & return result
}
}
Now let's say you have a method which should return the maximum of two objects according to their natural order. Such a method could look like the following:
public static <U extends Comparable<U>> U max(U left, U right) {
return left.compareTo(right) >= 0 ? left : right;
}
Note: Used U
as the type variable instead of T
to show it is separate from the T
used in the Comparable
interface.
The above is a generic method. The type variable U
is upper-bounded by Comparable<U>
. What this means is that the type argument used in place of U
must be assignable to (i.e. subtype of) Comparable<U>
. For instance, if we use Name
as the type argument it will work because Name
is assignable to Comparable<Name>
. The reason for specifying the upper-bound as Comparable<U>
is that the method needs to call compareTo
in order to function properly.
Name name1 = ...;
Name name2 = ...;
Name max = max(name1, name2); // U is inferred to be Name
As shown above, having U
as the return type also allows assigning the result to a variable of the same type as the arguments.
Note that for maximum flexibility the max
method should actually be declared like so:
public static <U extends Comparable<? super U>> U max(U left, U right) {
return left.compareTo(right) >= 0 ? left : right;
}
The difference being the use of Comparable<? super U>
as the upper-bound instead of Comparable<U>
. These two Q&As should help explain why using ? super U
offers greater flexibility:
- What is PECS (Producer Extends Consumer Super)?
- Explanation of generic
<T extends Comparable<? super T>>
in collection.sort/ comparable code?
Bounding generics with 'super' keyword
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
- Java Tutorials/Generics
- Subtyping
- More fun with wildcards
Related questions
On generics typing rules:
- Any simple way to explain why I cannot do
List<Animal> animals = new ArrayList<Dog>()
? - java generics (not) covariance
- What is a raw type and why shouldn’t we use it?
- Explains how raw type
List
is different fromList<Object>
which is different from aList<?>
- Explains how raw type
On using super
and extends
:
Java Generics: What is PECS?
- From Effective Java 2nd Edition: "producer
extends
consumersuper
"
- From Effective Java 2nd Edition: "producer
- What is the difference between
super
andextends
in Java Generics - What is the difference between
<E extends Number>
and<Number>
? - How can I add to
List<? extends Number>
data structures? (YOU CAN'T!)
Problem with T extends Comparable? super T
Suppose we changed the max
method to this:
<T extends Comparable<T>> T max(Collection<? extends T> coll)
You would not be able to get the max
of a List<Apple>
because Apple
does not implement Comparable<Apple>
, it implements Comparable<Fruit>
. But you and I know perfectly well that an Apple
knows how to compare itself to another Fruit
because it inherited that functionality.
We fix the problem by changing the declaration of max
to this:
<T extends Comparable<? super T>> T max(Collection<? extends T> coll)
This means that we accept any class T
such that:
T implements Comparable<T>
, or...T implements Comparable<X>
for someX
such thatX
is a super class ofT
In order to find the max
, we must be sure that any instance of T
can safely accept another instance of T
as an argument to its compare
method.
In the first scenario, it is obvious that any instance of T
can safely accept another instance of T
as an argument to its compare(T)
method.
In the second scenario, any instance of T
can safely accept another instance of T
as an argument to its compare(X)
method because all instances of T
are also instances of X
.
Your example illustrates the second scenario, where T
corresponds to Apple
and X
corresponds to Fruit
.
Java generic methods: super can't be used?
Here's one link that explains why this is not allowed:
http://www.angelikalanger.com/GenericsFAQ/FAQSections/TypeParameters.html#FAQ107
It basically just says that use super in type parameters "does not buy you anything", since if this is allowed, erasure will probably just erase it to Object
, which does not make much sense.
Related Topics
How to Disable Javac's Inlining of Static Final Variables
Convert String to Int Array in Java
Naming Convention for Getters/Setters in Java
Jackson - Serialization of Entities with Birectional Relationships (Avoiding Cycles)
Counting the Number of Files in a Directory Using Java
How to Check for a Valid Url in Java
"File Not Found" When Running New Libgdx Project
Change a Method at Runtime via a Hot Swap Mechanism
Check Line for Unprintable Characters While Reading Text File
Checking for a Null Int Value from a Java Resultset
Log4J Configuration via Jvm Argument(S)
Meaning of New Class(...){{...}} Initialization Idiom
Does Java Support Inner/Local/Sub Methods
How to Deserialize the Object, If It Was Moved to Another Package or Renamed