Downcasting a subclass of a concrete generic

Question

Hi--
Been puzzling over this one for quite awhile, and I still can't figure it out. I'm trying to downcast a generic type to a subclass of a concrete type. Now admittedly that's messy and I'd like to refactor, but I'm still puzzled. Take the following code:
public class Test1<T> {
    protected final T obj;
    public Test1(T obj) {
     this.obj = obj;
    public static void main(String[] args) {
     Test1<?> testObj = new Test2("hello");
     System.err.println("Calling a method: " + ((Test2) testObj)).aMethod());
public class Test2 extends Test1<String> {
    public Test2(String obj) {
     super(obj);
    public String aMethod() {
     return obj;
}This fails to compile, saying that Test1<capture of ?> isn't convertible to Test2.
Now suppose I change to the following:
public class Test1<T> {
    protected final T obj;
    public Test1(T obj) {
     this.obj = obj;
    public static void main(String[] args) {
     Test1<?> testObj = new Test2<String>("hello");
     System.err.println("Calling a method: " + ((Test2) testObj).anotherMethod());
public class Test2<T extends String> extends Test1<T> {
    public Test2(T obj) {
     super(obj);
    public String anotherMethod() {
     return obj;
}Here all I've done is add a parameter to the Test2 type that gives the same information available in item 1. In this case, however, it compiles and runs fine.
Even more oddly, the following also works and does not produce any warnings:
public class Test1<T> {
    protected final T obj;
    public Test1(T obj) {
     this.obj = obj;
    public static void main(String[] args) {
     Test1<?> testObj = new Test2("hello");
     System.err.println("Calling a method: " + ((Test2) ((Test1) testObj)).anotherMethod());
public class Test2 extends Test1<String> {
    public Test2(String obj) {
     super(obj);
    public String anotherMethod() {
     return obj;
}So essentially the system is ok as long as I cast the generic type to a raw type, and then downcast to the subclass of the concrete type... but I can't do the cast directly?
My feeling is that Java is being a little overly touchy about trying to prevent casting to a concrete type-- in the case where the type you're trying to cast to is itself not generic, shouldn't that be allowed? Or am I missing something subtle about how the generics work?

Answer 1

Correct me if I'm wrong, but I think this may be your problem:
public class Test2 extends Test1<String> {
}This means that Test2 is a subclass of Test1<String> -- not Test1<?>. Here's why.
If we "expand out," say, Test1<Integer> and Test1<String>, we get the following:
public class Test1String {
   protected final String obj;
   public Test1String(String obj) {
   this.obj = obj;
public class Test1Integer{
   protected final Integer obj;
   public Test1Integer(Integer obj) {
   this.obj = obj;
}Now, it's easy to see that inheriting from each of these classes yields completely different results. Once you've parameterized a class, it becomes a completely different beast. Sooo, saying that
Test1<?> testObj = new Test2("hello");could be the same thing as saying (since ? means any parameter), in our expanded form,
Test1Integer testObj = new Test2("hello"); //aka, a new Test1String
//or Test1Object, Test1MyComplicatedType, whateverwhich is clearly not allowed, since all the fields would be of a completely different type.
I hope this helps!