无法将有效常量（值）分配给通用类型变量

Question

Why does the following not work?

void execute() {
 Integer a = Integer.valueOf(1);

 a = reassign(a);

 D.log("a: " + a);
}

<T extends Integer> T reassign(T t) {
  t = Integer.valueOf(2); // error: incompatible types: Integer cannot be converted to T
  // t = (T) Integer.valueOf(2); // This works but with  warning: [unchecked] unchecked cast
  return t;
}

<T extends Integer> T reassign2(T t, T anotherT) {
  t = anotherT; // This works without any warning.
  return t;
}

My understanding is that generic methods/classes/interfaces will be compiled to a single class file where the type parameter is replaced with most appropriate lower bound (Integer in the above case).

Java env: java 11.0.4 2019-07-16 LTS

Answer 1

My understanding is that generic methods/classes/interfaces will be compiled to a single class file where the type parameter is replaced with most appropriate lower bound

Your understanding is correct, but compilers are designed to handle generics more intelligently. If compilers are designed exactly the way you described, what's the point of generics? I could just write a method taking an Integer instead. There's no need for generics, since the compiler will just replace whatever type parameter I have with Integer anyway.

You have specified that T must be Integer or a subclass of Integer . Think about the situation when T is a subclass of Integer , would the following assignment still work? It wouldn't!

t = Integer.valueOf(2); // you are assigning an instance of a superclass to a subclass variable

You could argue that Integer cannot have any subclasses as it is final , but the compiler is not designed to check for the final ness of classes in this situation. Using Integer as a bound here probably means that reassign shouldn't be generic at all.

---

Another thing that the compiler do is to insert casts where necessary, but that's not really relevant to this question.

Answer 2

The reason why it doesn't work is because the compiler can't prove that T is actually and not a subtype of T . Integer is a bad example here because it is final and no one can extend it but the compile is not smart enough to know that and reason about it.

Imagine you have the following

 class Foo{
 }

 class Bar extends Foo {
 }

and you call reassign like this

reassign(new Bar());

Where reassign was allowed to do

<T extends Foo> T reassign(T t){
    t = new Foo();
    return t;
}

then this would be equivalent of saying

Bar b = new Foo()

Which is not valid of course