Реализация Comparable, compareTo name collash: "имеют одно и то же стирание, но не переопределяет другое"

Я хотел бы иметь метод compareTo, который принимает Real (класс для работы с произвольно большими и точными действительными числами [ну, пока он меньше 2 ^ 31 в длину в данный момент]) и compareTo метод, который принимает объект, но Java не позволяет мне, и я недостаточно опытен, чтобы знать, почему.

Я просто попытался изменить класс для реализации Comparable, и я получил эти сообщения об ошибках ниже. Я действительно не понимаю, что означают сообщения об ошибках, но я знаю, что это связано с ужасным способом, которым я пытаюсь дать классу некоторую гибкость со всеми различными сигнатурами метода для каждого метода, который я делаю, и я могу исправить это, удалив метод compareTo (Object other), но я бы идеально хотел его сохранить. Так что я действительно спрашиваю: есть ли способ, чтобы эти сообщения об ошибках исчезали, не удаляя метод compareTo (Object other) и что именно означают эти ошибки?

Кроме того, я знаю, что уже есть некоторые встроенные классы Java, такие как BigInteger и т.д. для того, что я пытаюсь использовать для этого класса, но я делаю это для удовольствия/удовлетворения для использования с Project Euler (https://projecteuler.net/).

[email protected] /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

Это методы compareTo:

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

и конструкторы на случай, если они вам понадобятся:

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

Ответ 1

Способы оскорбления:

@Override
public int compareTo(Real other) { ... }

public int compareTo(Object other) { ... }

Эти методы имеют одинаковую erasure, а это означает, что, как только компилятор вычеркивает информацию общего типа, больше не будет способа дифференцировать их во время выполнения.

Ваши варианты должны либо удалить перегрузку compareTo(Object other), либо для Real для реализации Comparable<Object>.

Так как это выглядит как реализация всех ваших перегрузок compareTo, просто создайте новый Real и передайте его compareTo(Real), я бы предложил удалить их и оставить это преобразование до вызывающего:

Real real = ...;
Object compared = ...;

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

Ответ 2

Поскольку вы хотите сравнить объект Real с Object, вы можете просто заменить implements Comparable<Real> на implements Comparable<Object>. Это будет соответствовать Comparable<T> javadoc, в котором говорится, что <T> the type of objects that this object may be compared to.

Затем вам просто нужно изменить текущий код на:

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

Ответ 3

Это побочный эффект стирания стилей Java generic.

Вы реализуете общий интерфейс, Comparable, но этот уникальный метод после стирания типового типа станет compareTo (Object), поэтому он сталкивается с вашим собственным compareTo (Object).

Вот минимальный код для воспроизведения:

class Real implements Comparable<Real>
{
    public int compareTo(Object o)
    {
        return 0;
    }

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