为什么超类通用类型不被擦除/铸造

Question

Consider the following piece of code:

class A<T>{
T t;

public T getValue(){
    return t;
}

class B<S extends Number> extends A<String>{

//some code here..
}

B b = new B<Integer>();
String name = b.getValue() // This throws compilation error

whereas the following works:

B<Integer> b = new B<Integer>();
String name = b.getValue() // This works...!

So my questions are:

1. Do I have to give declare all the generics type involved? (Even though Class A's generic type was declared in Class B.)

2. Or, am I missing something basically?

Answer 1

See JLS 4.8 Raw Types :

a raw type is defined to be [...] the reference type that is formed by taking the name of a generic type declaration without an accompanying type argument list.

The superclasses (respectively, superinterfaces) of a raw type are the erasures of the superclasses (superinterfaces) of any of its parameterized invocations.

In other words, when you use B without <> , it becomes a raw type, basically erasing all generics, all the way up all base classes and interfaces, ie is becomes as if A and B weren't generic:

class A {
    Object t;
    public Object getValue() {
        return t;
    }
}

class B extends A {
    //some code here..
}

Which is why String name = b.getValue() fails, because getValue() is now returning an Object .

---

Note the following comment in the JLS:

The use of raw types is allowed only as a concession to compatibility of legacy code. The use of raw types in code written after the introduction of generics into the Java programming language is strongly discouraged . It is possible that future versions of the Java programming language will disallow the use of raw types.

In short, DON'T . Fix your code to not use raw types.

You can however shorten the right-hand side as follows:

B<Integer> b = new B<>();

Answer 2

The generic value of class B simply has no link with the one from class A.

The method T getValue() of a A(Long) will be Long getValue(), disregarding any genericity on the wrapping class.

If you want an Integer getValue() then simply go for

class B extends A<Integer> {}

EDIT : you change your question, lets change the response :)

B is considered as B (S extends Number, T) (because it extends A). If you store a variable as a raw type B, then its is implicitly B(Object, Object), even if declared properly.

Make test with a List

List l = new ArrayList<String>();
String s = l.get(0);

You will end with the same issue.