Должны ли мы @Override реализации метода интерфейса?

По возможности следует использовать @Override. Это предотвращает совершение простых ошибок. Пример:

class C {
    @Override
    public boolean equals(SomeClass obj){
        // code ...
    }
}

Это не компилируется, потому что оно неправильно переопределяет public boolean equals(Object obj).

То же самое касается методов, реализующих интерфейс (Только 1.6 и выше) или переопределяющих метод суперкласса.

Я бы использовал его при любой возможности. См. Когда вы используете аннотацию Java @Override и почему?

Я считаю, что поведение javac изменилось - с 1.5 он запретил аннотацию, с 1.6 нет. Аннотация обеспечивает дополнительную проверку во время компиляции, поэтому, если вы используете 1.6, я бы пошел на это.

Переопределение ваших собственных методов, унаследованных от ваших собственных классов, обычно не нарушает рефакторинга с использованием ide. Но если вы переопределяете метод, унаследованный от библиотеки, рекомендуется использовать его. Если вы этого не сделаете, вы часто получите не ошибку при последующем изменении библиотеки, а хорошо скрытую ошибку.

Eclipse сам добавит аннотацию @Override, когда вы скажете ему «сгенерировать нереализованные методы» во время создания класса, реализующего интерфейс.

Для меня часто это единственная причина, по которой некоторый код требует компиляции Java 6. Не уверен, стоит ли оно того.

JDK 5.0 не позволяет использовать аннотацию @Override, если вы реализуете метод, объявленный в интерфейсе (его ошибка компиляции), но JDK 6.0 позволяет это. Так что, возможно, вы можете настроить предпочтения вашего проекта в соответствии с вашими требованиями.

С JDK это не проблема. В Eclipse Helios он разрешает аннотацию @Override для реализованных методов интерфейса, в зависимости от того, какой JDK 5 или 6. Что касается Eclipse Galileo, аннотация @Override не разрешена, в зависимости от того, какой JDK 5 или 6.

Вы всегда должны аннотировать методы с помощью @Override, если он доступен.

В JDK 5 это означает переопределение методов суперклассов, в JDK 6 и 7 это означает переопределение методов суперклассов и реализацию методов интерфейсов. Причина, как упоминалось ранее, заключается в том, что это позволяет компилятору обнаруживать ошибки, когда вы думаете, что переопределяете (или реализуете) метод, но на самом деле определяете новый метод (другую сигнатуру).

Пример equals(Object) и equals(YourObject) является стандартным случаем, но тот же аргумент можно привести для реализации интерфейсов.

Я предполагаю, что не обязательно аннотировать методы реализации интерфейсов, потому что JDK 5 пометил это как ошибку компиляции. Если JDK 6 сделает эту аннотацию обязательной, это нарушит обратную совместимость.

Я не являюсь пользователем Eclipse, но в других IDE (IntelliJ) аннотация @Override добавляется только при реализации методов интерфейса, если проект задан как проект JDK 6+. Я бы предположил, что Eclipse похож.

Однако я бы предпочел увидеть другую аннотацию для этого использования, возможно, аннотацию @Implements.

Проблема с включением @Override заключается в том, что вы думаете, что вы забыли вызвать метод super.theOverridenMethod(), то есть очень запутанный. Это должно быть предельно ясно. Возможно, Java следует предложить здесь @Interface. Да ладно, еще одна недооцененная особенность Java ...

Если класс конкретный не является абстрактным методом преобладающий, использование @Override для выполнение является открытым вопросом, поскольку компилятор всегда предупреждает вас о любых нереализованных методах. В этих случаях можно привести аргумент, что это снижает удобочитаемость - в вашем коде больше вещей, которые нужно читать, и, в меньшей степени, он называется @Override, а не @Implement.

В java 6 и более поздних версиях вы можете использовать @Override для метода, реализующего интерфейс.

Но я не думаю, что это имеет смысл: переопределение означает, что у вас есть метод в суперклассе, и вы реализуете его в подклассе.

Если вы реализуете интерфейс, я думаю, нам следует использовать @Implement или что-то еще, но не @Override.

Читая javadoc в java8, вы можете найти следующее в объявлении переопределения интерфейса:

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

• Метод переопределяет или реализует метод, объявленный в супертипе.
• Этот метод имеет сигнатуру, эквивалентную сигнатуре любого общедоступного метода, объявленного в {@linkplain Object}.

Итак, по крайней мере, в java8 вы должны использовать @Override для реализации метода интерфейса.

Для интерфейса использование @Override вызвало ошибку компиляции. Итак, мне пришлось его удалить.

Сообщение об ошибке пошло «The method getAllProducts() of type InMemoryProductRepository must override a superclass method».

Также читается "One quick fix available: Remove @Override annotation.".

Это было на Eclipse 4.6.3, JDK 1.8.0_144.

Если класс, реализующий interface, является классом abstract, @Override полезен, чтобы гарантировать, что реализация предназначена для метода interface; без @Override класс abstract просто компилируется нормально, даже если сигнатура метода реализации не соответствует методу, объявленному в interface; несовпадающий метод interface останется нереализованным. Документ Java, цитируемый @Zhao

The method does override or implement a method declared in a supertype

явно относится к суперклассу abstract; interface нельзя назвать супертипом. Итак, @Override избыточен и не подходит для реализации метода interface в конкретных классах.