Trending September 2023 # How @Override Annotation Works In Java With Examples # Suggested October 2023 # Top 13 Popular

You are reading the article How @Override Annotation Works In Java With Examples updated in September 2023 on the website Happystarlongbien.com. We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested October 2023 How @Override Annotation Works In Java With Examples

Introduction to Java @Override

Web development, programming languages, Software testing & others

Syntax:

public @interface Override

Sign “@” should be present preceding to override keyword for the compiler to understand if this is annotation or not. The override function should have the same definition along with return type and a number of parameters in both the base and inherited classes. If there is a difference in any of these, it will not be considered an override function while understanding this function as a new function.

How @Override Annotation works in Java?

Override annotation is used just before the overriding function defined in the inherited class to ensure that compiler understands that this function is intentionally defined with the same parameters and return type in two different classes.

So that system understands which function to call as the function has the same parameters in both the base and inherited class, we have to call the function using instances.

If a function is called using the object of a parent class, then the parent class function with its local function definition is called while if the object of an inherited class is used, then the function of an inherited class is invoked.

Example:

Base class {} Child class{} Base object1= new Base();// Here Base class is instantiated so the function definition will be called from base class. Base object2= new Child(); function definition will be called from child class

Now the objects which are defined above named “object1” and “object2” are used along with dot operator to pull up function definition.

All of these functions work only if maintained under the main class from where the actual execution of code starts.

The control will hit the Main class and then will search for object instances of the classes predefined above the main class.

The object will then invoke the called function.

One can also pass desired parameters in the function if already defined in the class definition as a prototype.

One base class can be inherited by more than one class; the only difference is of object creation and function calling using that object.

Examples of Java @Override

Given below are the examples:

Example #1

An example to demonstrate the working of override annotation.

Explanation:

A function with the same name is declared and defined in an inherited class called “Cclass” with @override annotation preceding it. Other string is passed as a parameter to it. In the main class, above defined classes are instantiated by creating their objects. “object1” identifies the object of Pclass and “object2” identifies the object for Cclass. The same function is called using these different objects. In the first case, object1 gets the string from Pclass, which is the parent class. While later, when object2 is called, then @override annotation comes under action and changes the content string. This is an overriding facility provided under Java for understandable code and better functionality.

Code:

class Pclass { void printfunction() { System.out.println("This is the output of function present in parent class "Pclass". "); } } class Cclass extends Pclass { @Override void printfunction() { System.out.println("This is the output of function present in child class "Cclass"."); } } public class Main { public static void main(String[] args) { Pclass object1 = new Pclass(); object1.printfunction(); Pclass object2 = new Cclass(); object2.printfunction(); } }

Output:

Here is the output screen with two string lines. The first string line comes from the base function, while the second string line comes from the overriding function defined in the inherited class.

Example #2

Code:

class Pclass { void printfunction() { System.out.println("This is the output of function present in parent class "Pclass". "); } } class Cclass extends Pclass { @Override void printfunction() { System.out.println("This is the output of function present in child class "Cclass"."); } } class Cclass2 extends Pclass { @Override void printfunction() { System.out.println("This is the output of function present in child class number 2 "Cclass"."); } } public class Main { public static void main(String[] args) { Pclass object1 = new Pclass(); object1.printfunction(); Pclass object2 = new Cclass2(); object2.printfunction(); } }

Output:

Conclusion

Hence Java override function comes with a lot of benefits like providing run-time polymorphism, easy code access, clean code and many more. Adding override annotation assures that the compiler understands the intention of function definition via function declarations in classes. This is one of the important properties of the oops concept called polymorphism.