¿Cuándo usas la anotación @Override de Java y por qué?

¿Cuáles son las mejores prácticas para usar la anotación @Override de Java y por qué?

Parece que sería excesivo marcar cada método reemplazado con la anotación @Override . ¿Hay ciertas situaciones de progtwigción que requieren el uso de @Override y otras que nunca deben usar @Override ?

Úselo cada vez que anule un método para dos beneficios. Hágalo para que pueda aprovechar la verificación del comstackdor para asegurarse de que está anulando un método cuando cree que lo está. De esta forma, si comete un error común al escribir mal el nombre de un método o al no hacer coincidir correctamente los parámetros, se le advertirá que su método en realidad no se anula como cree que lo hace. En segundo lugar, hace que su código sea más fácil de entender porque es más obvio cuando se sobrescriben los métodos.

Además, en Java 1.6 puede usarlo para marcar cuándo un método implementa una interfaz para los mismos beneficios. Creo que sería mejor tener una anotación separada (como @Implements ), pero es mejor que nada.

Creo que es más útil como un recordatorio en tiempo de comstackción que la intención del método es anular un método principal. Como ejemplo:

 protected boolean displaySensitiveInformation() { return false; } 

A menudo verá algo así como el método anterior que anula un método en la clase base. Este es un detalle importante de implementación de esta clase: no queremos que se muestre información confidencial.

Supongamos que este método se cambia en la clase principal para

 protected boolean displaySensitiveInformation(Context context) { return true; } 

Este cambio no causará ningún error o advertencia de tiempo de comstackción, pero cambia por completo el comportamiento previsto de la subclase.

Para responder a su pregunta: debe usar la anotación @Override si la falta de un método con la misma firma en una superclase es indicativa de un error.

Aquí hay muchas buenas respuestas, así que permítame ofrecerle otra forma de verlo …

No hay excesos cuando estás codificando. No le cuesta nada escribir @override, pero los ahorros pueden ser inmensos si ha escrito mal el nombre de un método o si ha escrito mal la firma.

Piénsalo de esta manera: en el momento en que navegaste aquí y escribiste esta publicación, prácticamente usaste más tiempo de lo que gastarás escribiendo @override por el rest de tu vida; pero un error que evita puede ahorrarle horas.

Java hace todo lo posible para asegurarse de que no haya cometido ningún error durante el tiempo de edición / comstackción; esta es una forma prácticamente gratuita de resolver toda una clase de errores que no pueden prevenirse de ninguna otra manera fuera de las pruebas exhaustivas.

¿Podrías encontrar un mecanismo mejor en Java para garantizar que cuando el usuario intentara anular un método, realmente lo hiciera?

Otro efecto interesante es que si no proporciona la anotación, le advertirá en el momento de la comstackción que accidentalmente anulará un método principal, algo que podría ser significativo si no tuviera la intención de hacerlo.

Yo siempre uso la etiqueta. Es una simple bandera en tiempo de comstackción para detectar pequeños errores que pueda cometer.

tostring() cosas como tostring() lugar de toString()

Las pequeñas cosas ayudan en proyectos grandes.

El uso de la anotación @Override actúa como salvaguarda en tiempo de comstackción contra un error de progtwigción común. Lanzará un error de comstackción si tiene la anotación en un método que no está anulando el método de la superclase.

El caso más común en el que esto es útil es cuando está cambiando un método en la clase base para tener una lista de parámetros diferente. Un método en una subclase que utilizó para anular el método de la superclase ya no lo hará debido a la firma del método modificado. Esto a veces puede causar un comportamiento extraño e inesperado, especialmente cuando se trata de estructuras de herencia complejas. La anotación @Override protege contra esto.

Para aprovechar la comprobación del comstackdor, siempre debe utilizar Anular anotación. Pero no olvide que Java Compiler 1.5 no permitirá esta anotación al anular los métodos de interfaz. Solo puede usarlo para anular los métodos de clase (abstractos o no).

Algunos IDEs, como Eclipse, incluso configurados con Java 1.6 runtime o superior, mantienen el cumplimiento con Java 1.5 y no permiten el uso de @override como se describe arriba. Para evitar ese comportamiento, debe dirigirse a: Propiedades del proyecto -> Comstackdor de Java -> Verifique “Habilitar configuraciones específicas del proyecto” -> Elija “Nivel de cumplimiento del comstackdor” = 6.0 o superior.

Me gusta utilizar esta anotación cada vez que estoy anulando un método de forma independiente, si la base es una interfaz o clase.

Esto le ayuda a evitar algunos errores típicos, como cuando piensa que está anulando un controlador de eventos y luego no ve nada. Imagine que desea agregar un detector de eventos a algún componente de UI:

 someUIComponent.addMouseListener(new MouseAdapter(){ public void mouseEntered() { ...do something... } }); 

El código anterior se comstack y ejecuta, pero si mueve el mouse dentro de algúnUIComponent, el código “do something” notará la ejecución, porque en realidad no está anulando el método base mouseEntered(MouseEvent ev) . Usted acaba de crear un nuevo método mouseEntered() parámetros mouseEntered() . En lugar de ese código, si ha utilizado la anotación @Override , ha visto un error de comstackción y no ha perdido el tiempo pensando por qué el controlador de eventos no se estaba ejecutando.

@Override en la implementación de la interfaz es inconsistente ya que no existe tal cosa como “sobreescribir una interfaz” en java.

@Override en la implementación de la interfaz es inútil ya que en la práctica no detecta errores que la comstackción no captaría de todos modos. Solo hay un escenario descabellado en el que la anulación de implementadores realmente hace algo: si implementa una interfaz y la interfaz QUITA métodos, se le notificará en tiempo de comstackción que debe eliminar las implementaciones no utilizadas. Tenga en cuenta que si la nueva versión de la interfaz tiene métodos NUEVOS o CAMBIADOS, obviamente obtendrá un error de comstackción de todos modos ya que no está implementando las cosas nuevas.

@Override en implementadores de interfaz nunca debería haber sido permitido en 1.6, y con Eclipse tristemente eligiendo insertar automáticamente las anotaciones como comportamiento predeterminado, obtenemos muchos archivos fuente desordenados. Al leer el código 1.6, no puede ver desde la anotación @Override si un método realmente anula un método en la superclase o simplemente implementa una interfaz.

Usar @Override cuando se reemplaza un método en una superclase está bien.

Lo mejor es usarlo para todos los métodos destinados a la anulación, y Java 6+, cada método previsto como una implementación de una interfaz.

Primero, detecta errores ortográficos como ” hashcode() ” en lugar de ” hashCode() ” en tiempo de comstackción. Puede ser desconcertante depurar por qué el resultado de su método no parece coincidir con su código cuando la causa real es que su código nunca se invoca.

Además, si una superclase cambia la firma de un método, las anulaciones de la firma anterior pueden quedar “huérfanas”, quedando como un código muerto confuso. La anotación @Override te ayudará a identificar a estos huérfanos para que puedan modificarse para que coincidan con la nueva firma.

Si se encuentra a usted mismo reemplazando métodos (no abstractos) muy a menudo, probablemente quiera echarle un vistazo a su diseño. Es muy útil cuando el comstackdor no captaría el error. Por ejemplo, intentar anular initValue () en ThreadLocal, lo cual he hecho.

Usar @Override cuando implemente métodos de interfaz (característica 1.6+) me parece un poco exagerado. Si tiene muchos métodos, algunos de los cuales anulan y otros no, ese probablemente sea un mal diseño nuevamente (y su editor probablemente mostrará cuál es el que no conoce).

@Override en las interfaces en realidad son útiles, porque recibirás advertencias si cambias la interfaz.

Otra cosa que hace es que es más obvio cuando lee el código que está cambiando el comportamiento de la clase padre. Que puede ayudar en la depuración.

Además, en el libro de Joshua Block Effective Java (2da edición), el artículo 36 brinda más detalles sobre los beneficios de la anotación.

No tiene ningún sentido utilizar @Override al implementar un método de interfaz. No hay ninguna ventaja de usarlo en ese caso: el comstackdor ya detectará su error, por lo que es un desorden innecesario.

Siempre que un método anule otro método o un método implemente una firma en una interfaz.

La anotación @Override le asegura que, de hecho, anuló algo. Sin la anotación corre el riesgo de una falta de ortografía o una diferencia en los tipos de parámetros y el número.

Lo uso todo el tiempo. Es más información que puedo usar para descubrir rápidamente qué sucede cuando reviso el código en un año y olvidé lo que estaba pensando la primera vez.

La mejor práctica es usarlo siempre (o hacer que el IDE lo complete)

La utilidad @Override es detectar cambios en las clases principales que no se informaron en la jerarquía. Sin él, puede cambiar la firma de un método y olvida alterar sus anulaciones, con @Override, el comstackdor lo detectará por usted.

