Method overloading in Java allows a subclass to provide a specific implementation for a method already defined in its superclass. This feature allows a subclass to provide a specific implementation of a method already defined in its superclass, enhancing the flexibility and extensibility of your code. This article will guide you through the practical uses of method overriding in Java, a fundamental concept in Object-Oriented Programming.
What is Method Overriding?
Method overriding is an object-oriented programming language feature that allows a subclass to provide a specific implementation for a method already defined in its superclass. Although the method in a subclass has the same name, return type, and parameters as the method in its superclass, the method in the subclass overrides the method in the superclass.
Get curriculum highlights, career paths, industry insights and accelerate your technology journey.
Download brochure
Rules of Method Overloading in Java
Final methods can not be overridden: In Java, if we don’t want a method to be overridden in the subclass, We declare it as a final keyword.
The following program demonstrates the final keyword program.
Program
class ParentClass {
final void show(){
System.out.println("Show Display Something") ;
}
}
class ChildClass extends ParentClass{
void show(){
System.out.println("Show Display Something");
}
}
class Main{
public static void main(String args[]){
System.out.println("Final KeyWord Example") ;
ChildClass ob = new ChildClass() ;
}
}
Output
Main.java:8: error: show() in ChildClass cannot override show() in ParentClass
void show(){
^
overridden method is final
Static methods can not be overridden(Method Overriding vs Method Hiding)
When a developer defines a static method with the same signature as a static method in the base class. It is known as a method of hiding. The following table describes what happens when you define a method with the same signature as a method in a super-class.
Superclass Instance Method
Superclass Static Method
Subclass Instance Method
Overrides
Generates a compile-time error
Subclass Static Method
Generates a compile-time error
Hides
Program
class Parent {
static void addition(int x, int y){
System.out.println("Addition ="+(x+y)) ;
}
void subtraction(int x, int y) {
System.out.println("Subtraction = "+(x-y)) ;
}
}
class Child extends Parent {
static void addition(int x, int y){
System.out.println("Addition = "+(x+y));
}
@Override public void subtraction(int x, int y){
System.out.println("Subtract = "+(x-y)) ;
}
}
// Driver class
class Main {
public static void main(String[] args){
Parent ob = new Child() ;
ob.addition(30, 40);
ob.subtraction(50, 40);
}
}
Output
Addition =70
Subtract = 10
Private methods can not be overridden
We cannot override private methods in the subclass. Because the scope of private methods is limited to the class, we cannot access them outside the defined class.
Program
class SuperClass{
private void privateMethodExample(){
System.out.println("Private Method Example in Java") ;
}
public void publicMethodExample(){
System.out.println("This is a public method in SuperClass");
}
}
class SubClass extends SuperClass{
private void privateMethodExample(){
System.out.println("This is a private method in SubClass") ;
}
public void publicMethodExample(){
System.out.println("This is a public method in SubClass");
privateMethodExample();
}
}
class Main{
public static void main(String args[]){
System.out.println("Private Method Example ") ;
SuperClass ob = new SuperClass() ;
ob.publicMethodExample() ;
SubClass ob2 = new SubClass() ;
ob2.publicMethodExample();
}
}
Output
Private Method Example
This is a public method in SuperClass
This is a public method in SubClass
This is a private method in SubClass
The overriding method must have the same return type (or subtype)
After Java 5.0 was released, it is possible to have different return types for an overriding method in the child class, but the child’s return type should be a subtype of the parent’s return type. This phenomenon is known as the covariant return type.
The following program demonstrates the overriding method.
Program
class SuperClass {
public Object ObjectFuntion()
{
System.out.println(
"This is the method in SuperClass");
return new Object();
}
}
class SubClass extends SuperClass {
public String StringFunction()
{
System.out.println(
"This is the method in SubClass");
return "Hello, World!";
}
}
public class Main {
public static void main(String[] args)
{
SuperClass obj = new SuperClass();
obj.ObjectFuntion();
SubClass obj2 = new SubClass();
obj2.StringFunction();
}
}
Output
This is the method in SuperClass
This is the method in SubClass
Invoking overridden method from sub-class
Using the super keyword, we can use all the parent class methods in the overriding method.
The following program uses the super keyword in the sub-class.
Program
class SuperClass {
void show() {
System.out.println("Superclass show method");
}
}
class ChildClass extends SuperClass {
@Override void show(){
super.show();
System.out.println("Child show method");
}
}
class Main {
public static void main(String[] args){
SuperClass ob = new ChildClass();
ob.show() ;
}
}
Output
Superclass show method
Child show method
Example of Method Overriding
The following program demonstrates method overriding in Java.
Program
// Superclass
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
// Subclass
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.sound(); // Output: Dog barks
}
}
Output
Dog barks
The above program’s ‘Dog’ class overrides the ‘sound’ method of the ‘Animal’ class. When a sound method is called on an ‘Animal’ reference pointing to a ‘Dog’ object, the overridden method in the ‘Dog’ class is executed. This demonstrates the runtime polymorphism.
Uses of Method Overriding
Let’s discuss the uses of Method Overriding in the Java language.
Runtime Polymorphism: Method overriding achieves runtime polymorphism in Java. It allows a method to behave differently based on the object that invokes it.
Code Reusability: By overriding methods, subclasses can reuse the interface provided by the superclass while providing a specific implementation. This promotes code reusability and cleaner code architecture in the Java program.
Enhancing Functionality: In Overriding, the Subclass can enhance or modify the behaviour of methods inherited from the superclass. It makes it possible to extend the functionality without altering the superclass code.
Frameworks and Libraries: Method overriding is extensively used in frameworks and libraries where default methods are provided in base classes, and users can override these methods to customise behaviour.
Conclusion
In this article, we learned about method overriding in Java. It is a powerful feature that enables subclasses to customise or completely replace the behaviour of methods defined in their superclasses. By following the rules of method overriding, developers can leverage this mechanism to achieve polymorphism, which enhances code flexibility and promotes reusability. Understanding and effectively using method overriding is essential for mastering object-oriented programming.
FAQs
What is method overriding in Java?
In Java, method overriding allows a subclass to provide a specific implementation for a method already defined in its superclass. The overridden method in the subclass has the same name, return type, and parameters as the method in the superclass.
Can a private method be overridden?
Private methods cannot be overridden because they are not accessible outside their own class. They are not inherited by subclasses.
Can a static method be overridden?
In Java language, static methods cannot be overridden. They belong to the class itself rather than instances of the class. However, they can be hidden in subclasses using the same method signature.
Can we override a ‘final’ method?
No, A method declared as ‘final’ in the superclass cannot be overridden in the subclass. The ‘final’ keyword indicates that the method’s implementation is complete and cannot be changed.
Can an abstract method be overridden?
Yes, we can also override a subclass if it is not abstract. The subclass provides the implementation for the abstract method defined in the superclass.
Hero Vired is a leading LearnTech company dedicated to offering cutting-edge programs in collaboration with top-tier global institutions. As part of the esteemed Hero Group, we are committed to revolutionizing the skill development landscape in India. Our programs, delivered by industry experts, are designed to empower professionals and students with the skills they need to thrive in today’s competitive job market.
