java通用可比成语

Question

I encountered the following piece of a definition for a generic class:

public class binarysearchnode<T extends Comparable<T>> implements Comparable<binarysearchnode<T>>{
.............
}

Please help explaining why a class would specify itself as a Type parameter to comparable while implementing the comparable interface? How would it be different from the following:

public class binarysearchnode<T extends Comparable<T>> implements Comparable<? super (or extends)T>{
.............
}

Answer 1

This makes it possible to compare binarysearchnode s to each other. If it implemented Comparable<T> , that would instead mean that the node could be compared to the value of the node, which would be odd.

Inside the class you will probably find something like this:

T value;

public int compareTo(binarysearchnode<T> other) {
   return value.compareTo(other.value);
}

In order to be able to implement compareTo() like this, the value class ( T ) needs to be comparable to other objects of its class - hence the declaration of <T extends Comparable<T>> in the class definition.

Answer 2

It is because what the class author wants is to be able to write:

b1.compareTo(b2)

where b1 and b2 are binarysearchnode instances. The developer also adds a constraint to T so that T extends Comparable<T> . Probably so that the implementation of Comparable for binarysearchnode can just rely on T instances being Comparable themselves.

More generally, while it is possible for a class C1 to implement Comparable<C2> , ultimately, it makes no sense to do so: this does not mean that an instance of C2 could be comparable to an instance of C1 . And due to type erasure, it would not be possible, for instance, for class C1 to implement both Comparable<C1> and Comparable<C2> .

Also, if binarysearchnode<T> were to implement Comparable<T> directly, you would have at least two problems:

• you would not be able to compare one binarysearchnode<T> to another;
• given a binarysearchnote<T> instance b and a T instance t , you would be able to write b.compareTo(t) but not t.compareTo(b) (since T does not, and cannot, implement Comparable<binarysearchnode<T>> ), and that breaks the Comparable contract.

Answer 3

Let's say you have a superclass A and a subclass B . Imagine the superclass implements Comparable<A> , then B will also implement Comparable<A> through inheritance.

Your binarysearchnode class declared as such :

public class binarysearchnode<T extends Comparable<T>>

will not be able to take B as a type parameter for T ( B does not implement Comparable<B> ) But when defined as such :

public class binarysearchnode<T extends Comparable<? super T>>

it will be able to take B as a type parameter for T , since B implements Comparable<A> which fulfills Comparable<? super T> Comparable<? super T> .