Блог

Вот пример из моего кода:

Базовый класс:

 abstract class AbstractBase implements Comparable<AbstractBase> {
    private int a;
    private int b;

    public int compareTo(AbstractBase other) {
        // compare using a and b
    }
}
  

Реализация:

 class Impl extends AbstractBase {
private int c;

public int compareTo(Impl other) {
    // compare using a, b and c with c having higher impact than b in AbstractBase
}
  

FindBugs сообщает об этом как о проблеме. Но почему это так? Что может произойти?

И как мне правильно реализовать решение?

Impl#compareTo(Impl) не является переопределяющим AbstractBase#compareTo(AbstractBase) , поскольку они не имеют одинаковой подписи. Другими словами, он не будет вызываться при использовании Collections#sort , например.

РЕДАКТИРОВАТЬ: добавлено решение без приведения

Если вы не хотите выполнять приведение, вы можете попробовать следующее.

Измените свой базовый класс на:

 abstract class AbstractBase<T extends AbstractBase<?>> implements Comparable<T> {
//...
    public int compareTo(T other) {
      //... 
    }
}
  

И вы применяете класс к:

 class Impl extends AbstractBase<Impl> {
//...
    @Override
    public int compareTo(Impl other) {
    //...
    }
}
  

Решение с приведением:

Возможным решением было бы переопределить метод compareTo(AbstractBase) в классе Impl и явно проверить, передается ли экземпляр Impl в:

    class Impl extends AbstractBase {
   //...
        @Override
        public int compareTo(AbstractBase other) {

            if (other instanceof Impl) {

                int compC = Integer.compare(c, ((Impl) other).c);

                if (compC == 0) {
                    return super.compareTo(other);
                }
                return compC;
            }

            return super.compareTo(other);
        }
    }
  

Я попробовал следующее. Не совсем уверен, что это причина, по которой findbugs выдает ошибку.

Смотрите следующий код с гипотетической реализацией compareTo метода.

Сравнение одних и тех же объектов приводит к разным результатам.

 public class Main
{
  public static void main(String[] args)
  {
    Impl implAssignedToImpl = new Impl(1, 2, 3);
    Impl otherImpl = new Impl(3, 2, 1);
    System.out.println(implAssignedToImpl.compareTo(otherImpl)); // prints -2

    AbstractBase implAssignedToAbstract = implAssignedToImpl;
    System.out.println(implAssignedToAbstract.compareTo(otherImpl)); //prints 0
  }
}

class AbstractBase implements Comparable<AbstractBase>
{
  private int a;

  private int b;

  public AbstractBase(int a, int b)
  {
    super();
    this.a = a;
    this.b = b;
  }

  public int compareTo(AbstractBase other)
  {
    return (a   b) - (other.a   other.b);
  }
}

class Impl extends AbstractBase
{
  private int c;

  public Impl(int a, int b, int c)
  {
    super(a, b);
    this.c = c;
  }

  public int compareTo(Impl other)
  {
    return super.compareTo(other)   (c - other.c);
  }
}
  

Основываясь на моей гипотезе compareTo , следующее кажется хорошим решением. Вы можете попробовать использовать метод, аналогичный getSum которому, который присваивает экземпляру объекта значение.

 public class Main
{
  public static void main(String[] args)
  {
    Impl implAssignedToImpl = new Impl(1, 2, 3);
    Impl otherImpl = new Impl(3, 2, 1);
    System.out.println(implAssignedToImpl.compareTo(otherImpl)); // prints 0

    AbstractBase implAssignedToAbstract = implAssignedToImpl;
    System.out.println(implAssignedToAbstract.compareTo(otherImpl)); //prints 0
  }
}

class AbstractBase implements Comparable<AbstractBase>
{
  private int a;

  private int b;

  public AbstractBase(int a, int b)
  {
    super();
    this.a = a;
    this.b = b;
  }

  public int compareTo(AbstractBase other)
  {
    return getSum() - other.getSum();
  }

  public int getSum()
  {
    return a   b;
  }
}

class Impl extends AbstractBase
{
  private int c;

  public Impl(int a, int b, int c)
  {
    super(a, b);
    this.c = c;
  }

  @Override
  public int getSum()
  {
    return super.getSum()   c;
  }
}
  

Как сказал sp00m, ваша Impl#compareTo(Impl) подпись отличается AbstractBase#compareTo(AbstractBase) от, поэтому она не перегружает ее.

Ключевой момент заключается в понимании того, почему он не работает, даже когда вы пытаетесь sort() сравнить с другим Impl , где более конкретная подпись совпадает.

 Impl >>>
int compareTo(AbstractBase other) {
    return other.compareToImpl(this);
}

int compareToImpl(Impl other) {
    // perform custom comparison between Impl's
}

AbstractBase >>>
int compareTo(AbstractBase other) {
    // generic comparison
}

int compareToImpl(Impl other) {
    // comparison between an AbstractBase and an Impl.
    //Probably could just "return this.compareTo(other);", but check for loops :)
}