Проверьте, переписан ли метод в Java

Question

Я хотел бы реализовать метод, который сравнивает два объекта моего интерфейса Task, Поскольку будет строго строгий порядок Task, partialCompareTo должен вернуться null тогда и только тогда, когда два объекта несопоставимы.

Если вас смущает концепция строгого частичного заказа, проверьте это: https://en.wikipedia.org/wiki/Partially_ordered_set

Мотивация: некоторые задачи будут иметь ограничение, что они должны быть выполнены до или после другой задачи. Затем это используется для топологической сортировки задач, то есть упорядочения их таким образом, чтобы были выполнены все ограничения.

Он должен иметь следующее свойство для любых случаев Taska а также b:

• если a.partialCompareTo(b) != null затем sgn(a.partialCompareTo(b)) = -sgn(b.partialCompareTo(a))
• если a.partialCompareTo(b) = null затем b.partialCompareTo(a) = null

Примечание: я не могу использовать интерфейс Comparable стандартной библиотеки, так как не будет никакого полного упорядочения по Задаче: compareTo в Comparable возвращается intТаким образом, невозможно получить адекватный результат, если два объекта несопоставимы. В частности, будут реализации Task, где экземпляры этих реализаций никогда не будут сопоставимы друг с другом (но могут быть сравнимы с экземплярами других подклассов Task, которые переопределяют partialCompareTo).

Идея состоит в том, чтобы использовать partialCompareTo метод аргумента, если он переопределяет метод, указанный в классе Task,

Следующий подход на самом деле больше шутка, чем реальная попытка, поскольку каждый раз, когда сравниваются два несопоставимых объекта, мы получаем StackruError (который перехватывается, но в любом случае это неосуществимо):

public class Task implements TopologicalComparable<Task> {

    /*
     * other code
     */

    @Override
    public Integer partialCompareTo(Task other) {
        Integer result;
        try {
            result = - other.partialCompareTo(this);
        } catch (StackruError | NullPointerException e) {
            return null;
        }
        return null;
    }

}

Следующая реализация явно лучше, но у нее есть и недостаток: всегда нужно переопределять вспомогательный метод overridesDefaultPartialCompareTo:

public class Task implements TopologicalComparable<Task> {

    /*
     * other code
     */

    @Override
    public Integer partialCompareTo(Task other) {
        if (other.overridesDefaultPCompareTo()) {
            Integer revComp = other.overridesDefaultPartialCompareTo(this);
            if (revComp != null) {
                return - revComp;
            }
        }
        return null;
    }

    public default boolean overridesDefaultPartialCompareTo() {
        return false;
    }

}

Есть ли способ спросить, переписан ли метод в коде?

Или есть альтернативный подход к решению моей проблемы?

Answer 1

Когда вы сравниваете вещи, вы должны использовать что-то с сопоставимым интерфейсом, как рекомендовано Duffymo. Чтобы углубиться в детали, вы должны хранить ваши элементы в ArrayList, а затем переписывать метод сравнения. Я не уверен, почему у вас есть pCompare, но я собираюсь предположить, что вы не понимаете наследование и полиморфизм. Вместо того, чтобы менять имя вашего сравнения, вы должны использовать extends, вот документы о наследовании, пожалуйста, прочитайте их. Похоже, ваш синтаксис хорош, но вы плохо понимаете, как пишется Java-код. Так как вы должны это сделать?

Давайте начнем с того, что я считаю неправильным (не стесняйтесь поправлять меня, ребята, если это неверно), вы неправильно используете интерфейс. Интерфейс хорош для объявления глобальных переменных, помогает вам реализовывать шаблоны проектирования и т. Д. Большинство людей говорят, что это контракт поведения. На простом английском языке используйте интерфейс, чтобы помочь вам преодолеть множественное наследование. Я понятия не имею, почему вы используете один и что вы планируете делать с ним, но я никогда не добавлял метод в интерфейс, который реализован.

Следующее, что вы переименовываете свой pCompareTo, я никогда не делал этого, и я помог сделать несколько довольно больших программ. Я действительно не думаю, что это хорошее программирование. Это должно быть в классе. Класс, который использует это хорошо, хотя и не всегда, и мне трудно думать о том, как это можно объяснить, поэтому вам, возможно, придется провести какое-то исследование.

Когда вы избавляетесь от интерфейса, поместите compareTo () в правильное место (не меняйте его на pCompareTo (), который является плохим программированием), вы переопределяете его, как и сделали, и указываете, что входит в него. Обратите внимание, что это важно. Обычно, когда вы переопределяете сравнение, у вас есть метод CompareTo, у которого он возвращает -1, если входящий объект меньше, чем тот, с которым он сравнивается, 1, если он больше, или 0, если он такой же. размер. В случае, когда вы просто хотите проверить, равно ли оно, тогда вы можете просто проверить, равны ли они, как для строки, которую вы делаете

string1.equals(string2)

и он вернет 1, если истина или 0, если ложь.

 @Override
public default Integer pCompareTo(Task other) {
    Integer result;
    try {
        result = - other.pCompareTo(this);
    } catch (StackruError | NullPointerException e) {
        return null;
    }
    return null;
}

Хорошо, это ужасно неправильный человек, просто ужасно неправильно. Ваш метод является pCompareTo (), верно? Вы называете это внутри себя (это называется рекурсией, и я бы не рекомендовал вам использовать это прямо сейчас). Я не знаю, что вы сравниваете (также вам здесь не нужен трик-поймать, но, если хотите, можете, если у вас есть, попытка-ловушка - это ловушка, которую вы установили в своем коде, которая срабатывает, если эта конкретная область не работает правильно), но если бы они были целыми числами, вы бы сделали что-то вроде

@Override
public int compareTo(Integer other){
 if (this < other) {
  return 1;
 }
 if (this > other) {
  return -1;
 }
 return 0;

Пожалуйста, смотрите объяснение переопределения. Для меня очень много, чтобы объяснить, как это работает для вас в этом уже длинном посте. Удачи, и мой совет синтаксис в программировании не очень важен. Знать, как правильно программировать, гораздо важнее.

Answer 2

Редакция немного лучше и имеет больше смысла. Спасибо за это. Теперь для начала вам нужно понять, что вы сравниваете объекты. Если вы хотите написать метод compareTo(), вам нужно подумать о том, "что я сравниваю". Чтобы написать свой метод, вы должны объяснить нам, что вы сравниваете, по вашему мнению, вы можете сравнивать элементы в наборе. Но в мире программирования вы сравниваете целые, строки или те, из которых вы их делаете. Поэтому я спрашиваю вас, что вы сравниваете? Вы должны сделать класс ж / е, который вы сравниваете, скажем

class POsetElement{...
//make some sort of set element object
}

В этом классе вы хотели бы реализовать сопоставимую так,

class POsetElement implements comparable{...
//make some sort of set element object...

//then make w/e other methods you need...

//now use compareTo() override
@override
compareTo(){
//make your custom method
}
}

Обратите внимание, как я помещаю метод CompareTo () ВНУТРИ класса POsetElement. Ява это ООП. Это означает объектно-ориентированное программирование. Вам нужно создавать объекты на заказ. Вам нужно создать свой собственный мир, создать свои собственные объекты. Я никак не могу объяснить вам все это. Пожалуйста, приложите некоторые усилия и узнайте больше о программировании на Java. Также вы должны понимать, я бы сказал, что это очень простые вещи, и еще раз повторю, что вам нужно немного прочесть основы Java. Удачи.