Raw types and Generics -- Java

Question

Possible Duplicate:
Is List<Dog> a subclass of List<Animal>? Why aren't Java's generics implicitly polymorphic?
Java Generics — Assigning a list of subclass to a list of superclass

With raw types you can easily say something like this.

[...] // MyClass is generic with upper bound of Object

MyClass c = new MyClass<Double>();

[...]

But this isn't allowed

MyClass<Number> c = new MyClass<Double>() 

I don't understand why this is. My book tells me why the second doesn't work, because you can't add a Integer to a MyClass<Double>. What it doesn't explains is why MyClass<Double> is a subclass of MyClass<Object> (or the equivalent raw type form), since double is subclass of object.

So why is the first allowed if the second form isn't. Please realize I am new to this.

Edit: Taking it a step further what would happen in the first example if Number was the upper bound?

You can see here the effects of type erasure

class Untitled {
public static void main(String[] args) {

}
public static<T> void c(T t)
{
    t.SubClassMethod();// this won't work because class Object has no such method. But if I change the upperbound to SubClass it will.
            t.toString() // this will because class Object has such a method
}
}

My point is that why should it matter what the Generic is declared as if it ultimately becomes treated as the upper bound anyway?

Answer 1

Try this:

MyClass<? extends Number> c = new MyClass<Double>();

Answer 2

Suppose that MyClass is like this:

public class MyClass<T>{
  T value;

  public void foo(T arg){
    value = arg;
  }
}

and then those two other classes:

class A{ }

class B extends A { }

now imagine what happens if you do:

MyClass<A> container = new MyClass<B>();
container.foo(new A());

you'd try to put an A into a field of type B. The restriction you are facing is thought to prevent such things. C# has a nifty solution in terms of in and out parameters to generics...

Answer 3

The first thing to eliminate your confusion is to understand that the Raw Type is not part of the generics system at all. It is in no way equivalent to Something<Object>. Basically, the reason the Raw Type exists at all is just for backward compatibility. When Generics were introduced in Java 5, some existing classes and interfaces were retroactively made generic. In order for old code that didn't have generic declarations to compile in the Java 5 or later compiler, the Raw Declarations are legal.

Any comparison between the way the Raw Type behaves and the way the Parameterized type behaves is in a way a bit fundamentally spurious. The intent of the design is not that the Raw Type be considered an 'alternative' to declaring a parameter. New code that uses the Raw Type is incorrect code. It's legal to compile it so that old code still works.

My point is that why should it matter what the Generic is declared as if it ultimately becomes treated as the upper bound anyway?

Because the entire point of the generics is to prevent ClassCastException. It will be treated as the actual declared type when someone, for example, someone takes the object back out of the list and assigns it to the specific type they're expecting. The compiler is making a promise that it guarantees this will succeed, so it has to restrict what goes in and out.

Answer 4

Any MyClass<XXX> is a MyClass, but contrary to what you are saying, MyClass<Double> is not a subclass of MyClass<Object>.

You can find more about it if you search for erasure, like here.