Downcasting from generic bases

[Christopher Benson-Manica]

Why isn't this legal?

public class TestIt {
private static class Foo<T> {
}

private static class Bar extends Foo<Integer> {
}

private static void Baz( Foo<?> foo ) {
if( foo instanceof Bar ) { // "inconvertible types" error
}
}
}

And since that's not legal, why exactly does it become legal if the
parameter foo is of the raw type Foo? I clearly don't understand
generics completely and it seems perverse that I can't ask a
superclass if it's an instance of a base class just because of the
generic type paramters.

 

[Joshua Cranmer]

Why isn't this legal?

public class TestIt {
private static class Foo<T> {
}

private static class Bar extends Foo<Integer> {
}

private static void Baz( Foo<?> foo ) {
if( foo instanceof Bar ) { // "inconvertible types" error
}
}
}

And since that's not legal, why exactly does it become legal if the
parameter foo is of the raw type Foo? I clearly don't understand
generics completely and it seems perverse that I can't ask a
superclass if it's an instance of a base class just because of the
generic type paramters.

Generics are sometimes confusing. Here is why it gives you an error:

private class Foo<T> {
protected T doSomething();
}

private class Bar extends Foo<Integer> {
protected Integer doSomething();
}

foo1 = new Foo<Integer>();
foo2 = new Bar();
foo1.doSomething();
foo2.doSomething();

Erasing the types, the first method will return Object and the second
Integer. Then, foo2's doSomething will become ambiguous in your code.
The return type would become ambiguous because of the cast.

Yes, I know it seems overprotective, but much of generics is like that.

 

[Tom Hawtin]

Why isn't this legal?

public class TestIt {
private static class Foo<T> {
}

private static class Bar extends Foo<Integer> {
}

private static void Baz( Foo<?> foo ) {
if( foo instanceof Bar ) { // "inconvertible types" error
}
}
}

Works for me! Are you using and old or non-Sun compiler?

There are some confusing wildcard situations where you have nesting of
generic types (Foo<Bar<?>>), but this code should not be a problem.

Tom Hawtin

 

[Christopher Benson-Manica]

Works for me! Are you using and old or non-Sun compiler?

No. I mean, yes, but I didn't realize it until just now. Oops!
(I was using 1.5.0_06 - did the language spec change or was this
merely a bug that was fixed in a later version?)