Ese tipo de red de seguridad siempre es bueno tener.

Lo uso en todas partes. Sobre el tema del esfuerzo para marcar los métodos, dejo que Eclipse lo haga por mí, así que no es un esfuerzo adicional.

Soy religioso acerca de la refactorización continua … así que usaré cada pequeña cosa para que todo sea más fácil.

  • Usado solo en declaraciones de métodos.
  • Indica que la statement del método anotado anula una statement en supertipo.

Si se usa de manera constante, te protege de una gran clase de errores nefastos.

Use la anotación @Override para evitar estos errores: (Localice el error en el siguiente código 🙂

 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 s = new HashSet(); 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()); } } 

fuente: Java efectivo

Tenga cuidado cuando use Override, ya que no puede hacer ingeniería inversa en starUML después; haz el uml primero.

Parece que la sabiduría aquí está cambiando. Hoy instalé IntelliJ IDEA 9 y noté que su ” inspección omitida de @Override ” ahora no solo capta los métodos abstractos, sino que también implementa métodos de interfaz. En la base de código de mi empleador y en mis propios proyectos, hace mucho tiempo que tengo el hábito de usar solo @Override para los métodos abstractos implementados anteriormente. Sin embargo, al reconsiderar el hábito, el mérito de usar las anotaciones en ambos casos se vuelve claro. A pesar de ser más detallado, protege contra el problema de la clase base frágil (no tan graves como los ejemplos relacionados con C ++) donde el nombre del método de interfaz cambia, orfanizando el método de implementación en una clase derivada.

Por supuesto, este escenario es principalmente hipérbole; la clase derivada ya no comstackría, ahora carece de una implementación del método de interfaz renombrado, y hoy es probable que utilice una operación de refactorización de Método de cambio de nombre para direccionar la base de códigos completa en masa.

Dado que la inspección de IDEA no es configurable para ignorar los métodos de interfaz implementados, hoy cambiaré mi hábito y los criterios de revisión del código de mi equipo.

La anotación @Override se usa para ayudar a verificar si el desarrollador reemplaza el método correcto en la clase o interfaz principal. Cuando cambia el nombre de los métodos de super, el comstackdor puede notificar ese caso, que es solo para mantener la consistencia con el super y la subclase.

Por cierto, si no anunciamos la anotación @Orride en la subclase, pero anulamos algunos métodos del super, entonces la función puede funcionar como esa con @Override. Pero este método no puede notificar al desarrollador cuando se cambió el método del súper. Porque no conocía el propósito del desarrollador: ¿anular el método de super o definir un nuevo método?

Entonces, cuando queremos anular ese método para hacer uso del Polimorfismo, es mejor que agreguemos @Override sobre el método.

Lo uso tanto como puedo para identificar cuándo se está anulando un método. Si miras el lenguaje de progtwigción de Scala, también tienen una palabra clave de anulación. Lo encuentro útil.

Le permite (bueno, el comstackdor) captar cuando ha utilizado la ortografía incorrecta en un nombre de método que está anulando.

La anulación de anulación se usa para aprovechar el comstackdor, para comprobar si realmente está anulando un método de la clase principal. Se utiliza para notificar si comete algún error, como por error al escribir mal el nombre de un método, error al no hacer coincidir correctamente los parámetros

Creo que es mejor codificar el @override siempre que se permita. ayuda a codificar sin embargo, para tener en cuenta, para ecipse Helios, ya sea sdk 5 o 6, se permite la anotación @override para los métodos de interfaz implementados. en cuanto a Galileo, ya sea 5 o 6, la anotación @override no está permitida.

Las anotaciones proporcionan metadatos sobre el código al comstackdor y la anotación @Override se usa en caso de herencia cuando estamos anulando cualquier método de la clase base. Simplemente le dice al comstackdor que está anulando el método. Puede evitar algunos tipos de errores comunes que podemos hacer, como no seguir la firma correcta del método o errores en el nombre del método, etc. Por lo tanto, es una buena práctica usar la anotación @Override.

Para mí, @Override me garantiza que tengo la firma del método correcta. Si pongo la anotación y el método no está escrito correctamente, el comstackdor se queja de que algo está mal.

Simple: cuando desee sobrescribir un método presente en su superclase, use la anotación @Override para hacer una anulación correcta. El comstackdor le advertirá si no lo reemplaza correctamente.