La anotación @Override en Java

La anotación @Override es una anotación estándar de Java que se introdujo por primera vez en Java 1.5. La anotación @Override indica que el método de la clase secundaria anula el método de la clase base.

Por dos razones, la anotación @Override es útil.

1. Si el método anotado en realidad no anula nada, el compilador emite una advertencia.
2. Puede ayudar a que el código fuente sea más legible.

Por qué usamos la anotación @Override:

Debido a las siguientes dos ventajas, el uso de la anotación @Override al anular un método se considera una buena práctica para codificar en Java:

1) Obtendrá un error de tiempo de compilación si el programador comete un error al anular, como usar el nombre de método o los tipos de parámetros incorrectos. Porque le está informando al compilador que está anulando este método usando esta anotación. Si no usa la anotación, el método de la subclase se tratará como un nuevo método en la subclase (en lugar del método de reemplazo).

2) Mejora la legibilidad del código. Si cambia la firma de un método anulado, todas las subclases que lo anulen arrojarán un error de compilación, lo que eventualmente lo llevará a cambiar la firma en las subclases. Si tiene una gran cantidad de clases en su aplicación, esta anotación lo ayudará en gran medida a identificar las clases que deben cambiarse cuando se cambia la firma de un método.

Sintaxis:

public @interface Override

Ejemplo 1: sin uso de clase abstracta 

// Java Program Illustrating Override Annotation
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Parent class
class ParentClass {
 
    // Method inside parent class
    public void display()
    {
 
        // Print statement whenever
        // method of parent class is called
        System.out.println("We are in base class method");
    }
}
 
// Class 2
// Child class
class ChildClass extends ParentClass {
 
    // @Override
    // Method inside child class
    public void display()
    {
 
        // Print statement whenever
        // method of child class is called
        System.out.println("We are in child class method");
    }
}
 
// Clas 3
// OverrideAnnotationTest
public class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Display message only
        System.out.println(
            "Example of @Override annotation");
 
        // Creating an object of parent class
        // with reference t ochild class
        ParentClass obj = new ChildClass();
 
        // Calling the method to execute inside classes
        obj.display();
    }
}

Producción:

Ejemplo 2: Usando la clase abstracta

// Java Program illustrating Override Annotation
// Using Abstract class
 
// Importing input output classes
import java.io.*;
 
// Class 1
// Helper abstract class
abstract class Vehicle {
 
    // Calling this method
    public abstract void method();
}
 
// Class 2
// Helper class
class Car extends Vehicle {
 
    // @Override
    // Method of Car class
    public void method()
    {
 
        // Print statement whenever this method is called
        System.out.println("This is Car");
    }
}
 
// Class 3
// Helper class
class Bike extends Vehicle {
 
    // @Override
    // Method of bike class
    public void method()
    {
 
        // Print statement whenever this method is called
        System.out.println("This is Bike");
    }
}
 
// Class 4
// OverrideAnnotationExample
public class GFG {
    // Main drive method
    public static void main(String[] args)
    {
        // Creating object of both the classes
        // namely Car and Bike
        Car Carobj = new Car();
 
        // Calling method over car object
        Carobj.method();
 
        Bike Bikeobj = new Bike();
 
        // Similarly calling method over bike object
        Bikeobj.method();
    }
}

This is Car
This is Bike