Issue with using 'extends' and 'super' in java generics with generic methods

Question

There is a method :

public static <T> void addandDisp(Collection<T> cs, T t)

which is being called in the following way :

List<? extends Object> ls2 = new LinkedList<Number>();
addandDisp(ls2,new Object());

This gives a compile time error. On the other hand, if we had only one parameter, then the call is successful. Why is that ?

Moreover, this is successful :

List<? super String> ls1 = new LinkedList<String>();
addandDisp(ls1,new String());

while this is not :

List<? super String> ls1 = new LinkedList<Object>();
addandDisp(ls1,new Object());

What is the underlying logic ?

_If we had only one parameter_ Which one? Either? Consider the type inferred. — Sotirios Delimanolis, Aug 04 '14 at 14:45
If the method signature had only 'Collection cs' as the argument, the above call works fine. — Daud, Aug 04 '14 at 14:58

score 11 · Answer 1 · edited May 23 '17 at 12:11

11

I would assume that addandDisp means add and display.

When you have a collection, defined as:

List<? extends Object> ls2 = new LinkedList<Number>();

This means that the compiler will allow you to assign the colletion to all the possible unknown subtypes of Object. Since you have the operation add, the compiler denies to give you green light, because it doesn't know if the provided object's type meets the restriction to be of the unknown subtype of Object. This is called covariance.

Similary, when you have a definition like this:

List<? super String> ls1 = new LinkedList<String>();

The compiler allows you to assing ls1 to:

LinkedList<String>(); //you can add Strings to the list
LinkedList<Object>(); //you can add Strings and Objects to the list

In this case, the compiler will be completely aware if the object you're trying to pass meets the condition to be subtype of the generic type of the collection. This is called contravariance.

More info:

What is PECS?

edited May 23 '17 at 12:11

Community

1
1

answered Aug 04 '14 at 14:30

Konstantin Yovkov

62,134
8
100
147

In the case of 'extend', Why does the call succeed if the method has only the collection parameter. Why does adding a second parameter force it to fail ? – Daud Aug 04 '14 at 14:43
Well...by definition, collections can be parametrized with only one type. Or I don't understand what are you asking... – Konstantin Yovkov Aug 04 '14 at 14:44
I am calling 'addandDisp' with 2 parameters in the example in the question, and getting the errors. These errors don't come if the method signature takes only a single parameter i.e. only 'Collection cs' – Daud Aug 04 '14 at 14:52

score 2 · Answer 2 · answered Aug 04 '14 at 15:19

Here is another approach, but others gave a quite detailed response.

The first example:

List<? extends Object> ls0 = new LinkedList<Number>();
addandDisp(ls0, new Object());

Here ls0 may be of any type that is a subclass of Object, like a Number as your example shows.

Now what if this could work? It would mean that if you can put an Object into any of the collections.

Imagine I want to iterate your previous list of Number objects:

for (Number n : numbers) {
    ...
}

If I could put an Object here, then Plaff! I would get a class cast exception immediately.

The second example

List<? super String> ls1 = ...;
addandDisp(ls1,new String());

Let's play a bit with the object hierarchy: String is a subclass of CharSequence which is a subclass of Object.

You get ls1 here which is an unknown supertype of String (e.g., a CharSequence). Is it all right to put a String into a list of character sequences? Yup, it's okay, since they share the same interface for sure! You can handle them through it in the same way.

The third example

List<? super String> ls1 = ...;
addandDisp(ls1,new Object());

Let's suppose the previous situation: you assign ls1 a list of CharSequences. Can you add an object to a List<CharSequence>? Nope, for the same reason as the first example fails.

Hope that helps clarifying your issues a bit :-)

score 1 · Accepted Answer · answered Aug 04 '14 at 15:20

On the other hand, if we had only one parameter, then the call is successful. Why is that ?

Your method has a single type parameter. When you invoke a method, you either provide a type argument explicitly or have one be inferred implicitly.

When you invoke it like

addandDisp(ls2, new Object());

the compiler needs to extract a type to bind to T from both method arguments, since both method parameters rely on the method's type parameter, T.

The issue here is that ? extends Object and Object do not produce a single type that can be bound to T safely. Imagine you had

public static <T> void addandDisp(Collection<T> cs, T t) {
    cs.add(t);
}
...
List<? extends Object> ls2 = new LinkedList<Number>();
addandDisp(ls2, new Object());

This add should not be allowed since an Object should not be used where a Number would have been expected. Type safety would break.

If you have a single parameter

public static <T> void addandDisp(Collection<T> cs) {

Then the compiler uses the single argument to infer the type argument. There is then no ambiguity about what to use.

score 0 · Answer 4 · edited Aug 04 '14 at 14:32

0

1 example: Object is not ? extends Object (for example, Number is ? extends Object, but Object is not Number). Thus, it is not type safe.

2 example: String is ? super String. It is type safe.

3 example: Object is not ? super String. Not safe again.

edited Aug 04 '14 at 14:32

EpicPandaForce

79,669
27
256
428

answered Aug 04 '14 at 14:30

kraskevich

18,368
4
33
45

Object is the superclass of String, though. Mind elaborating on what you mean? If String extends object, then wouldn't Object be suitable for `? super String`? – Vince Aug 04 '14 at 14:33
@VinceEmigh ? super String is unknown type which is a super type of String. String is a super type of String. Object is not String. – kraskevich Aug 04 '14 at 14:35

Issue with using 'extends' and 'super' in java generics with generic methods

4 Answers4