15 Differences Between Overloading And Overriding In Java (+Examples)

15 mins read

Overloading and overriding are two essential object-oriented programming concepts that allow developers to enhance code flexibility and reusability. While overloading focuses on defining multiple methods with the same name but different parameters, overriding emphasizes redefining a method in a subclass to modify its behavior.
In this article, we will discuss the difference between overloading and overriding in Java. By the end, you’ll understand when and where to use these techniques, ensuring you write efficient, maintainable, and clean code.

• Method Overloading: Creating multiple methods in the same class with the same name/ identifier but different parameter lists (number, data type, or both).
• Method Overriding: Redefining a method in a child class that already exists in the parent class. In the definition of methods in subclass, you maintain the same signature but add a new functionality or a variation.

Difference Between Overloading And Overriding In Java (Comparison Table)

Method overloading and method overriding may sound similar, but they serve distinct purposes. They are used in different contexts and have distinctions that affect how they are implemented. The table below highlights the difference between method overloading and method overriding in Java language.

Now that we know about the differences between method overloading and overriding in Java let's discuss these concepts individually.

What Is Method Overloading In Java?

Method overloading allows a class to have multiple methods with the same name but different parameter lists. This is an example of compile-time polymorphism, where the method call is resolved during compilation based on the arguments passed. It improves code readability and reusability by enabling method customization for different inputs without requiring unique method names.

Rules Of Method Overloading In Java

1. The method name must be the same.
2. The parameter list must differ (by number, type, or order).
3. The return type may or may not be the same.
4. It is independent of access modifiers.
5. Static methods can be overloaded.

Example Of Method Overloading In Java

In the example below, we will illustrate how to define three methods with the same name, which accept different types of variables/ arguments and then a different number of parameters.

Code Example:

class OverloadExample {

// Method to add two integers
int add(int a, int b) {
return a + b;
}

// Overloaded method to add three integers
int add(int a, int b, int c) {
return a + b + c;
}

// Overloaded method to add two doubles
double add(double a, double b){
return a+b;
}
}
class Main{
public static void main(String[] args) {
OverloadExample obj = new OverloadExample();

System.out.println("Addition of 2 integers: " + obj.add(5, 10)); // Calls first method 
System.out.println("Addition of 3 integers: " + obj.add(5, 10, 15)); // Calls second method 
System.out.println("Addition of 2 doubles: " + obj.add(5.5, 10.5)); // Calls third method
}
}

Output:

Addition of 2 integers: 15
Addition of 3 integers: 30
Addition of 2 doubles: 16.0

Explanation:

In this example, the add() method is overloaded three times. Depending on the number and type of arguments passed during the method call, the appropriate method is executed. This demonstrates the flexibility of method overloading in handling various scenarios.

Advantages Of Overloading In Java

1. Increases code readability and reusability by avoiding repetitive method names.
2. Provides flexibility in defining methods to perform similar operations with different input types.
3. Reduces the need for complex method names, simplifying the code structure.

For more, read: Method Overloading In Java | Ways, Rules & Type Promotion (+Codes)

What Is Method Overriding In Java?

Method overriding allows a subclass to provide a specific implementation of a method already defined in its parent class. This is an example of runtime polymorphism, where the method call is resolved at runtime. Overriding is essential for achieving dynamic behavior and adhering to the principles of inheritance and abstraction in OOP.

Rules Of Method Overriding In Java

1. The method must have the same name, return type, and parameter list as the parent class method.
2. The overriding method cannot have a more restrictive access modifier than the overridden method.
3. Only inherited methods can be overridden. This also means that static, final, or private methods cannot be overridden.
4. The overriding method can throw the same or narrower checked exceptions.
5. Requires inheritance between parent and child classes.

Example Of Method Overriding In Java

In the simple Java example below, we first define a single method in the base class and then override it to redefine the functionality within the subclass.

Code Example:

