Implémentation Comparable, compareTo: «avoir le même effacement, mais ni l'un ni l'autre».

J'aimerais avoir une méthode compareTo qui prend un Réel (une classe pour travailler avec arbitrairement grand et précise des nombres réels [eh bien, tant qu'il est à moins de 2^31 de la longueur à l'instant]) et une méthode compareTo qui prend un Objet, mais Java n'est pas de me laisser et je ne suis pas assez expérimenté pour savoir pourquoi.

J'ai juste essayé de modifier la classe pour mettre en œuvre Comparable et j'ai ces messages d'erreur ci-dessous. Je ne comprends pas vraiment ce que la signification des messages d'erreur, mais je sais qu'il a quelque chose à voir avec la manière horrible, je suis en train de donner à la classe une certaine souplesse avec toutes les différentes signatures de méthode pour chaque méthode unique que je fais, et je peux le résoudre en supprimant le compareTo(Object autres) de la méthode, mais j'ai l'idéal serait de le garder. Donc, ce que je suis vraiment se poser est: Est-il un moyen de rendre ces messages d'erreur disparaissent sans enlever le compareTo(Object autres) méthode et exactement ce que ces erreurs veux dire?

Aussi, je sais qu'il y a déjà quelques intégrés dans des classes Java comme BigInteger et des choses comme ça pour ce que je suis en train d'utiliser cette classe, mais je fais ça pour le plaisir/satisfaction pour une utilisation avec Project Euler (https://projecteuler.net/).

Jake@Jake-PC /cygdrive/c/Users/Jake/Documents/Java/Mathematics
$ javac Real.java
Real.java:377: error: name clash: compareTo(Real) in Real overrides a method whose erasure is the same as another method, yet neither overrides the other
  public int compareTo(Real other)
             ^
  first method:  compareTo(Object) in Real
  second method: compareTo(T) in Comparable
  where T is a type-variable:
    T extends Object declared in interface Comparable
Real.java:440: error: name clash: compareTo(Object) in Real and compareTo(T) in Comparable have the same erasure, yet neither overrides the other
  public int compareTo(Object other)
             ^
  where T is a type-variable:
    T extends Object declared in interface Comparable
2 errors

Ce sont les compareTo méthodes:

  @Override
  public int compareTo(Real other)
  {
    //Logic.
  }
  public int compareTo(char givenValue) 
  { return compareTo(new Real(givenValue)); }
  public int compareTo(char[] givenValue) 
  { return compareTo(new Real(givenValue)); }
  public int compareTo(char[] givenValue, int offset, int count) 
  { return compareTo(new Real(givenValue, offset, count)); }
  public int compareTo(double givenValue) 
  { return compareTo(new Real(givenValue)); }
  public int compareTo(float givenValue) 
  { return compareTo(new Real(givenValue)); }
  public int compareTo(int givenValue) 
  { return compareTo(new Real(givenValue)); }
  public int compareTo(long givenValue) 
  { return compareTo(new Real(givenValue)); }
  public int compareTo(Object other) 
  { return compareTo(new Real(other.toString())); }

et les constructeurs juste au cas où vous en avez besoin:

  public Real(String givenValue)
  {
    //Logic.
  }
  public Real(char givenValue) 
  { this(String.valueOf(givenValue)); }
  public Real(char[] givenValue) 
  { this(String.valueOf(givenValue)); }
  public Real(char[] givenValue, int offset, int count) 
  { this(String.valueOf(givenValue, offset, count)); }
  public Real(double givenValue) 
  { this(String.valueOf(givenValue)); }
  public Real(float givenValue) 
  { this(String.valueOf(givenValue)); }
  public Real(int givenValue) 
  { this(String.valueOf(givenValue)); }
  public Real(long givenValue) 
  { this(String.valueOf(givenValue)); }
  public Real(Object other) 
  { this(other.toString()); }

source d'informationauteur Jxek

14

La délinquance méthodes sont les suivantes:
```
@Override
public int compareTo(Real other) { ... }

public int compareTo(Object other) { ... }
```
Ces méthodes ont le même effacementce qui signifie qu'une fois que le compilateur des bandes de type générique de l'information, il n'y aura plus un moyen de les différencier lors de l'exécution.

Vos options sont à supprimer la compareTo(Object other) de surcharge, ou pour Real à mettre en œuvre Comparable<Object>.

Puisqu'elle ressemble à la mise en œuvre de tous vos compareTo surcharges il vous suffit d'instancier un nouveau Real et de le passer à compareTo(Real)je vous suggère de le retirer et de laisser de conversion jusqu'à l'appelant:
```
Real real = ...;
Object compared = ...;

Real comparedAsReal = new Real(compared);
int result = real.compareTo(comparedAsReal);
```

Que vous voulez être en mesure de comparer Real objet de Objectvous pouvez simplement remplacer le implements Comparable<Real> avec implements Comparable<Object>. Ce serait cohérent avec Comparable<T> javadoc qui dit que <T> the type of objects that this object may be compared to.

Ensuite vous avez juste à changer votre code actuel :

//No more @Override
public int compareToReal(Real other)
{
  //Logic.
}
public int compareTo(char givenValue) 
{ return compareToReal(new Real(givenValue)); }
public int compareTo(char[] givenValue) 
{ return compareToReal(new Real(givenValue)); }
public int compareTo(char[] givenValue, int offset, int count) 
{ return compareToReal(new Real(givenValue, offset, count)); }
public int compareTo(double givenValue) 
{ return compareToReal(new Real(givenValue)); }
public int compareTo(float givenValue) 
{ return compareToReal(new Real(givenValue)); }
public int compareTo(int givenValue) 
{ return compareToReal(new Real(givenValue)); }
public int compareTo(long givenValue) 
{ return compareToReal(new Real(givenValue)); }
@Override
public int compareTo(Object other) 
{ return compareToReal(new Real(other.toString())); }

1

C'est un effet secondaire de Java génériques de type effacement de.

Vous êtes à la mise en œuvre d'un interface génériqueComparable, mais cette méthode unique, à la fois générique type effacé deviendra compareTo(Object)donc c'est en contradiction avec votre propre compareTo(Object).

Voici un code minimal à reproduire:
```
class Real implements Comparable<Real>
{
    public int compareTo(Object o)
    {
        return 0;
    }

    @Override
    public int compareTo(Real o)
    {
        return 0;
    }       
}
```

Vous devez vous connecter pour publier un commentaire.