Question

Any ideas why the code below doesn’t compile?

public class A<TT extends B<?>> extends C<TT> implements D<TT> {

    protected A(Class<TT> c) {
        super(c);
    }

}

interface B<MM> {

}

interface D<MM extends B<?>> {

}

abstract class C<TT> {
    protected C(Class<TT> c) {

    }
}

class F implements B<String> {

}

class G extends F {

}

class E<TT extends B<String>> {
    public E() {
        // why does this not work?
        // Error: The constructor A<TT>(Class<G>) is undefined
        D<TT> d = new A<TT>(G.class);

    }
}

Answer 1

Simple: G.class is a Class<G> – not a Class<TT>.

This works:

D<G> d = new A<G>(G.class);

… but you don’t know the type of TT (in E) so you can’t provide the relevant Class<TT> instance to the A<TT> constructor. This would compile too, but probably isn’t what you want:

// Oops - we don't really have TT.class, and can't refer to it...
D<TT> d = new A<TT>(null); 

Imagine we tried to use your current code, and had:

class H extends B<String> {}

Then it would be entirely reasonable to construct an E<H>, but you’d be trying to pass G.class to the constructor of A<H> – it’s clearly not the same type.

(As a side-note, it’s really helpful to make these examples as simple as possible. That means getting rid of all the classes which aren’t relevant, and avoiding reusing type parameter names for the sake of clarity.)