class Parent {
void showMessage() {
System.out.println("This is the parent class message.");
}
}

class Child extends Parent {
@Override
void showMessage() {
System.out.println("This is the child class message.");
}
}

public class Main {
public static void main(String[] args) {

Parent obj1 = new Parent();
Parent obj2 = new Child();

obj1.showMessage(); // Calls parent class method
obj2.showMessage(); // Calls child class method
}
}

Output:

This is the parent class message.
This is the child class message.

Explanation:

In this example, the showMessage() method is overridden in the Child class. When a Child object is assigned to a Parent reference (obj2), the overridden method in the child class is executed. This demonstrates runtime polymorphism and how overriding allows behavior modification in a subclass.

Advantages Of Overriding In Java

1. Supports runtime polymorphism, enabling dynamic method invocation.
2. Allows behavior customization in child classes without modifying the parent class.
3. Enhances code maintainability by centralizing method definitions in parent classes.
4. Adheres to the DRY (Don't Repeat Yourself) principle by reusing the parent class method signature.

For more, read: Method Overriding In Java | Rules, Use-Cases & More (+Examples)

Want to expand your knowledge of Java programming? Check out this amazing Java course and become the Java developer of your dreams.

Key Differences Between Overloading & Overriding In Java Explained

Let's elaborate on some of the key differences between overloading and overriding in Java programming language.

1. Definition | Difference Between Overloading & Overriding In Java

Method Overloading: This occurs when you define multiple methods with the same name but different parameter lists within the same class. The compiler chooses the correct method to invoke based on the number or type of arguments passed.

class Calculator {
int add(int a, int b) { // Adds two integers double
return a + b;
}
add(double a, double b) { // Adds two doubles
return a + b;
}
}

Method Overriding: In method overriding, a subclass redefines a method that already exists in its parent class. The method signature (name, return type, and parameters) in the subclass must match the parent class exactly.

class Animal {
void sound() {
System.out.println("Animal makes a sound");
} }
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks"); } // Overriding the parent class method
}

2. Class | Difference Between Overloading & Overriding In Java

Method Overloading: All overloaded methods must be defined in a single class. These methods are independent of inheritance and don’t rely on any parent-child relationship.
For example, methods add() in the Calculator class above are all within the same class.

Method Overriding: Happens across a parent class and its child class. The child class redefines a method inherited from the parent class, providing specific functionality for the subclass.
For example, the sound() method in the Dog class overrides the sound() method from the Animal class, in the snippet above.

3. Return Type | Difference Between Overloading & Overriding In Java

Method Overloading: The return type can differ between overloaded methods. However, the method signatures must still differ in their parameters.

class Calculator {
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; } // Overloading with a different return type
}

Method Overriding: The return type must be the same as the parent method's return type or a subclass of it (covariant return type). This ensures that the overriding method maintains the contract of the parent class.

class Animal {
Animal sound() { return this; }
}
class Dog extends Animal {
@Override
Dog sound() { return this; } // Covariant return type (returns a Dog, which is a subclass of Animal)
}

4. Type Of Polymorphism | Difference Between Overloading & Overriding In Java

Method Overloading: This is an example of compile-time polymorphism (also known as static binding). The method that gets called is determined at compile time based on the method signature.
For example, the method to be called (add(int, int) or add(double, double)) is resolved during compilation.

Method Overriding: This is run-time polymorphism (also called dynamic binding). The method that gets called is determined at runtime based on the actual object type, not the reference type.
For example, if we create an object of Dog but refer to it through an Animal reference, the overridden sound() method in Dog is called at runtime, not the one in Animal.

5. Inheritance | Difference Between Overloading & Overriding In Java

Method Overloading: In method overloading, inheritance is not a factor. All methods are within the same class and do not require inheritance or parent-child relationships.
For example, overloaded methods, such as in the Calculator class, are defined within the same class.

Method Overriding: In overriding, inheritance is mandatory. The child class inherits the method from the parent class and overrides it to provide a specific implementation.
For example, the Dog class overrides the sound() method from the Animal class, requiring inheritance.

6. Access Modifier Rules | Difference Between Overloading & Overriding In Java

Method Overloading: There are no specific access modifier restrictions for overloaded methods. They can have different access levels (e.g., public, private).
For example, the overloaded add methods could have any valid access modifier.

Method Overriding: The overriding method cannot reduce the visibility of the parent method. For instance, if the parent method is protected, the child class cannot override it with private visibility.
For example, if the sound() method in Animal is protected, the overriding method in Dog must also be protected or public, but not private.

7. Exception Handling | Difference Between Overloading & Overriding In Java

Method Overloading: Overloaded methods can throw different types of exceptions. Since the methods are resolved at compile-time, the compiler doesn't require uniform exception handling across overloaded methods.
For example, overloading methods like add() can throw different exceptions (e.g., IllegalArgumentException for invalid input types).

Method Overriding: Overridden methods can only throw the same exceptions or narrower exceptions (checked exceptions). This ensures that the subclass does not introduce unexpected exceptions that the parent method doesn't handle.
For example, if the parent class method throws IOException, the overridden method in the child class can throw IOException or a subclass of it, but not a broader exception like Exception.

8. Binding / Method Resolution | Difference Between Overloading & Overriding In Java

Method Overloading: Resolved at compile-time (early binding/ binding at compile time). The compiler selects the method to call based on the method signature (parameter types and count).

Method Overriding: Resolved at runtime (late binding/ binding at runtime). The method to call is determined by the actual object type, not the reference type, and is executed when the program runs.

Here is your chance to top the leaderboard while practising your coding skills: Participate in the 100-Day Coding Sprint at Unstop.

Difference Between Overloading And Overriding In Java Code Example

In the following example, we first illustrate method overloading and then overriding. We will then compare the definition and impact of the two concepts in code execution.

Code Example:

// Method Overloading
class OverloadingDemo {
void display(int a) {
System.out.println("Integer: " + a); }

void display(double b) {
System.out.println("Double: " + b); }
}

// Method Overriding
class Parent {
void show() {
System.out.println("Parent's show method"); }
}

class Child extends Parent {
@Override
void show() {
System.out.println("Child's show method"); }
}

class Main {
public static void main(String[] args) {

// Method Overloading
OverloadingDemo obj = new OverloadingDemo();
obj.display(10); // Calls the method with int parameter
obj.display(10.5); // Calls the method with double parameter

// Method Overriding
Parent parentObj = new Parent();
parentObj.show(); // Calls the method in Parent class

Child childObj = new Child();
childObj.show(); // Calls the overridden method in Child class
}
}

Output:

Integer: 10
Double: 10.5
Parent's show method
Child's show method

Explanation:

In the Java code example,

1. We first demonstrate the concept of method overloading by defining a class called OverloadingDemo, with two methods named display(), where one accepts an int parameter and the other a double.
2. These are distinct methods because their parameter types differ. The compiler determines which method to call at compile time based on the argument passed.
3. Next, we illustrate the concept of method overriding using two classes with an IS-A (inheritance) relationship.
4. Here, we first define a class Parent containing a method show() that simply prints "Parent's show method."
5. Then, we define another class Child that inherits from Parent, and overrides the original method with its own implementation. The show() method here prints "Child's show method."
6. In the Main class, we demonstrate the implementation of method overriding and overloading defined above.
7. We first create an object of the OverloadingDemo class named obj and then use it to invoke the overloaded methods with different type of argument in call.
   • When we call obj.display(10), the display(int a) method is invoked.
   • When we call obj.display(10.5), the display(double b) method is invoked.
8. Here, the method is resolved at compile time based on the method signature (i.e., the number and type of parameters). This is why the parameter types (int vs. double) differentiate the methods.
9. Then, we create two more instances, one of Parent class and one of Child class, and use them to call the show() method.
   • When parentObj.show() is called, the show() superclass method is executed.
   • When childObj.show() is called, the overridden show() subclass method is executed despite being called from a Parent reference.
10. Here, the method is resolved at runtime based on the actual object type, which allows for dynamic method dispatch.
11. The JVM checks the actual object type (Parent or Child) at runtime, and the appropriate method is invoked accordingly. This is a key feature of runtime polymorphism. In this case, the Child's method takes precedence, as it's the method associated with the actual object (childObj).

Need more guidance on how to become a Java developer? You can now select an expert to be your mentor here.

Conclusion

Method overloading and method overriding are two fundamental concepts in Java that both offer distinct benefits in object-oriented programming, enabling flexibility and efficiency in code.

Method Overloading allows you to define multiple methods with the same name but different parameter lists within a single class.

• This gives you the flexibility to handle various argument types or counts, with method resolution taking place at compile-time.
• This mechanism is great for scenarios where you need to perform similar actions with different inputs, such as initializing an object with different data types or providing multiple ways to process information.

Method Overriding, on the other hand, empowers subclasses to redefine methods from their parent class, allowing for runtime polymorphism.

• This is particularly useful when you want to provide specific behavior in a subclass while maintaining a consistent interface.
• The method resolution happens at runtime, based on the actual object type, making this mechanism key to implementing dynamic method dispatch and achieving flexibility in behavior based on object instances.

Key differences between overloading and overriding in Java also include their relationship with inheritance and exception handling.

• Overloading does not require inheritance as it can be done within the same class, while overriding mandates inheritance between a parent and subclass.
• Additionally, when it comes to exception handling, overloading allows different exceptions to be thrown, whereas overriding restricts you to throwing exceptions that are narrower than those declared in the parent method.

By understanding the nuances of these mechanisms, you can harness the power of polymorphism to write cleaner, more efficient, and more maintainable code.

Frequently Asked Questions

Q1. Can method overloading occur in different classes?

No, method overloading occurs within the same class. It involves multiple methods with the same name but different parameter lists. If similar methods exist across different classes, it is not considered overloading.

Q2. Why is method overriding possible only in a parent-child relationship?

Method overriding requires inheritance because the concept revolves around redefining a method from the parent class in the child class. Without inheritance, there is no "parent method" to override.

Q3. Is the return type considered for method overloading?

No, method overloading is determined solely by the method's name and parameter list. Changing only the return type while keeping the method name and parameters the same will result in a compilation error.

Q4. Can static methods be overridden in Java?

No, static methods cannot be overridden because they are bound to the class rather than the object. They can, however, be hidden by defining a method with the same name in the subclass. Note that this is not true overriding.

Q5. Can method overloading involve inheritance?

Yes, method overloading can involve inheritance. If a child class inherits methods from its parent and also defines overloaded methods, the overloaded versions in the child class will coexist with the inherited methods.

Q6. Why does method overriding require the same method signature?

For method overriding to work, the overridden and overriding methods must have the exact same signature (name, parameters, and return type). This ensures the method call can be dynamically resolved at runtime based on the actual object's type.

Q7. How does binding differ in overloading and overriding?

Overloading: Uses static binding (also called compile-time binding), where the method to be called is resolved at compile time based on the method signature.

Overriding: Uses dynamic binding (also called runtime binding), where the method call is resolved at runtime based on the object's actual type.

This compiles our discussion on the difference between overloading and overriding in Java. You must also explore the following Java topics:

1. Difference Between Java And JavaScript Explained In Detail
2. 90+ Java Collections Interview Questions (+Answers) You Must Know
3. Java Developer Resume - See How To Make ATS Catch Your Resume
4. Difference Between Java And Python Decoded
5. Volatile Keyword In Java | Syntax, Working, Uses & More (+Examples)