为什么通用约束T扩展了可比性 <T> 还不足以避免演员阵容？

Question

I have a class like this:

public class AbstractParameter<T extends Comparable> {
  ....
    public void validate(T tempVal, StringBuilder msg) {
        if(tempVal.compareTo(new Integer(0)) != 0 ) {
            //do something
        }
    }
  ....
}

The tempVal will be an Integer. It compiles and runs fine. But if I change the T extends Comparable to T extends Comparable<T> Above if statement generated the following compile error:

required: T#1
found: Integer
reason: actual argument Integer cannot be converted to T#1 by method invocation conversion
where T#1,T#2 are type-variables:
  T#1 extends Comparable<T#1> declared in class AbstractParameter
  T#2 extends Object declared in interface Comparable

I can cast the new Integer(0) to T to remove the compile error. My question is should I use public class AbstractParameter<T extends Comparable> or public class AbstractParameter<T extends Comparable<T>> ?

I guess the public class AbstractParameter<T extends Comparable<T>> should be the way to go but that (T)new Integer(0) cast seems annoyance. Is there anything wrong in my code?

Answer 1

Because the type of the parameter to Comparable<T>.compareTo() is T, and you are sending an integer, which is not compatible. Ask yourself this: if you know that tempVal is an Integer , why do you declare it as T?

Answer 2

public abstract class AbstractParameter implements Comparable will produce compilation error because inside validate you are invoking compareTo on tempVal and Since there is no Upperbound on T(T can be anything) the compiler can't resolve method tempVal.compareTo(...)

You mentioned that "The tempVal will be an Integer" in your post. So change the class definition to include this info in order to avoid unchecked warning

public abstract class AbstractParameter<T extends Comparable<Integer>>