Overloading vs Overriding in Java (original) (raw)

Last Updated : 8 Jun, 2026

Method Overloading and Method Overriding are two important concepts in Java that enable polymorphism. Overloading allows multiple methods with the same name but different parameters within the same class, while overriding allows a subclass to provide a specific implementation of a method already defined in its parent class.

• Both concepts improve code reusability and readability.
• Overloading achieves compile-time polymorphism, whereas overriding achieves runtime polymorphism.
• They help create flexible and maintainable object-oriented applications.

Method Overloading (Compile-Time Polymorphism)

Method Overloading occurs when multiple methods in the same class have the same name but different parameter lists. It allows a method to perform similar operations with different types or numbers of inputs.

• Methods must differ in the number, type, or order of parameters.
• The method to execute is determined by the compiler at compile time. Java `

public class OverloadDemo {

static int my_Sum(int a, int b) {
    return a + b;
}

static int my_Sum(int a, int b, int c) {
    return a + b + c;
}

public static void main(String[] args) {

    System.out.println(
        "my_Sum with 2 int parameters: "
        + my_Sum(4, 6));

    System.out.println(
        "my_Sum with 3 int parameters: "
        + my_Sum(4, 6, 7));
}

}

`

Output

my_Sum with 2 int parameters: 10 my_Sum with 3 int parameters: 17

**Explanation: The my_Sum() method is overloaded by defining multiple methods with the same name but different parameter lists. The compiler chooses the appropriate method based on the number of arguments passed. This demonstrates compile-time polymorphism.

Method Overriding (Runtime Polymorphism)

Method Overriding occurs when a subclass provides its own implementation of a method already defined in the parent class. It allows the same method to behave differently based on the object's actual type.

• The method in the child class must have the same signature as the parent class method.
• The method to execute is determined by the JVM at runtime. Java `

// Parent class class Calculator {

public int my_Sum(int a, int b) {

    System.out.println("Parent class sum method:");
    return a + b;
}

}

// Child class class AdvancedCalculator extends Calculator {

@Override
public int my_Sum(int a, int b) {

    System.out.println(
        "Child class overridden sum method:");

    return a + b + 10;
}

}

// Main class public class OverrideDemo {

public static void main(String[] args) {

    Calculator calc1 = new Calculator();
    System.out.println(
        "Result: " + calc1.my_Sum(5, 10));

    AdvancedCalculator calc2 =
        new AdvancedCalculator();
    System.out.println(
        "Result: " + calc2.my_Sum(5, 10));

    // Runtime Polymorphism
    Calculator calc3 =
        new AdvancedCalculator();

    System.out.println(
        "Result: " + calc3.my_Sum(5, 10));
}

}

`

Output

Parent class sum method: Result: 15 Child class overridden sum method: Result: 25 Child class overridden sum method: Result: 25

**Explanation: The child class overrides the my_Sum() method of the parent class. When a Calculator reference points to an AdvancedCalculator object, Java calls the overridden method at runtime. This demonstrates runtime polymorphism (dynamic method dispatch).

Method Overloading vs Method Overriding

The differences between Method Overloading and Method Overriding in Java are as follows: