Java @Override Annotation

In this quick article, we will look into what is the use of @Override annotation with examples.

From Oracle Java Doc: @Override annotation indicates that a method declaration is intended to override a method declaration in a supertype. If a method is annotated with this annotation type compilers are required to generate an error message unless at least one of the following conditions hold:

1. The method does override or implement a method declared in a supertype.
2. The method has a signature that is override-equivalent to that of any public method declared in Object.

Below diagram shows the internal implementation of @Override annotation for your reference:

Let's demonstrates the usage of @Override annotation with few examples.

Example 1: Simple Example

package net.javaguides.annotations;

public class OverrideAnnotationExample {
    public static void main(String[] args) {
        BaseClass baseClass = new SubClass();
        baseClass.test();

        SubClass subClass = new SubClass();
        subClass.test();
    }
}


class BaseClass {
    public void test() {
        System.out.println("Inside baseclass");
    }
}

class SubClass extends BaseClass {
    @Override
    public void test() {
        System.out.println("Inside subclass");
    }
}

Output:

Inside subclass
Inside subclass

Example 2: Using Abstract Class

In this example, we create an Animal class with abstract sound() method. We create Dog and Cat classes which extend an Animal class.

package net.javaguides.annotations;

public class OverrideAnnotationExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.sound();

        Animal cat = new Cat();
        cat.sound();
    }
}

abstract class Animal {
    public abstract void sound();
}

class Dog extends Animal {

    @Override
    public void sound() {
        System.out.println("Bou bou");
    }
}

class Cat extends Animal {

    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

Output:

Bou bou
Meow

Example 3: Using Interface

package net.javaguides.annotations;

public interface StudentService {
    public void save(Student student);
    public void update(Student student);
    public void delete(int id);
    public Student get(int id);
}

class Student {
    private int id;
    private String name;

}

public class StudentServiceImpl implements StudentService {

    @Override
    public void save(Student student) {
        // TODO Auto-generated method stub

    }

    @Override
    public void update(Student student) {
        // TODO Auto-generated method stub

    }

    @Override
    public void delete(int id) {
        // TODO Auto-generated method stub

    }

    @Override
    public Student get(int id) {
        // TODO Auto-generated method stub
        return null;
    }
}

Java @Override annotation benefits

If programmer makes any mistake such as wrong method name, wrong parameter types while overriding, you would get a compile time error. As by using this annotation you instruct compiler that you are overriding this method. If you don’t use the annotation then the sub class method would behave as a new method (not the overriding method) in sub class.

It’s clear that using java @Override annotation will make sure any superclass changes in method signature will result in a warning and you will have to do necessary changes to make sure the classes work as expected.

It’s better to resolve potential issues at compile time than runtime. So always use java @Override annotation whenever you are trying to override a superclass method.

Reference

https://docs.oracle.com/javase/8/docs/api/java/lang/Override.html