Implementing Comparable with a generic class

Question

I want to define a class that implements the generic Comparable interface. While in my class I also defined a generic type element T. In order to implement the interface, I delegate the comparison to T. Here is my code:

public class Item<T extends Comparable<T>> implements Comparable<Item> {

    private int s;
    private T t;

    public T getT() {
        return t;
    }

    @Override
    public int compareTo(Item o) {
        return getT().compareTo(o.getT());
    }
}

When I try to compile it, I get the following error information:

Item.java:11: error: method compareTo in interface Comparable<T#2> cannot be applied to given types;
        return getT().compareTo(o.getT());
                     ^
  required: T#1
  found: Comparable
  reason: actual argument Comparable 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 Item
    T#2 extends Object declared in interface Comparable
1 error

Can anybody tell me why and how to fix it?

Not 100% sure, but should this: compareTo(Item o) be compareTo(Item<T> o)? — npinti
– npinti, Commented Feb 4, 2014 at 5:41

Radiodef · Accepted Answer · 2018-07-11 14:46:42Z

27

Item (without any type argument) is a raw type, so:

We could pass any kind of Item to Item.compareTo. For example, this would compile:
```
new Item<String>().compareTo(new Item<Integer>())
```
The method o.getT() returns Comparable instead of T, which causes the compilation error.

In the example under the 1st point, after passing Item<Integer> to Item.compareTo, we would then erroneously pass an Integer to String.compareTo. The compilation error prevents us from writing the code which does that.

I think you just need to remove the raw types:

public class Item<T extends Comparable<T>>
implements Comparable<Item<T>> {

    ...

    @Override
    public int compareTo(Item<T> o) {
        return getT().compareTo(o.getT());
    }
}

edited Jul 11, 2018 at 14:46

answered Feb 4, 2014 at 5:42

Radiodef

38k14 gold badges95 silver badges127 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Njol · Accepted Answer · 2014-02-04 05:42:12Z

10

You're using raw types in your class definition (Item<T> is generic, but you're omitting the type parameter <T>), change it to:

class Item<T extends Comparable<T>> implements Comparable<Item<T>>

(Note the last <T>)

The compareTo method will then have to be changed as well:

public int compareTo(Item<T> o) { // again, use generics
    return getT().compareTo(o.getT());
}

answered Feb 4, 2014 at 5:42

Njol

3,28920 silver badges32 bronze badges

Comments

aditya · Accepted Answer · 2014-02-07 06:40:30Z

1

I think, this makes more sense. I have compiled and tested the following :

class Item<E extends Comparable<E>> implements Comparable<E> {

 private int s;
 private E t;

 public E getE() {
     return t;
 }

 @Override
 public int compareTo(E e) {
     return getE().compareTo(e);
 }

 public int compareTo(Item<E> other)
    {
        return getE().compareTo(other.getE());
    }

 }

Notice that you now need to have two compareTo methods.

edited Feb 7, 2014 at 6:40

answered Feb 4, 2014 at 7:10

aditya

2125 silver badges13 bronze badges

6 Comments

Njol Over a year ago

The asker wants items to be comparable (by comparing their values).

Njol Over a year ago

It's possible if T implements Comparable, which is the case here.

aditya Over a year ago

Ya, please have a look at the other solution that I have given now.

Njol Over a year ago

Your answer doesn't make much sense at all. "we are extending comparable and not implementing it." - one implements interfaces and extends classes. extends is used in generics for both cases though. "because we are using a generic type T, we must not override compareTo method" - generic types don't prevent us from implementing interfaces, e.g. ArrayList<T> implements List<T>. "T can be anything [...] Specifically, it has to be something that is Comparable" - T already is Comparable, in both the OP's code and your code, in particular it is comparable to itself.

Njol Over a year ago

That's certainly better.

|

keesp · Accepted Answer · 2021-11-05 10:42:45Z

0

A bit of a related issue that I ran into, and couldn't find a concrete answer.

Suppose you have an interface

public interface myInt extends Comparable<myInt>

And a class MyClass that implements myInt.

Now you only want to compare MyClass with MyClass objects. How should we rewrite the interface and the class?

Answer:

public interface myInt<T extends myInt<T>> extends Comparable<T>
public class MyClass implements myInt<MyClass>

answered Nov 5, 2021 at 10:42

keesp

3212 silver badges13 bronze badges

Collectives™ on Stack Overflow

Implementing Comparable with a generic class

4 Answers 4

Comments

Comments

6 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

6 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related