带有擦除的Java类型推断

Question

having some problem with erasure & type inference. I have the following class hierarchy, which doesn't look very complicated:

public class Foo<T> {

}

public class Bar<T> {
    private final Class<T> clazz;

    public Bar(Class<T> clazz) {
        this.clazz = clazz;
    }
}

And what I'm trying to do is something like this:

Bar<Foo<?>> bar = new Bar<>(Foo.class);

which, of course, doesn't work, as Foo is not quite Foo<?> . The question is how to construct such a Bar? I need exactly Bar<Foo<?>> , not Bar<Foo> , as there is method which accepts only Bar<Foo<?>> as a parameter. Appreciate ideas.

Answer 1

Sorry, there is no such Class object, because, as you note, erasure means that there can't be. You need to cast it:

((Class<Foo<?>>)(Class)Foo.class)

This will give you the bounds you want, but may generate a compiler warning because you are performing an unchecked generic cast. This is reasonable: the compiler is requiring you to acknowledge that you are leaving behind the compile-time safety of generics. But in this case there's really no way this case can generate a runtime error, at this point in your program or in the future, so it's fine.

The double-cast is necessary because the compiler knows that Foo.class is not compatible with Class>, so you have to first cast it to the "raw" type Class: using raw types in an expression disables the compiler's generic-type checks for that expression, so then the "impossible" cast works okay.

Answer 2

You cannot create generic object without providing Type information in <> , as shown in your question post. You must supply a Type or use the raw version. If you are forced to use the wild card parameter type, then just suppress the warning by using raw type, as shown below

@SuppressWarnings("rawtypes")
Bar<Foo<?>> bar = new Bar(Foo.class);       

//Bar is having no type "<>" (but this is not recommended

Answer 3

Since java.lang.Class is immutable, you could use a weaker type declaration in the constructor of Bar:

class Foo<T> {}

class Bar<T> {
    private final Class<? extends T> clazz;

    public Bar(Class<? extends T> clazz) {
        this.clazz = clazz;
    }
}

If you'd still need the field to be of type Class<T> rather than Class<? extends T> Class<? extends T> it's safe to cast it within the constructor.