11.2.1 @Override Explained

The @Override annotation in Java SE 11 is a crucial tool for ensuring method overriding is done correctly. It provides a way to indicate that a method is intended to override a method from a superclass or interface. Understanding the @Override annotation is essential for writing robust and error-free Java code.

Key Concepts

1. Method Overriding

Method overriding is a feature in Java that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. The method in the subclass must have the same name, return type, and parameters as the method in the superclass.

Example

        class Animal {
            void makeSound() {
                System.out.println("Animal sound");
            }
        }

        class Dog extends Animal {
            @Override
            void makeSound() {
                System.out.println("Bark");
            }
        }
    

2. Purpose of @Override

The @Override annotation is used to indicate that a method is intended to override a method in a superclass or interface. It helps the compiler verify that the method signature matches the method in the superclass, preventing potential errors.

Example

        class Vehicle {
            void start() {
                System.out.println("Vehicle started");
            }
        }

        class Car extends Vehicle {
            @Override
            void start() {
                System.out.println("Car started");
            }
        }
    

3. Compiler Verification

When the @Override annotation is used, the compiler checks if the method actually overrides a method in the superclass. If the method signature does not match, the compiler generates an error, preventing potential runtime issues.

Example

        class Shape {
            void draw() {
                System.out.println("Drawing shape");
            }
        }

        class Circle extends Shape {
            @Override
            void draw() {
                System.out.println("Drawing circle");
            }
        }
    

4. Usage in Interfaces

The @Override annotation can also be used to indicate that a method is intended to implement a method from an interface. This helps ensure that the method signature matches the method in the interface.

Example

        interface Drawable {
            void draw();
        }

        class Rectangle implements Drawable {
            @Override
            public void draw() {
                System.out.println("Drawing rectangle");
            }
        }
    

Examples and Analogies

Think of the @Override annotation as a safety check for method overriding. Just as a safety check ensures that a bridge is built correctly before it is used, the @Override annotation ensures that a method is correctly overridden before it is executed.

For example, if you are designing a system where different types of vehicles make different sounds, the @Override annotation ensures that each subclass correctly overrides the makeSound method from the Vehicle class.

By using the @Override annotation, you can prevent common errors such as misspelling the method name or changing the method signature unintentionally. This makes your code more reliable and easier to maintain.

In summary, the @Override annotation is a powerful tool for ensuring method overriding is done correctly, providing a safety check that helps prevent runtime errors and improves code quality.