Resolve IDE warning with generics, Class<?> type

Question

class Test1<T> {
  Test1(Class<T> type) {}
}

class Test2 extends Test1<Class> {
  Test2() {
    super(Class.class);
  }
}

This works, but, I am warned about use of a raw generic type in "Test1<Class>". I understand that, but, changing it to "Class<?>" (which should be equivalent?) gives a compiler error in the call to super() -- Class.class is apparently of type "Class<Class>" instead of "Class<Class<?>>".

Variants on these all seem to result in a compile error.

Can anyone see how to resolve this, such that I am always using a type param with Class, and hence don't get an IDE warning? It seems better that way, even if it works as-is. I am open to changes in the structure of these two classes two as long as it preserves the basic intent: Test2 is a special type of Test1, specialized for "Class" objects.

Answer 1

I use Java 1.6.0_14 and the compiler doesn't give me any warnings when compiling that code.

Answer 2

Class and Class<?> aren't exactly equivalent. They're semantically equivalent, but the latter is effectively telling the compiler, "Yes, I know this is a generic type, but I don't know anything about the type parameter." The former is just the raw type, which can often be a sign that it's old code which hasn't been migrated to use generics.

This is covered in the Java Generics FAQ - see the question "What is the difference between the unbounded wildcard parameterized type and the raw type?" in the parameterized types section.

Answer 3

This might be one of those times that is appropriate for:

@SuppressWarnings("unchecked")
class Test2 extends Test1<Class> {
  Test2() {
    super(Class.class);
  }
}

Unless you will always use Test1<Class>, I don't see another way to resolve this warning. (You'd probably get the same warning if you ran javac -Xlint:unchecked, but I'm not positive about this.) The issue here is that you will normally (I assume) be using your class Test1 with ungeneric values, but Class is a genericized class that takes a Class object as its parameter. I don't see any way around this, so I think the best solution is to suppress this specific warning so that the real problems will stand out.

Answer 4

Your warnings stem from the fact that Class is itself a paramterized class: public final class Class<T>. The simplest way to remove the warnings is to make the T the type parameter instead of Class<T>:

class Test1<T> {
    Test1(T type) { Class<?> classType = type.getClass();}
}

class Test2 extends Test1<String> {
    Test2() {
        super("");
    }
}

Answer 5

The short answer is that there is no way to specify the type parameter. That is because the Class object (say, for example, List.class, not just Class.class) doesn't understand that generic type parameter - it is erased during compilation.

My IDE, Intellij IDEA, gives the same warning. It is the IDE being too aggressive. You can suppress the warning with IDEA (it generates a @SuppressWarnings annotation), but code to work around it (like Robert Munteau's clever workaround) is really introducing some nasty design just to avoid an IDE message that is really not correct - the JDK does not view this case as an erasure.

EDIT: Given the downvote, I should at least justify my thinking here.

Think about the following:

 List.class

That represents a class object of type:

 Class<List>

It cannot represent a type of:

 Class<List<?>>

because it isn't known if the given list will actually have a generic parameter or what it will be. The List.class object has to represent all types, as far as parameterizing Class.

The evidence that the JDK does not view this as an unsafe operation is that if you compile the code, it gives you no warning.

So the IDE is just being overly sensitive. Although the questioner didn't specify which IDE he uses, I see this behavior with Intellij IDEA 8.1.2.