Me gustaría tener un método compareTo que tome un Real (una clase para trabajar con números reales arbitrariamente grandes y precisos [bueno, siempre que tenga menos de 2 ^ 31 de longitud en este momento]) y un método compareTo que tome un objeto, pero Java no me lo permite y no tengo la experiencia suficiente para saber por qué.

Intenté modificar la clase para implementar Comparable y recibí estos mensajes de error a continuación. Realmente no entiendo lo que significan los mensajes de error, pero sé que tiene algo que ver con la horrible manera en que trato de dar a la clase algo de flexibilidad con todas las firmas de métodos diferentes para cada método que hago, y puedo solucionar eliminando el método compareTo (Objeto otro), pero lo ideal sería mantenerlo. Entonces, lo que realmente pregunto es: ¿hay una manera de hacer que estos mensajes de error desaparezcan sin eliminar el método compareTo (Objeto otro) y qué significan exactamente estos errores?

Además, sé que ya hay algunas clases integradas de Java como BigInteger y cosas por el estilo para las que estoy tratando de usar esta clase, pero lo hago por diversión / satisfacción para usar con el Proyecto 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

Estos son los métodos 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())); }

y los constructores por si los necesitas:

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