不兼容的通用类型：使用带有泛型类型的.class时，无法指定子类型

Question

There are many threads relating to Java Generics, and I'm having trouble sorting out why exactly Java doesn't support this (or alternatively, what I need to do to make it work).

public interface Thinger<T> {

    Class<? extends Thinger<T>> getThingers();
}

public class Thingy<Qwerty> implements Thinger<String> {

    @Override
    public Class<? extends Thinger<String>> getThingers() {
        return Thingx.class;
    }
}

public class Thingx implements Thinger<String> {

    @Override
    public Class<? extends Thinger<String>> getThingers() {
        return Thingy.class;    // Incompatible types error
    }
}

I can fix the compile error two ways, but both of them end up dropping some kind of typing information that I want to keep!

Option 1

Drop the generic Qwerty in Thingy<Qwerty> .

public class Thingy implements Thinger<String> {
    ..
// Ends up fixing the compile error in Thingx

Option 2

Drop the generic String in Class<? extends Thinger<String>> Class<? extends Thinger<String>>

public class Thingx implements Thinger<String> {

    @Override
    public Class<? extends Thinger> getThingers() {
        return Thingy.class;    // Fixed!

Answer 1

Thingy.class returns a Class<Thingy> where Thingy is a raw type since it doesn't specify a value for Qwerty . Since, it's a raw type, the compiler is only aware of Thingy implementing Thinger , instead of Thinger<String> , since that information is lost due to type erasure.

To fix it, you can convert the Class<Thingy> to a Class<? extends Thinger> Class<? extends Thinger> using Class#asSubclass , and then the compiler allows the implicit cast to Thinger<String> .

return Thingy.class.asSubclass(Thinger.class);

This produces no compiler or runtime errors when tested:

Class<? extends Thinger<String>> c = new Thingx().getThingers();
System.out.println(c.getGenericInterfaces()[0]);

Output is:

Thinger<java.lang.String>

Answer 2

I'm having trouble sorting out why exactly Java doesn't support this

Thingy.class has type Class<Thingy> , which is not a subtype of Class<? extends Thinger<String>> Class<? extends Thinger<String>> , because Thingy is not a subtype of Thinger<String> .

Note that since Thingy is a generic class (it is declared with a type parameter), using Thingy by itself without a type argument is a raw type . When you use a raw type, you disable all generics, so the supertype of Thingy (the raw type) is Thinger (the raw type), not Thinger<String> (even though Qwerty is not involved in the relationship). This is similar to how if you call a method on a raw type like Thingy , all generics are turned off in the parameter and return types of the method, even if they have nothing to do with Qwerty . This is just one of the reasons to avoid raw types.

It works for Thingx.class because Thingx is a subtype of Thinger<String> , as Thingx is not a raw type because the class Thingx is not generic.

As others have noted, there doesn't seem to be any reason why Thingy is generic, as the type parameter Qwerty is never used inside Thingy . So the best choice would be to remove it.