Java generics Enum subtyping Interface

Question

Given the following setup:

  public class TestType {

  public static void main(String[] args) {
    List<Constants> list = new ArrayList<>();
    accept(list); //Does not compile
  }

  static void accept(Iterable<MyInterface> values) {
    for (MyInterface value : values) {
      value.doStuff();
    }
  }
}

interface MyInterface<T> {
  T doStuff();
}

enum Constants implements MyInterface<Integer> {
  ONE, TWO, THREE;

  @Override
  public Integer doStuff() {
    return ordinal();
  }
}

Why won't the compiler accept the list as parameter to accept()?

List extends Iterable via Collection so that isn't the problem.

On the other hand, the compiler tells me that incompatible types: java.util.List<enums.Constants> cannot be converted to java.lang.Iterable<enums.MyInterface>

But Constants IS a MyInterface... isn't it?

score 4 · Accepted Answer · edited May 23 '17 at 12:15

4

The problem is with how Generics work. Specifically, Generics are non-reified... meaning that the compiler will not see an Iterable<enum.Constants> as an Iterable<enum.MyInterface> even if Constants is a sub-class of MyInterface.

However, there is a way to get around it: Generic wildcards.

If you change static void accept(Iterable<MyInterface> values) to static void accept(Iterable<? extends MyInterface> values), it should work.

edited May 23 '17 at 12:15

Community

1
1

answered Feb 12 '16 at 14:18

Powerlord

87,612
17
125
175

That does indeed work. Will accept the answer as soon as SO let's me. Thanks a lot! – tannerli Feb 12 '16 at 14:22

score 2 · Answer 2 · answered Feb 12 '16 at 14:28

You need to use Iterable<? extends MyInterface> instead of Iterable<MyInterface> because even though Constants is a subtype of MyInterface, Iterable<Constants> is not a subtype of Iterable<MyInterface> - and I'll show you why:

If it was so (let's use List instead of Iterable for the next example), I would be able to do this:

List<Constant> constantsList = new ArrayList<Constants>(); // list of constants
List<MyInterface> ifaceList = constantsList; // you said this would be OK ...
// assume MyOtherImplementation is another implmentation of MyInterface
ifaceList.add(new MyOtherImplementation()); // OK, MyOtherImplementation implements MyInterface
Constant myConst = constantsList.get(0); // Oops! I just got an instance of MyOtherImplementation from List<Constant> - not cool.

score 0 · Answer 3 · answered Feb 12 '16 at 14:19

0

Generic types do not inherit this way, although it may seem counter-intuitive at first glance. Using Iterable<? extends MyInterface> will allow you to use any Iterable (e.g., a List) of a type that extends MyInterface (e.g. Constants).

answered Feb 12 '16 at 14:19

Mureinik

297,002
52
306
350

Java generics Enum subtyping Interface

3 Answers3