Java generics with inner class and inner interface

Question

Below I have a generic OuterClass, an InnerClass that use OuterClass generics and non-generic InnerInterface.

public class OuterClass<E> {

    public class InnerClass  {

        public E someMethod() {
            return null;
        }
    }

    public interface InnerInterface{
        public void onEvent(OuterClass.InnerClass innerClass);
    }
}

In the main method below, I use two instance of OuterClass, o1 parameterized with , and o2 with . My annonymous inner class myListener tries to use the generic type of the outer class (E). The code as it is below does not compile (Integer i = innerClass.someMethod() - Type mismatch: cannot convert from Object to Integer).

public class Test {
    public static void main(String[] args) {

        OuterClass<Integer> o1 = new OuterClass<Integer>();
        OuterClass<String> o2 = new OuterClass<String>();

        OuterClass.InnerInterface innerInterface = new OuterClass.InnerInterface() {
            @Override
            public void onEvent(InnerClass innerClass) {
                Integer i = innerClass.someMethod();
            }
        };
    }
}

I would like to express that myListener is for o1, and should use E = Integer, without repeating it (without repeating , I already say it when declaring o1). Is that possible?

Many thanks! Faton.

Your interface method needs to be genericized, too. – Bombe Mar 23 '11 at 09:14 — Bombe, Mar 23 '11 at 09:14

Laurent Pireyn · Answer 1 · 2011-03-23T12:24:04.440

16

An inner interface or enum is implicitely static, and static members are not parameterized with the type parameters of the outer class. So InnerInterface should look like this:

public interface InnerInterface<E> {
    void onEvent(OuterClass<E>.InnerClass innerClass);
}

Note that the E parameter of InnerInterface is not the same as the E parameter of OuterClass.

edited Mar 23 '11 at 12:24

answered Mar 23 '11 at 09:27

Laurent Pireyn

6,735
1
29
39

8

Perhaps, then, it would be better not to call it E? – Ingo Mar 23 '11 at 09:40
2

Thank you Laurent. It would work, but I've to repeat because it's a different E. My question was "is it possible to reuse the first E = ", and prevent redeclaring for the interface ? – Faton Mar 23 '11 at 09:48
1

Probably not a great idea to use the same identifier for the generic parameter. – Tom Hawtin - tackline Mar 23 '11 at 09:52
@Faton Then the answer is no. – Laurent Pireyn Mar 23 '11 at 12:25
@Tom Maybe, but the type parameter of `InnerInterface` has the very same meaning as the `E` of `Outerclass`, and I think using the same name makes that relation obvious. – Laurent Pireyn Mar 23 '11 at 12:41
@Laurent Pireyn In terms of code, it is completely independent. Now if the didn't have an intersecting scope (sensible) then it wouldn't be an issue. – Tom Hawtin - tackline Mar 23 '11 at 13:02

Tom Hawtin - tackline · Answer 2 · 2011-03-23T13:08:34.660

As always, non-private nested types don't help keeping things simple. Push the boat out and create some new files, even if your IDe works against you.

Anyway, static members of a class do not share the generic parameters of the outer class. This is important for the behaviour of fields, and allows more flexibility on static nested types (such as InnerInterface) even if you don't want it. So, in your case, you need to give your (static) nested interface a generic parameter. For $deity's sake, use a different identifier!

public class OuterClass<E> {
    public class InnerClass  {
        public E someMethod() {
            return null;
        }
    }

    public interface InnerInterface<T> {
        void onEvent(OuterClass<T>.InnerClass innerClass);
    }
}


public class Test {
    public static void main(String[] args) {

        OuterClass<Integer> o1 = new OuterClass<Integer>();
        OuterClass<String> o2 = new OuterClass<String>();

        OuterClass.InnerInterface<Integer> innerInterface =
            new OuterClass.InnerInterface<Integer>() 
       {
            @Override
            public void onEvent(OuterClass<Integer>.InnerClass innerClass) {
                Integer i = innerClass.someMethod();
            }
        };
    }
}

(I've also qualified InnerClass where necessary.)

Edit: It's probably worth just looking at the original anonymous inner class in isolation from the rest of the use:

public interface InnerInterface{
    public void onEvent(OuterClass.InnerClass innerClass);
}

    OuterClass.InnerInterface innerInterface = new OuterClass.InnerInterface() {
        @Override
        public void onEvent(InnerClass innerClass) {
            Integer i = innerClass.someMethod();
        }
    };

Integer only appears once, in a place where it clearly cannot be inferred to be correct.

Java generics with inner class and inner interface

2 Answers2

Linked