Java- The meaning of <T extends Comparable<T>>?
Solution 1
This means that the type parameter must support comparison with other instances of its own type, via the Comparable interface.
An example of such a class is provided in the Oracle tutorial Object Ordering. Note the similar pattern to T extends Comparable<T>
in the excerpt below:
public class Name implements Comparable<Name> {
...
public int compareTo(Name n) { ... }
}
Solution 2
Java- The meaning of <T extends Comparable<T>>
?
a) Comparable <T>
is a generic interface (remember it's an "interface" i.e not a "class")
b) extends
means inheritance from a class or an interface.
From above-said point#a, it is an interface..(Remember it is an inheritance from an "interface" i.e not from a "class")
c)From above-said both points #a & #b,
here "one interface" extends "another interface".
There should be an interface defined for this class.. just an example here is
interface MinMax<T extends Comparable<T>> {
T min();
T max();
}
d) now your class i.e public class RClass {}
SHOULD
1# EITHER "implement" this "generic interface" Comparable<T>
..!!!
ex: public class RClass<T> implements Comparable<T>
2# OR create an interface and extend to this "generic interface" Comparable<T>
ex:
interface MinMax<T extends Comparable<T>> {
T min();
T max();
}
class RClass<T extends Comparable<T>> implements MinMax<T> {
.....
.....
}
Here,
Pay special attention to the way that the type parameter T is declared by RClass and
then passed to MinMax
. Because MinMax
requires a type that implements Comparable
,
the implementing class (RClass in this case) must specify the same bound. Furthermore,
once this bound has been established, there is no need to specify it again in the implements clause.
Solution 3
Somewhere in that class, the programmer needs to write something like
if(t.compareTo(othert) < 0) {
...
}
For that to work, the type T must have a compareTo-method which compares it to another object of type T. Extending Comparable guarantees the existence of such a method, among other things.
Solution 4
It means that you can only create an instance of RClass
with a type which quite literally extends Comparable<T>
. Thus,
RClass<Integer> a;
is acceptable, since Integer
extends Comparable<Integer>
, while
RClass<Object> b;
is not, since Object
is not a class which extends comparable at all.
Solution 5
Yes, and bear in mind that objects of classes derived from Comparable
ARE Comparable
objects. Inheritance is a is-a
relationship.
LTH
Updated on July 09, 2022Comments
-
LTH almost 2 years
The full context being:
public class RClass<T extends Comparable<T>>
Would I be right in saying that the statement in the title means that the arguments plugged into the method must either be an object of a class which implements Comparable OR one of its derived classes?
Thanks.
-
committedandroider about 9 yearsWhy not just have Name implements Comparable? Why need to specify the class name again?
-
Alex Bitek almost 9 years@committedandroider because Comparable is a generic interface you need to specify the type
-
Sathish Kumar k k over 8 yearsIn the question, it's been asked that
public **class** RClass<T extends Comparable<T>>
. It's a class and not an interface. So please comment on what will be the meaning if it's a class. -
flow2k almost 6 yearsThis is a good answer. But it's interesting in bounded generic types, Java doesn't differentiate between interface implementation and class inheritance -
<T implements Comparable<T>>
is not legal. -
Jesse Zhuang about 4 yearsgreat answer. question: why
class A<T extends Comparable<T>>
but notclass A<T implements Comparable<T>>
? For example,A
can beA<Integer>
. HereInteger
isT
andInteger
classimplements
Comparable<Integer>`. -
piepi almost 3 yearsWhy is extends allowed here if
Comparable
is an interface? Shouldn't it beimplements
? You can't extend an interface. -
Andy Thomas almost 3 years@piepi - Because it's useful, and because the JLS says so. Using a single keyword to indicate subtyping in generic type parameters allows cases like
T extends U
, that work whether U is a class type or interface type. This differs from class declarations, in which you're subtyping known (though possibly parameterized) types.