[英]Implementing Comparable, compareTo name clash: “have the same erasure, yet neither overrides the other”
I'd like to have a compareTo method that takes a Real (a class for working with arbitrarily large and precise real numbers [well, as long as it's less than 2^31 in length at the moment]) and a compareTo method that takes an Object, but Java isn't letting me and I'm not experienced enough to know why. 我想有一个compareTo方法,它接受一个Real(一个用于处理任意大而精确的实数的类[好吧,只要它的长度小于2 ^ 31])和compareTo方法一个对象,但Java不让我,我没有足够的经验知道为什么。
I just tried to modify the class to implement Comparable and I got these error messages below. 我只是尝试修改类来实现Comparable,我在下面收到了这些错误消息。 I don't really understand what the error messages mean but I know it's got something to do with the horrible way I'm trying to give the class some flexibility with all the different method signatures for every single method I make, and I can fix it by removing the compareTo(Object other) method, but I would ideally like to keep it. 我真的不明白错误信息是什么意思但我知道这与我可怕的方式有关,我试图给我的课程一些灵活性,我为每一种方法制作所有不同的方法签名,我可以解决它通过删除compareTo(Object other)方法,但我最好保留它。 So what I'm really asking is: Is there a way to make these error messages disappear without removing the compareTo(Object other) method and what exactly do these errors mean? 所以我真正要问的是:有没有办法让这些错误消息消失而不删除compareTo(Object other)方法,这些错误究竟是什么意思?
Also, I know there are already some built-in Java classes like BigInteger and things like that for what I'm trying to use this class for but I'm doing it for fun/satisfaction for use with Project Euler ( https://projecteuler.net/ ). 另外,我知道已经有一些像BigInteger这样的内置Java类,以及我正在尝试使用这个类的东西,但我正在为了与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
These are the compareTo methods: 这些是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())); }
and the constructors just in case you need them: 和构造函数,以防万一你需要它们:
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()); }
The offending methods are: 违规方法是:
@Override
public int compareTo(Real other) { ... }
public int compareTo(Object other) { ... }
These methods have the same erasure , meaning that once the compiler strips out generic type information, there will no longer be a way to differentiate them at runtime. 这些方法具有相同的擦除 ,这意味着一旦编译器去掉泛型类型信息,就不再有办法在运行时区分它们。
Your options are to either remove the compareTo(Object other)
overload, or for Real
to implement Comparable<Object>
. 您可以选择删除compareTo(Object other)
重载,或者Real
实现Comparable<Object>
。
Since it looks like the implementations of all your compareTo
overloads just instantiate a new Real
and pass it to compareTo(Real)
, I'd suggest removing them and leaving that conversion up to the caller: 由于看起来所有compareTo
重载的实现只是实例化一个新的Real
并将其传递给compareTo(Real)
,我建议删除它们并将该转换留给调用者:
Real real = ...;
Object compared = ...;
Real comparedAsReal = new Real(compared);
int result = real.compareTo(comparedAsReal);
Since you want to be able to compare Real
object to Object
, you may just replace the implements Comparable<Real>
with implements Comparable<Object>
. 由于您希望能够将Real
对象与Object
进行比较,因此您可以使用implements Comparable<Object>
替换implements Comparable<Real>
implements Comparable<Object>
。 This would be consistent with Comparable<T>
javadoc which says that <T> the type of objects that this object may be compared to
. 这与Comparable<T>
javadoc一致,后者表示<T> the type of objects that this object may be compared to
。
Then you just have to change your current code 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())); }
This is a side effect of Java generics type-erasure . 这是Java泛型类型擦除的副作用。
You are implementing a generic interface , Comparable, but this its unique method, once generic type erased will become compareTo(Object) , hence it clashes with your own compareTo(Object) . 您正在实现一个通用接口 ,Comparable,但这是一个独特的方法,一旦擦除泛型类型将成为compareTo(Object) ,因此它与您自己的compareTo(Object)冲突。
Here is a minimal code to reproduce: 这是一个重现的最小代码:
class Real implements Comparable<Real>
{
public int compareTo(Object o)
{
return 0;
}
@Override
public int compareTo(Real o)
{
return 0;
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.