La mise en œuvre de Comparable avec une classe générique

Je veux définir une classe qui implémente le générique de l'interface Comparable. Alors que dans ma classe, j'ai également défini un type générique élément T. Afin de mettre en œuvre l'interface, j'ai délégué la comparaison de T. Voici mon 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());
    }
}

Lorsque j'essaie de compiler, je reçois les informations d'erreur suivant:

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

Quelqu'un peut-il me dire pourquoi et comment le résoudre?

Pas sûr à 100%, mais il faut: compareTo(Item o) être compareTo(Item<T> o)?
pour de meilleurs résultats, utilisez <T extends Comparable<? super T>>
Vous devez sélectionner une réponse pour cette question.

OriginalL'auteur frank.liu | 2014-02-04

  1. 17

    Item (sans argument) est un raw type, donc:

    1. Nous avons pu passer de tout type de Item à Item.compareTo. Par exemple, ce serait de compiler:

      new Item<String>().compareTo(new Item<Integer>())

    2. La méthode o.getT() retourne Comparable au lieu de T, ce qui provoque l'erreur de compilation.

      Dans l'exemple le 1er point, après le passage de Item<Integer> à Item.compareTo, nous aurions alors le tort de passer un Integer à String.compareTo. L'erreur de compilation, qui nous empêche d'écrire le code qui le fait.

    Je pense que vous avez juste besoin de retirer le 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());
    }
}

    OriginalL'auteur Radiodef

  2. 7

    Vous êtes à l'aide de matières types dans la définition de votre classe (Item<T> est générique, mais vous êtes en omettant le paramètre de type <T>), le modifier:

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

    (Notez que le dernier <T>)

    La compareTo méthode devra ensuite être modifié ainsi:

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

    OriginalL'auteur Njol

  3. 1

    Je pense, cela fait plus de sens. J'ai compilé et testé les suivantes : 

    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());
    }

 }

    Notez que vous devez maintenant avoir deux compareTo méthodes.

    Le demandeur veut éléments comparables (en comparant leurs valeurs).
    C'est possible si T implémente Comparable, ce qui est le cas ici.
    Ay, veuillez jeter un oeil à l'autre solution que j'ai donnée à maintenant.
    Votre réponse n'a pas beaucoup de sens. "nous sommes l'extension comparable et ne pas la mettre en œuvre." - on met en oeuvre des interfaces et s'étend classes. extends est utilisé dans les génériques pour les deux cas. "parce que nous sommes à l'aide d'un type générique T, nous ne devons pas ignorer méthode compareTo" - types génériques ne nous empêche pas de mettre en œuvre des interfaces, par exemple ArrayList<T> implémente List<T>. "T peut être n'importe quoi [...] plus Précisément, il doit être quelque chose qui est Comparable" - T est déjà Comparable, dans le cas des OP de code et de votre code, en particulier, il est comparable à lui-même.
    C'est certainement mieux.

    OriginalL'auteur aditya