为什么这个泛型方法不接受任何类型？

Question

In the code below, when I call getList() I am not able to specify <T> . getList<T>() does not compile.

Instead, I may only call getList() - but then <T> is always simply <Event> .

Why is this?

class Foo
{
    public static void main (String[] args) throws java.lang.Exception
    {
        // For the sake of a complete example - the next method has
        // my question.
        Foo f = new Foo();
        f.register(new Subscriber<MyEvent>() {
            public void handle(MyEvent event){};
        });
    }

    public <T extends Event> void register(Subscriber<T> subscriber) {

        // Below won't work. I can't specify <T>, so getList()
        // will return a HashSet<Subscriber<Event>>, to which I cannot
        // add the Subscriber<T>!

        getList().add(subscriber);

        // Why can't I call getList<T>().add(subscriber) ?

    }

    private <T extends Event> HashSet<Subscriber<T>> getList() {
        // For the sake of example, simply return a new HashSet.
        return new HashSet<Subscriber<T>>();
    }
}

interface Subscriber<T extends Event> {
    public void handle(T event);
}

interface Event { }
class MyEvent implements Event { }

Answer 1

It appears that Java won't accept a <T> as the type argument to a simple name such as getList() . But it will accept it if you explicitly state this. when calling the method:

this.<T>getList().add(subscriber);

Answer 2

I believe the right answer is to make Foo into Foo<T extends Event> so that when in Foo T is defined.

Otherwise, try this.<T>getList() . This is how this is done for statics MyClass.<String>someMethod() . Not sure if it will also work for an instance method. Again, the best answer is to make Foo generic.

Answer 3

The T from you example is extending Event in both methods of Foo class. Well that implicitly means you Foo class is working only with <T extends Event> type inference. Unfortunately, your T is defined only at method scope. For humans all looks alright. But compiler is a bit different. Compiler doesn't believe you and it's not able to figure out implicit informations, however they are just fine, logically. You did not define your T at Class scope and the compiler did not figure out you are using the same type inference in both methods. So, compiler wont let you mix these method together.

So, the solution should explicitly define type inference is for Class scope use not only for method scope.

class Foo<T extends Event>
{
    public static void main (String[] args) throws java.lang.Exception
    {
        // For the sake of a complete example - the next method has
        // my question.
        Foo<MyEvent> f = new Foo<MyEvent>();
        f.register(new Subscriber<MyEvent>() {
            public void handle(MyEvent event){};
        });
    }

    public void register(Subscriber<T> subscriber) {

        // Below won't work. I can't specify <T>, so getList()
        // will return a HashSet<Subscriber<Event>>, to which I cannot
        // add the Subscriber<T>!

        getList().add(subscriber);

        // Why can't I call getList<T>().add(subscriber) ?

    }

    private HashSet<Subscriber<T>> getList() {
        // For the sake of example, simply return a new HashSet.
        return new HashSet<Subscriber<T>>();
    }

}

interface Subscriber<T extends Event> {
    public void handle(T event);
}

 class MyEvent extends Event {

}
 class Event {

}

Answer 4

Perhaps you need to be a little more gentle with Java. This seems to work without warnings:

HashSet<Subscriber<T>> list = getList();
list.add(subscriber);