1. What is Method Overloading in Java?

Method overloading occurs when multiple methods in the same class share the same name but have different parameters (type, number, or both). The main idea behind method overloading is to increase the readability of the program.

1.1 Characteristics of Method Overloading

Same method name : All overloaded methods must have the same name.
Different parameter lists : The methods must differ in the number of parameters or their types.
Compile-time polymorphism : Method overloading is an example of compile-time (or static) polymorphism in Java.

1.2 Example of Method Overloading

Let's take a look at a simple example to illustrate method overloading:

public class Calculator {

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

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

    // Method to add two doubles
    public double add(double a, double b) {
        return a + b;
    }
}

1.3 Explanation of the Example

In the above example, the Calculator class has three overloaded methods named add. Each method has a different parameter list:

The first method takes two int parameters.
The second method takes three int parameters.
The third method takes two double parameters.

When the add method is called, the appropriate version is selected based on the arguments passed. This makes the code more intuitive and easier to understand.

1.4 Demo and Results

public class TestCalculator {
    public static void main(String[] args) {
        Calculator calc = new Calculator();

        System.out.println("Addition of two integers: " + calc.add(10, 20)); // Outputs 30
        System.out.println("Addition of three integers: " + calc.add(10, 20, 30)); // Outputs 60
        System.out.println("Addition of two doubles: " + calc.add(10.5, 20.5)); // Outputs 31.0
    }
}

2. What is Method Overriding in Java?

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The purpose of method overriding is to allow a subclass to provide a specific implementation of a method that is already defined by one of its superclasses.

2.1 Characteristics of Method Overriding

Same method signature : The method in the subclass must have the same name, return type, and parameters as the method in the superclass.
Runtime polymorphism : Method overriding is an example of runtime (or dynamic) polymorphism in Java.
@override annotation : It's good practice to use the @override annotation to indicate that a method is overriding a superclass method.

2.2 Example of Method Overriding

Let's see a practical example of method overriding:

class Animal {
    // Method in the superclass
    void sound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    // Overriding the sound() method in the subclass
    @Override
    void sound() {
        System.out.println("The dog barks");
    }
}

2.3 Explanation of the Example

In the above example:

The Animal class has a method named sound that prints a general message.
The Dog class extends Animal and overrides the sound method to provide a specific message.

When the sound method is called on an instance of Dog, the overridden method in Dog is executed.

2.4 Demo and Results

public class TestAnimal {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Upcasting
        myDog.sound(); // Outputs: The dog barks
    }
}

3. Overloading vs. Overriding: Key Differences

3.1 Definition

Overloading : Involves multiple methods in the same class with the same name but different parameters.
Overriding : Involves redefining a method in a subclass that is already defined in the superclass.

3.2 Polymorphism Type

Overloading : Represents compile-time polymorphism.
Overriding : Represents runtime polymorphism.

3.3 Binding

Overloading : Method binding occurs at compile time.
Overriding : Method binding occurs at runtime.

3.4 Use Case

Overloading : Used when methods perform similar functions with different types or numbers of parameters.
Overriding : Used when a subclass needs to provide a specific implementation for a method that is already defined in the superclass.

4. Conclusion

Understanding the differences between method overloading and method overriding is crucial for writing effective Java code. Overloading enhances the readability and usability of your code by allowing multiple methods with the same name but different parameters. Overriding, on the other hand, enables a subclass to provide a specific implementation of a method that is already defined in the superclass, facilitating runtime polymorphism.

If you have any questions or need further clarification, feel free to comment below. I'm here to help!

Read posts more at : What are overloading and overriding in Java