Java Method Overloading & Overriding

In the realm of Java programming, two essential concepts that developers encounter frequently are method overload and method override. These concepts are fundamental to object-oriented programming (OOP) and play a crucial role in designing robust and flexible software. In this article, we will delve into these concepts, explore their differences, and showcase practical examples to enhance your comprehension.

1. Method Overload

Method overloading is a feature in Java that allows a class to have multiple methods with the same name but different parameter lists within the same class. The method signature, which includes the method name and parameter types, distinguishes these overloaded methods. Method overloading enables the creation of multiple versions of a method with varying input parameters, providing flexibility and convenience in method usage.

1.1 Syntax of Method Overload

To overload a method in Java, you need to define multiple methods with the same name but different parameter lists. The parameters can differ in terms of type, number, or both.

public class MyClass {

   // Method with a single integer parameter
   public void myMethod(int number) {
       // Method logic for integer parameter
   }

   // Method with a double and an integer parameter
   public void myMethod(double value, int number) {
       // Method logic for double and integer parameters
   }
   
   // Method with a string parameter
   public void myMethod(String text) {
       // Method logic for string parameter
   }
}

1.2 Example of Method Overload

Let's illustrate method overloading with a practical example:

public class Calculator {

   public int add(int a, int b) {
       return a + b;
   }

   public double add(double a, double b) {
       return a + b;
   }

   public int add(int a, int b, int c) {
       return a + b + c;
   }

   public static void main(String[] args) {
       Calculator calculator = new Calculator();

       // Calling the add method with two integers
       int result1 = calculator.add(5, 7);
       System.out.println("Result of adding two integers: " + result1);

       // Calling the add method with two doubles
       double result2 = calculator.add(3.5, 2.5);
       System.out.println("Result of adding two doubles: " + result2);

       // Calling the add method with three integers
       int result3 = calculator.add(2, 4, 6);
       System.out.println("Result of adding three integers: " + result3);
   }
}

Output :
 

In this example, the Calculator class has three overloaded add methods, each accepting a different number or type of parameters. The appropriate method is invoked based on the number and types of arguments passed.

2. Method Override

Method overriding is a crucial feature in Java's inheritance mechanism, allowing a subclass to provide a specific implementation for a method defined in its superclass. The subclass must have the same method signature (name and parameter types) to successfully override the method.

Use of @Override

When utilizing method override, it's good practice to use the @Override annotation to explicitly indicate that a method is intended to override a method from a superclass. The @Override annotation helps catch errors in case the method signature does not match any method in the superclass.

class Parent {

   public void display() {
       System.out.println("Parent's display method");
   }
}

class Child extends Parent {

   @Override
   public void display() {
       System.out.println("Child's display method");
   }
}

2.1 Syntax of Method Override

To override a method in Java, follow these steps:

1. Create a subclass that extends a superclass.
2. Define a method in the subclass with the same name, return type, and parameter list as the method in the superclass.

class Superclass {

   public void display() {
       System.out.println("Superclass display method");
   }
}
class Subclass extends Superclass {

   @Override
   public void display() {
       System.out.println("Subclass display method");
   }
}

public class Main {
   public static void main(String[] args) {
       Superclass superClassReference = new Superclass();
       Superclass subClassReference = new Subclass();

       System.out.println("Calling display() using Superclass reference:");
       superClassReference.display();

       System.out.println("\nCalling display() using Subclass reference:");
       subClassReference.display();
   }
}

Output:  
 

2.2 Example of Method Override

Let's demonstrate method override with an example:

class Animal {

   public void makeSound() {
       System.out.println("Generic animal 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 catAsAnimal = new Cat();
       Cat cat = new Cat();

       System.out.println("Calling makeSound() on Animal object:");
       animal.makeSound();

       System.out.println("\nCalling makeSound() on Cat as an Animal object:");
       catAsAnimal.makeSound();

       System.out.println("\nCalling makeSound() on Cat object:");
       cat.makeSound();
   }
}

Output:
 

In this example, the Cat class overrides the makeSound method from the Animal class to provide a specific sound for a cat.

Method Overloading vs Method Overriding

Here are the key differences between method overloading and method overriding presented in a tabular format:
 

Method overloading and method overriding are fundamental concepts in Java that empower developers to write flexible and modular code. Understanding these differences is crucial for effective utilization in software development. Method overloading allows for multiple versions of a method with different parameter lists, enhancing flexibility and ease of use. On the other hand, method overriding enables a subclass to provide a specific implementation for a method defined in a superclass. Leveraging these features wisely enhances the structure and functionality of your Java programs.