java: converting from List<SomeClass> to List<SomeInterface> when SomeClass implements SomeInterface

Question

I'm having a brain cramp: I have a public interface SomeInterface and a static private class SomeClass and am trying to return a List<SomeInterface> from one of my methods, but I get the error (on the return list; line below):

Type mismatch: cannot convert from List<GenericList1.SomeClass> to
List<GenericList1.SomeInterface>

How can I fix this without having to create a new list?

Clarification: I do not want the list to be created as List<SomeInterface> (perhaps the obvious solution) because privately I want to maintain a List<SomeClass> to allow future access to SomeClass's methods beyond the ones in the public interface. This isn't shown in the example case below, but in my real program I need this.

import java.util.ArrayList;
import java.util.List;

public class GenericList1 {

    public interface SomeInterface
    {
        public int getX();
    }

    private static class SomeClass implements SomeInterface
    {
        final private int x;
        @Override public int getX() {
            return this.x;
        }       
        public SomeClass(int x) { this.x = x; }
    }

    public static void main(String[] args) {
        List<SomeInterface> list = createList(10);
        printList(list);
    }

    private static void printList(List<SomeInterface> list) {
        for (SomeInterface si : list)
            System.out.println(si.getX());
    }

    private static List<SomeInterface> createList(int n) {
        List<SomeClass> list = new ArrayList<SomeClass>();
        for (int i = 0; i < n; ++i)
            list.add(new SomeClass(i));
        return list;
    }
}

Paul · Accepted Answer · 2017-12-29 17:34:32Z

24

You should redefine your method as

private static List<? extends SomeInterface> createList(int n) { ...

and similarly, the other list declarations. This allows you to deal with generic lists polymorphically, as long as you only read values from them.

(Should you want to add new elements to a list, you should use List<? super SomeInterface> instead.)

This idiom is known by the abbreviation PECS - Producer: Extends / Consumer: Super, coined by Josh Bloch in Effective Java 2nd Edition, Item 28.

As others have noted, this idiom is needed because a List<SomeClass> is not a List<SomeInterface>, even when SomeClass implements SomeInterface. The reason for this is thoroughly explained in the referred document.

edited Dec 29, 2017 at 17:34

Paul

20.2k15 gold badges84 silver badges100 bronze badges

answered Feb 10, 2011 at 15:25

Péter Török

117k31 gold badges277 silver badges332 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Jason S Over a year ago

ah, OK, this works. In my real program I'm returning a List<> wrapped by Collections.unmodifiableList() so they're going to be read only.

Paul Over a year ago

The answer had a link to Item 28 but the link is now dead. A PDF of the book is available here: github.com/ldfaiztt/CSE331/blob/master/…

pnt · Accepted Answer · 2011-02-10 15:27:46Z

6

Contrary to popular belief, List<Derived> has absolutely no relation to List<Base>, even if Derived extends Base.

Just because the classes share a hierarchy doesn't mean that collections of them do. This is true for generics in general.

You could alter your code as follows:

private static List<SomeInterface> createList(int n) {
        List<SomeInterface> list = new ArrayList<SomeInterface>();
        for (int i = 0; i < n; ++i)
            list.add(new SomeClass(i)); //add a SomeClass object - valid, because it has the interface
    return list;
}

answered Feb 10, 2011 at 15:27

pnt

1,9161 gold badge20 silver badges29 bronze badges

1 Comment

Jason S Over a year ago

yes, that's the obvious solution but I don't want to do that; see my edits.

ILMTitan · Accepted Answer · 2011-02-10 16:45:10Z

1

I would change the signatures of the methods like so:

private static void printList(List<? extends SomeInterface> list) {
    for (SomeInterface si : list)
        System.out.println(si.getX());
}

private static <T super SomeClass> List<T> createList(int n) {
    List<T> list = new ArrayList<T>();
    for (int i = 0; i < n; ++i)
        list.add(new SomeClass(i));
    return list;
}

Using a wildcard in a return type is often a bad idea, because it forces you to use wildcards in all calling methods. I made createList a generic method so that the return type can be as flexable as possible while still being as specific as possible.

answered Feb 10, 2011 at 16:45

ILMTitan

11k3 gold badges32 silver badges48 bronze badges

Comments

irreputable · Accepted Answer · 2011-02-10 15:29:40Z

0

private static List<SomeInterface> createList(int n) {
    List<SomeInterface> list = new ArrayList<SomeInterface>();
    for (int i = 0; i < n; ++i)
        list.add(new SomeClass(i));
    return list;
}

answered Feb 10, 2011 at 15:29

irreputable

45.6k9 gold badges70 silver badges94 bronze badges

1 Comment

Jason S Over a year ago

that's the obvious solution but I don't want to do that; see my edits.

Collectives™ on Stack Overflow

java: converting from List<SomeClass> to List<SomeInterface> when SomeClass implements SomeInterface

4 Answers 4

2 Comments

1 Comment

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

1 Comment

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related