Java @Override

@Override annotation is used when a developer overrides a function in Java to use the same function name but assign these functions with different properties. If you are aware of over rise functions in Java but have not been using @override annotation since you did not feel like using it as a mandatory option to explicitly write it. It is by default activated since Java 1.5 was introduced. It promotes run time polymorphism. This is because we can override any function without using annotation. Still, it has got one major advantage: if the compiler, by chance, misses the overriding (like the developer did a spelling mistake in the overriding function name). With the help of overriding annotation, the compiler will understand and override the base function with the child function. It also advances the code readability reducing the maintenance time and effort.

Start Your Free Software Development Course

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(); /// Here Child class is instantiated so the
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:

There are two classes defined in the below program: one is the base class, which is also called parent class “Pclass”, while the other class “, Cclass” which is inheriting the properties and member functions of the base, is called inherited or child class. The function is first of all declared in the parent class. In this example, the function name is printfunction() which is assigned with the work of printing the string passed as a parameter.

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:

// This is Base class
class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// Thi is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
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

Here we have one base class with two child classes inheriting it. The second inherited class is instantiated, and the output string is triggered from the 2^nd inherited class.

Code:

class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// This is Child class
class Cclass2 extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class number 2 \"Cclass\".");
}
}
// This is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
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.

The above is the detailed content of Java @Override. For more information, please follow other related articles on the PHP Chinese website!