How do I best implement a comparable parameterized class?

Question

I am trying to implement a parameterized Wrapper class that I want to make Comparable, and the ordering is supposed to
be consistent with equals(). How can this be done? I'm kind of lost ...
My first approach looked like this:
class Wrapper<T> implements Comparable<Wrapper<T>> {
  private T theObject;
  public Wrapper(T arg) { theObject = arg; }
  public boolean equals(Object other) {
    if (this == other) return true;
    if (other == null) return false;
    if (getClass() != other.getClass()) return false;
    ... comparison of theObject based on T.equals() ...
  public int hashCode() { ... }
  public int compareTo(Wrapper<T> other) {
    if (this == other) return 0;
    if (other == null) throw new NullPointerException();
    ... comparison of theObject based on T.compareTo() ...
}This does not work, because I cannot invoke T.compareTo(), since T's bound it Object. Okay, it makes sense to perform
comparison only against wrappers around something that is comparable to T. Next try:
class Wrapper<T> implements Comparable<Wrapper<? extends Comparable<T>>> {
  public int compareTo(Wrapper<? extends Comparable<T>> other) {
    if (this == other) return 0;
    if (other == null) throw new NullPointerException();
    ... comparison of theObject based on T.compareTo() ...
}Now it compiles and I can compare a Wrapper<Integer> to a Wrapper<Integer>. But I cannot compare a Wrapper<Number> to
a Wrapper<Integer>, although the Wrapper<Number> may well contain a reference to an Integer object that is
comparable to the Integer in the other wrapper and the comparison is meaningful in such a case. Simply for reasons
of consistency with equals() I want to compare Wrapper<Integer> and Wrapper<Number>, but with the implementation above
I can't:
          Wrapper<Integer> p0 = new Wrapper<Integer>(10000);
          Wrapper<Number> p2 = new  Wrapper<Number>(10000);
          boolean equ = false;
          equ = p0.equals(p2);
          equ = p2.equals(p0);     
          int less = 0;
          less = p0.compareTo(p2);
          less = p2.compareTo(p0);The error messages say:
compareTo(Wrapper<? extends Comparable<Integer>>) in Wrapper<Integer> cannot be applied to (Wrapper<Number>)
          result = p0.compareTo(p2);
                           ^
compareTo(Wrapper<? extends Comparable<Number>>) in Wrapper<Number> cannot be applied to (Wrapper<Integer>)
          result = p2.compareTo(p0);
                           ^Okay, a Wrapper<Number> is not comparable to a Wrapper<Integer>. Obviously, the wildcard "? extends Comparable<T>" is
too restrictive. So I tried "? extends Comparable<?>", but then I cannot invoke T.compareTo(). Hence I use the raw
type Comparable:
class Wrapper<T> implements Comparable<Wrapper<? extends Comparable>> {
  public int compareTo(Wrapper<? extends Comparable> other) {
    if (this == other) return 0;
    if (other == null) throw new NullPointerException();
    ... comparison of theObject based on T.compareTo() ...
}Now, it is asymmetric; I can pass Wrapper<Integer> to Wrapper<Number>.compareTo(Wrapper<? extends Comparable>), but I
cannot pass Wrapper<Number> to Wrapper<Integer>.compareTo(Wrapper<? extends Comparable>). I see, Number is simply not
comparable to anything.
Is there a way to express that a Wrapper<T> shall be comparable to another Wrapper<U> where U is comparable to T or is
a supertype of something that is comparable to T? The wildcard Wrapper<? super Comparable<T>> isn't what I'm looking
for; it requires that Comparable<Integer> would be a subtype of Number, which it is not.
Eventually the best implementation I can come up with is this one:
class Wrapper<T> implements Comparable<Wrapper> {
  public int compareTo(Wrapper other) {
    if (this == other) return 0;
    if (other == null) throw new NullPointerException();
    ... comparison of theObject based on T.compareTo() plus a cast to Comparable<T> ...
}As soon as I try to be more specific and require that the wrapped object must be somehow comparable I cannot get
access to a comparable object through a non-comparable supertype any longer. I had somehow hoped that wildcards would
help expressing things like this, but that's a misconception, right?
Or does anybody have an idea how to express my intent in terms of wildcards or any other Java feature?

Answer 1

Have you tried the following declaration:
class Wrapper<T extends Comparable<T>> implements Comparable<Wrapper<T>> This should pass the restriction imposed on T upwards
to the super-interface.
Maybe that works as you expected?It's more restricted than I want because then all my wrappers would be wrappers around a comparable object and I cannot have a Wrapper<Number> any longer. Perhaps that's what I will resort to: a Wrapper, a ComparableWrapper, a CloneableWrapper, ...
>
BTW, what is this declaration of yours supposed to
mean:
class Wrapper<T> implements Comparable<Wrapper<? extends Comparable<T>>>
I think it is a wrapper that is comparable to another wrapper and that other wrapper contains an object that is comparable to T. It does not have to be a T, it suffices that it is comparable to T.
My gut feeling says that the use of wildcards in the
supertype of a derived class declaration should not be
legal, since it would render the supertype of
Wrapper<T> into a "family" of supertypes. Doesn't make
any sense to me, but if the compiler swallows it, then
it's probably just my limited understanding...The use of the wildcard in not in the supertype; it is in the type argument of the type argument of the supertype. A declaration such as ... implements Comparable<? extends Wrapper<T>> would be illegal, as far as I understand wildcards.