Difference Between Method Overloading and Method Overriding in Java

Understanding method overloading and method overriding is crucial for Java developers, whether you're a beginner or an intermediate programmer. Both are part of Java’s polymorphism feature but serve different purposes. This guide explains the differences with examples, use cases, and practical code samples.

What is Method Overloading in Java?

Method overloading occurs when multiple methods in the same class have the same name but different parameters (type, number, or order). It allows you to perform similar operations with different types or numbers of inputs.

Key Features of Method Overloading

• Same method name in the same class.
• Different parameter list (number, type, or order).
• Return type can be same or different.
• Resolved at compile time (compile-time polymorphism).

Example of Method Overloading

📄

class Calculator {
    int add(int a, int b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
    double add(double a, double b) { return a + b; }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 10));       // 15
        System.out.println(calc.add(5, 10, 15));   // 30
        System.out.println(calc.add(5.5, 10.5));   // 16.0
    }
}

What is Method Overriding in Java?

Method overriding occurs when a subclass provides a specific implementation for a method already defined in its parent class. It enables runtime polymorphism, where the method executed depends on the object type at runtime.

Key Features of Method Overriding

• Same method name, parameters, and return type as parent method.
• Allows a subclass to provide specific behavior.
• Resolved at runtime (runtime polymorphism).
• Access modifiers cannot be more restrictive than the parent method.

Example of Method Overriding

📄

class Animal {
    void sound() { System.out.println("Animal makes a sound"); }
}

class Dog extends Animal {
    @Override
    void sound() { System.out.println("Dog barks"); }
}

class Cat extends Animal {
    @Override
    void sound() { System.out.println("Cat meows"); }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        Animal d = new Dog();
        Animal c = new Cat();

        a.sound(); // Animal makes a sound
        d.sound(); // Dog barks
        c.sound(); // Cat meows
    }
}

Comparison Table: Method Overloading vs Method Overriding

Practical Use Cases

Use Cases of Method Overloading

• Different ways of calculating or processing data.
• Multiple constructors in a class.
• Flexible API methods in libraries.

Use Cases of Method Overriding

• Customizing behavior of base classes.
• Implementing abstract methods.
• Enabling dynamic polymorphism.

FAQs

1. Can a private method be overridden?

No, private methods cannot be overridden because they are not visible to subclasses.

2. Can overloading be done by only changing return type?

No, parameter lists must differ. Changing only return type is insufficient.

3. Is overriding possible without inheritance?

No, overriding requires a parent-child relationship.

4. Can a static method be overridden?

No, static methods cannot be overridden but can be hidden.

5. Which is faster: overloading or overriding?

Overloading is faster since it’s resolved at compile time, while overriding is resolved at runtime.

Conclusion

Method overloading and overriding are core to Java’s polymorphism. Overloading enhances flexibility at compile time, while overriding allows subclasses to provide specific behavior at runtime. Understanding the difference is key to writing maintainable and efficient Java code.