Method Overriding and Method Overloading in Java

In Java, method overriding and method overloading are two important concepts related to polymorphism.

Method Overriding:

Method overriding occurs when a subclass provides a different implementation of a method that is already defined in its superclass. The method in the subclass must have the same name, return type, and parameters as the method in the superclass. By overriding a method, you can customize the behavior of the method in the subclass to suit your specific needs.

Here's an example to illustrate method overriding:

class Animal { public void makeSound() { System.out.println("The animal makes a sound"); } } class Cat extends Animal { @Override public void makeSound() { System.out.println("Meow"); } } public class Main { public static void main(String[] args) { Animal animal = new Animal(); animal.makeSound(); // Output: "The animal makes a sound" Cat cat = new Cat(); cat.makeSound(); // Output: "Meow" } }

In the example above, the `Cat` class overrides the `makeSound()` method from the `Animal` class. When the `makeSound()` method is called on an instance of `Cat`, it prints "Meow" instead of the default message defined in the `Animal` class.

Method Overloading:

Method overloading occurs when a class has multiple methods with the same name but different parameters. The overloaded methods must have different parameter lists (number of parameters or their types) or different return types. This allows you to define methods that perform similar operations but with different input or output.

Here's an example to illustrate method overloading:

class MathUtils { public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } } public class Main { public static void main(String[] args) { MathUtils math = new MathUtils(); int sum1 = math.add(2, 3); // Calls the first add() method System.out.println(sum1); // Output: 5 double sum2 = math.add(2.5, 3.7); // Calls the second add() method System.out.println(sum2); // Output: 6.2 } }

In the example above, the `MathUtils` class has two `add()` methods—one that takes two `int` parameters and another that takes two `double` parameters. When calling the `add()` method, Java determines the appropriate method to invoke based on the arguments provided.

To summarize, method overriding is about providing a different implementation of a method in a subclass, while method overloading is about defining multiple methods with the same name but different parameters in a class. Both concepts play a crucial role in achieving polymorphism in Java.