Difference Between Method Overloading and Method Overriding in Java

Have you ever thought about how you can use the same method name for different tasks in Java? Or how does a child class change the behavior of its parent method? What if you want to reuse method names without writing completely new ones? And how does Java determine which version of a method to execute when dealing with compile-time vs runtime polymorphism in Java?

In this article, we will understand the concepts of Method Overloading and Method Overriding, the key differences between them, and when and how to use them effectively.

Table of Contents:

• Method Overloading in Java
• Method Overriding in Java
• Difference Between Method Overloading and Method Overriding in Java
• When to Use Method Overriding in Java?
• When to Use Method Overloading in Java?
• Conclusion

Method Overloading in Java

Method Overloading is a concept in object-oriented programming, in which you can create more than one method with the same name, but with different types or numbers of inputs. In this, the compiler decides which method to call, based on the arguments you pass. It is a type of polymorphism.

Method Overloading happens at compile-time, so this is also called Compile-Time Polymorphism or Static Polymorphism. Also, method overloading does not depend on inheritance.

Method Overloading rules in Java:

To overload a method in Java, you must change at least one of the following:

1. All overloaded methods must have the same name but different parameter lists. For example,

public void show() {}
public void show(int a) {}

In the above example, both methods are named as show(), so they follow this rule.

2. The types of parameters of the methods should be different. For two methods with the same name, the number or types of parameters must be different. For example,

public void display(int a) {}      // Method with int parameter
public void display(double a) {}   // Method with double parameter
public void display(String s) {}   // Method with String parameter

In the above example, all display() methods are overloaded because they take different types of parameters

3. The order of parameters should be different if the types are different. If the number of parameters in the method are same, then changing their order will also count as valid overloading. For example,

public void print(int a, String b) {}
public void print(String b, int a) {}

In the above example, the method print() has 2 parameters, a and b, the method can be overloaded if the order of the parameters is changed.

For example,

Output:

Explanation:

In the above Java code, the add function is used to add different types of numbers, like integers, two floats, or three integers. The program chooses the right method based on the type and number of values you pass.

Advantages and Disadvantages of Method Overloading in Java

Method Overriding in Java

When a child class has a method with the same name and parameters as the parent class, and provides its own implementation. This is called method overriding. The method that has to be executed is chosen when the program runs, not when it is compiled. Hence, you can also call it runtime polymorphism.

Method Overriding rules in Java:

• The method name in the subclass must be the same; otherwise, Java treats it as a new method, not an override.

class Animal {
    void sound() {       
    }
}
class Dog extends Animal {
    void bark() {        
    }
}

• The method in a subclass must have the exact same parameter list as the methods that are present in its superclass.

class Animal {
    void sound(String type) {
        }
}
class Dog extends Animal {
    void sound(String type) {       
    } 
}

• In method overriding, the return type of the overriding method in its subclass must be exactly the same as the method in the superclass.

class Animal {
    Animal getAnimal() {
        return new Animal();
    }
}
class Dog extends Animal {
    Animal getAnimal() {  
        return new Dog();
    }
}

For example,

Output:

Explanation:

In the above Java code, the child class Student changes the sayHello() method of the parent class Person. When sayHello() is called, the version that runs depends on the actual object, not the reference type. This helps change behaviour in the child class while keeping the same method name.

Advantages and Disadvantages of Method Overriding

Difference Between Method Overloading and Method Overriding in Java

Here, we are going to discuss Method Overloading vs Overriding in Java with example in tabular format:

When to Use Method Overriding in Java?

• Method Overriding is mainly used when you want a child class to change the behaviour of a method that it inherits from its parent class.

• It is also used when the basic logic is useful in a superclass, but the subclasses need their own version, along with the basic one. It helps you to follow the principles of OOPs, like runtime polymorphism, which makes the code meaningful.

• For example, the superclass can be Vehicle, and its subclasses can be bike and car.

When to Use Method Overloading in Java?

• Method Overloading is used when you want to perform similar actions in a class, but with different inputs.

• It mainly does not create multiple methods; instead, it uses the same method name, but with different parameters or counts, which makes your code easier to understand.

• For example, the print() method can be used to print a string, a number, or even two strings.

Unlock Your Future in Java

Start Your Java Journey for Free Today

Explore Program

Conclusion

From the above article, we conclude that method overloading and method overriding make your code easier to manage. Overloading allows you to use the same method in one class, but with different inputs, which helps when you are doing the same task differently. Overriding is used when the working of the parent class needs to be changed, and the behaviour is more specific. Overloading works at compile-time, while overriding happens at runtime. Hence, a person needs to know when and how to use both programs to make their code more flexible and easier to understand.

Overloading and Overriding – FAQs