Каковы наилучшие методы использования аннотации Java @Override и почему?
Кажется, что было бы излишним отмечать каждый единственный переопределенный метод аннотацией @Override. Существуют ли определенные ситуации программирования, которые требуют использования @Override и других, которые никогда не должны использовать @Override?
Используйте его каждый раз, когда вы переопределяете метод для двух преимуществ. Сделайте это так, чтобы вы могли воспользоваться проверкой компилятора, чтобы убедиться, что вы фактически переопределяете метод, когда считаете себя. Таким образом, если вы допустили распространенную ошибку при неправильном написании имени метода или неправильном совпадении параметров, вы будете предупреждены о том, что ваш метод фактически не переопределяет, как вы думаете. Во-вторых, это упрощает понимание кода, потому что это более очевидно, когда методы перезаписываются.
Кроме того, в Java 1.6 вы можете использовать его, чтобы отметить, когда метод реализует интерфейс для тех же преимуществ. Я думаю, что было бы лучше иметь отдельную аннотацию (например, @Implements), но это лучше, чем ничего.
Я думаю, что наиболее полезным в качестве напоминания о компиляции является намерение метода переопределить родительский метод. В качестве примера:
protected boolean displaySensitiveInformation() {
return false;
}
Вы часто увидите что-то вроде описанного выше метода, который переопределяет метод в базовом классе. Это важная деталь реализации этого класса - мы не хотим, чтобы отображалась конфиденциальная информация.
Предположим, что этот метод изменен в родительском классе на
protected boolean displaySensitiveInformation(Context context) {
return true;
}
Это изменение не приведет к ошибкам или предупреждениям времени компиляции, но полностью изменяет предполагаемое поведение подкласса.
Чтобы ответить на ваш вопрос: вы должны использовать аннотацию @Override, если отсутствие метода с той же сигнатурой в суперклассе указывает на ошибку.
Здесь есть много хороших ответов, поэтому позвольте мне предложить еще один способ взглянуть на это...
При кодировании нет переполнения. Вам ничего не стоит набирать @override, но экономия может быть огромной, если вы ошибочно написали имя метода или получили подпись неправильно.
Подумайте об этом так: в то время, когда вы перешли сюда и набрали этот пост, вы в значительной степени использовали больше времени, чем потратили бы написание @override на всю оставшуюся жизнь; но одна ошибка, которую он предотвращает, может сэкономить вам часы.
Java делает все возможное, чтобы убедиться, что вы не совершали ошибок при редактировании/компиляции, это практически бесплатный способ решения целого класса ошибок, которые невозможно предотвратить каким-либо другим способом вне всестороннего тестирования.
Не могли бы вы придумать лучший механизм в Java, чтобы убедиться, что когда пользователь намеревался переопределить метод, он действительно сделал?
Другим опрятным эффектом является то, что если вы не предоставите аннотацию, он предупредит вас во время компиляции, что вы случайно перепробовали родительский метод - что-то, что может быть значительным, если вы не намеревались это сделать.
Я всегда использую тег. Это простой флаг времени компиляции, чтобы поймать небольшие ошибки, которые я мог бы сделать.
Он поймает такие вещи, как tostring() вместо tostring()
Маленькие вещи помогают в крупных проектах.
Использование аннотации @Override действует как защита времени компиляции от общей ошибки программирования. Это вызовет ошибку компиляции, если у вас есть аннотация для метода, на котором вы фактически не переопределяете метод суперкласса.
Наиболее распространенный случай, когда это полезно, - это когда вы меняете метод в базовом классе, чтобы иметь другой список параметров. Метод в подклассе, который используется для переопределения метода суперкласса, больше не будет делать этого из-за измененной подписи метода. Иногда это может вызвать странное и неожиданное поведение, особенно при работе со сложными структурами наследования. @Override защищает аннотации от этого.
Чтобы воспользоваться преимуществами проверки компилятора, вы всегда должны использовать аннотацию Override. Но не забывайте, что Java Compiler 1.5 не позволит эту аннотацию при переопределении методов интерфейса. Вы можете использовать его для переопределения методов класса (абстрактные или нет).
Некоторые IDE, как Eclipse, даже настроенные с использованием Java 1.6 или выше, поддерживают соответствие Java 1.5 и не позволяют использовать @override, как описано выше. Чтобы избежать этого поведения, вы должны перейти к: Project Properties → Java Compiler → Check "Enable Project Specific Settings" → Выберите "Comp Compliance Level" = 6.0 или выше.
Мне нравится использовать эту аннотацию каждый раз, когда я переопределяю метод независимо, если база является интерфейсом или классом.
Это поможет вам избежать некоторых типичных ошибок, например, когда вы думаете, что вы переопределяете обработчик событий, а затем видите, что ничего не происходит. Представьте, что вы хотите добавить прослушиватель событий к некоторому компоненту пользовательского интерфейса:
someUIComponent.addMouseListener(new MouseAdapter(){
public void mouseEntered() {
...do something...
}
});
Вышеприведенный код компилируется и запускается, но если вы перемещаете мышь внутри некоторого UIComponent, код "сделать что-то" будет отмечать прогон, потому что на самом деле вы не переопределяете базовый метод mouseEntered(MouseEvent ev). Вы просто создаете новый метод без параметров mouseEntered(). Вместо этого кода, если вы использовали аннотацию @Override, вы видели ошибку компиляции, и вы не теряли время, думая, почему ваш обработчик событий не работал.
Лучше всего использовать его для каждого метода, предназначенного для переопределения, и для Java 6+, для каждого метода, предназначенного для реализации интерфейса.
Во-первых, во время компиляции он ловит орфографические ошибки, такие как "hashcode()" вместо "hashcode()". Может быть сложно понять, почему результат вашего метода, похоже, не соответствует вашему коду, когда реальная причина в том, что ваш код никогда не вызывается.
Кроме того, если суперкласс изменяет подпись метода, переопределение старшей сигнатуры может быть "осиротевшим", оставленным как запутанный мертвый код. Аннотация @Override поможет вам идентифицировать этих сирот, чтобы их можно было изменить в соответствии с новой сигнатурой.
@Override в реализации интерфейса несовместимо, поскольку в java нет такой функции, как "переопределение интерфейса".
@Override в реализации интерфейса бесполезно, поскольку на практике он не обнаруживает ошибок, которые компиляция не поймает. Существует только один сценарий с большим выбором, где переопределение на исполнителей фактически что-то делает: если вы реализуете интерфейс и методы REMOVES интерфейса, во время компиляции вы будете уведомлены об удалении неиспользуемых реализаций. Обратите внимание, что если новая версия интерфейса содержит NEW или CHANGED методы, вы, очевидно, получите ошибку компиляции, поскольку вы не реализуете новый материал.
@Override для реализации интерфейса никогда не должен быть разрешен в версии 1.6, и с затмением, грустно выбирающим автоматическую вставку аннотаций в качестве поведения по умолчанию, мы получаем много загроможденных исходных файлов. При чтении кода 1.6 вы не можете видеть из аннотации @Override, если метод фактически переопределяет метод в суперклассе или просто реализует интерфейс.
Использование @Override при фактическом переопределении метода в суперклассе прекрасно.
Если вы слишком часто находите переопределяющие (не абстрактные) методы, вы, вероятно, хотите взглянуть на свой дизайн. Это очень полезно, когда компилятор в противном случае не поймал бы ошибку. Например, попытка переопределить initValue() в ThreadLocal, который я сделал.
Использование @Override при внедрении методов интерфейса (функция 1.6+) кажется для меня немного излишним. Если у вас есть множество методов, некоторые из которых переопределяют, а некоторые - нет, то, вероятно, плохой дизайн снова (и ваш редактор, вероятно, покажет, что есть, если вы не знаете).
@Override на интерфейсах действительно полезно, потому что вы получите предупреждения, если вы измените интерфейс.
Другое дело, что это делает его более очевидным при чтении кода, что он изменяет поведение родительского класса. Чем может помочь отладка.
Кроме того, в книге Джошуа Блока "Эффективная Java" (2-е издание) в пункте 36 приводится более подробная информация о преимуществах аннотации.
Всякий раз, когда метод переопределяет другой метод или метод реализует подпись в интерфейсе.
Аннотация @Override гарантирует, что вы действительно что-то переопределили. Без аннотации вы рискуете ошибкой или разницей в типах и количестве параметров.
Нет смысла использовать @Override при реализации метода интерфейса. В этом случае нет преимущества использовать его - компилятор уже поймает вашу ошибку, так что это просто лишний беспорядок.
Я использую его каждый раз. Это больше информации, которую я могу использовать, чтобы быстро выяснить, что происходит, когда я пересматриваю код за год, и я забыл, что я думал в первый раз.
Лучше всего всегда использовать его (или чтобы IDE заполнил их для вас)
@Использовать полезность - это обнаружение изменений в родительских классах, о которых не сообщалось в иерархии. Без него вы можете изменить подпись метода и забыть изменить его переопределения, с помощью @Override компилятор поймает его для вас.
Такая система безопасности всегда хороша.
Я использую его везде. По теме усилий по методам маркировки я позволяю Eclipse делать это для меня, поэтому никаких дополнительных усилий не требуется.
Я верим в непрерывный рефакторинг.... так что я буду использовать каждую мелочь, чтобы сделать ее более плавно.
Если используется последовательно, он защищает вас от большого класса гнусных ошибок.
Используйте аннотацию @Override, чтобы избежать этих ошибок: (Определите ошибку в следующем коде:)
public class Bigram {
private final char first;
private final char second;
public Bigram(char first, char second) {
this.first = first;
this.second = second;
}
public boolean equals(Bigram b) {
return b.first == first && b.second == second;
}
public int hashCode() {
return 31 * first + second;
}
public static void main(String[] args) {
Set<Bigram> s = new HashSet<Bigram>();
for (int i = 0; i < 10; i++)
for (char ch = 'a'; ch <= 'z'; ch++)
s.add(new Bigram(ch, ch));
System.out.println(s.size());
}
}
источник: Эффективная Java
Будьте осторожны при использовании переопределения, потому что после этого вы не можете делать обратный инженер в starUML; сначала сделайте uml.
Кажется, что мудрость здесь меняется. Сегодня я установил IntelliJ IDEA 9 и заметил, что его отсутствует @Override инспекция "теперь улавливает не только реализованные абстрактные методы, но и реализует интерфейсные методы. В моей базе кода моего работодателя и в моих собственных проектах я давно привык использовать @Override для прежних - реализованных абстрактных методов. Однако, переосмысливая привычку, достоинство использования аннотаций в обоих случаях становится ясным. Несмотря на то, что он является более подробным, он защищает от проблемы хрупкого базового класса (не столь серьезного, как примеры, связанные с С++), где изменяется имя метода интерфейса, прибегая к методу реализации в производном классе.
Конечно, этот сценарий в основном гипербола; производный класс больше не будет компилироваться, а теперь отсутствует реализация метода переименованного интерфейса, и сегодня, скорее всего, будет использоваться операция рефакторинга метода переименования, чтобы в полной мере охватить всю базу кода.
Учитывая, что инспекция IDEA не настраивается, чтобы игнорировать внедренные методы интерфейса, сегодня я изменю как мою привычку, так и критерии проверки кода команды.
Аннотирование @Override используется для проверки того, что разработчик должен переопределить правильный метод в родительском классе или интерфейсе. Когда имя супер методов меняется, компилятор может уведомить об этом случае, который предназначен только для сохранения соответствия супер и подклассу.
Кстати, если мы не объявили аннотацию @Override в подклассе, но мы переопределим некоторые методы супер, то функция может работать как таковая с @Override. Но этот метод не может уведомить разработчика, когда был изменен метод super. Потому что он не знал цель разработчика - переопределить супер метод или определить новый метод?
Поэтому, когда мы хотим переопределить этот метод, чтобы использовать Полиморфизм, нам лучше добавить @Override выше метода.
Я использую его столько, сколько может, чтобы определить, когда метод переопределяется. Если вы посмотрите на язык программирования Scala, у них также есть ключевое слово переопределения. Я считаю это полезным.
Это позволяет вам (ну, компилятор) поймать, когда вы использовали неправильное написание имени метода, которое вы переопределяете.
Простая - если вы хотите переопределить метод, присутствующий в вашем суперклассе, используйте аннотацию @Override, чтобы сделать правильное переопределение. Компилятор предупредит вас, если вы не отмените его правильно.
Обозначение переопределения используется для использования компилятора для проверки того, действительно ли вы переопределяете метод из родительского класса. Он используется для уведомления, если вы допустили какую-либо ошибку, например, ошибку при неправильном написании имени метода, ошибку неправильного соответствия параметров
Я думаю, что лучше всего кодировать @override всякий раз, когда это разрешено. это помогает для кодирования. однако, чтобы быть отмеченным, для ecipse Helios, либо sdk 5 или 6, допускается аннотация @override для реализованных методов интерфейса. как для Galileo, либо 5 или 6, аннотация @override не разрешена.
Аннотации предоставляют метаданные о коде компилятору, а аннотация @Override используется в случае наследования, когда мы переопределяем любой метод базового класса. Он просто сообщает компилятору, что вы являетесь основным методом. Он может избегать некоторых распространенных ошибок, которые мы можем сделать, не следуя правильной подписи метода или неправильного использования имени метода и т.д. Поэтому его хорошая практика заключается в использовании аннотации @Override.
Для меня @Override гарантирует, что у меня есть подпись метода правильно. Если я помещаю аннотацию, и метод неправильно написан, компилятор жалуется, что позволяет мне знать, что что-то не так.