Java generic methods: super can't be used?

Question

So I have this method:

protected void collectSelectedItems(ListSelectionModel lsm, 
         Collection<? super MyItemClass> result) {
    for (int i : GUI.getSelectionIndices(lsm))
    {
        result.add(getItemByDisplayIndex(i));
    }
}

I'd like to return the collection instead of having a void method:

protected <T super MyItemClass> Collection<T> 
  collectSelectedItems(ListSelectionModel lsm, Collection<T> result) {
    for (int i : GUI.getSelectionIndices(lsm))
    {
        result.add(getItemByDisplayIndex(i));
    }
    return result;
}

with the intent of doing something like this (where MyItemClass extends MyItemBaseClass):

List<MyItemBaseClass> list = 
   collectSelectedItems(lsm, new ArrayList<MyItemBaseClass>());

but I get a syntax error on the super:

Syntax error on token "super", , expected

What gives? Can I fix this?

`Object` is a super of `MyItemClass` so the `Collection` could be a `Collection — Peter Lawrey, Dec 06 '11 at 16:44
Peter, why not? PECS: I'm passing in a *C*onsumer of MyItemClass, therefore I need to use `super` rather than `extends` — Jason S, Dec 06 '11 at 16:46

score 8 · Accepted Answer · answered Dec 06 '11 at 17:10

8

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.

answered Dec 06 '11 at 17:10

zw324

26,764
16
85
118

1

It "buys you something" if you want to declare your method to take a `Comparator super Widget>` though, because a `Comparator – Hakanai Dec 04 '14 at 00:08
1

That's not what the linked page says - it explicitly says that if super were allowed in _method_ declarations, that would help create type-safe generic methods. Right now the example I bumped into is Optional's orElse: it only accepts the same type as the Optional, even though it would often make perfect sense to say `Optional optional = ...; Supertype result = optional.orElse(supertypeInstance);` – laszlok May 24 '18 at 11:12

score 2 · Answer 2 · answered Dec 06 '11 at 17:04

Here are two ideas. The first only returns a generic Collection, the second returns the actual result-type:

public <T, S extends T> Collection<T> ver1(Collection<S> src, Collection<T> dst)
{
    dst.addAll(src);
    return dst;
}

public <U, T extends Collection<U>, S extends U> T ver2(Collection<S> src, T dst)
{
    dst.addAll(src);
    return dst;
}

score 1 · Answer 3 · answered Dec 06 '11 at 16:48

well, I didn't answer my question exactly, but this is an acceptable solution for my problem:

protected <T extends Collection<? super MyItemClass>> 
  T collectSelectedItems(ListSelectionModel lsm, T result) {
    for (int i : GUI.getSelectionIndices(lsm))
    {
        result.add(getItemByDisplayIndex(i));
    }
    return result;
}

Java generic methods: super can't be used?

3 Answers3

Linked

Related