Question

I want to provide something like this in my api:

class Foobar extends AbstractThing<Double>

class EventThing<Foobar> {    
            public Foobar getSource();
            public Double getValue();
}

So I write this:

class EventThing<T extends AbstractThing<U>> {    
        public T getSource();
        public U getValue();
}

But java can not resolve the U.

With EventThing<T extends AbstractThing<U>,U> instead it works, but the second U is actually redundant ’cause the AbtractThing define the Type already. So I love to get rid of it.

Answer 1

You can’t get rid of it. The second U is not redundant. You want the compiler to interpret the first U as a type parameter, but it doesn’t. You could also have written this:

class EventThing<T extends AbstractThing<Double>>

Note that Double in this case is a concrete class, and not a type parameter. Compare this to the following:

class EventThing<T extends AbstractThing<U>>

Note that this has the exact same form as the first line of code above. How is the compiler supposed to know that in the first case, Double is meant as a concrete class, while in the second case, U is meant as a type parameter?

The compiler can’t know that, and treats the U as a concrete class, just like the Double in the first line. The only way to let the compiler know that U is a type parameter is to specify it as such:

class EventThing<T extends AbstractThing<U>, U>