Method Overloading in Java

Method overloading in Java is a feature that allows a class to have more than one method with the same name, provided their parameter lists (also known as method signatures) are different. This is a type of polymorphism (specifically, compile-time or static polymorphism) where multiple methods can perform similar but slightly varied tasks, differentiated by the number and type of their parameters.

Key Points of Method Overloading:

  1. Same Method Name: The overloaded methods must have the same name.
  2. Different Parameter List: The parameter list must differ in at least one of the following ways:
    • Number of parameters
    • Type of parameters
    • Order of parameters (if the types are different)
  3. Return Type: The return type can be different, but it does not contribute to the method signature for overloading purposes.

Benefits of Method Overloading:

  • Readability: Makes the code easier to read and understand by using the same method name for similar actions.
  • Reusability: Encourages code reuse by allowing a common method name for related functionalities.
  • Flexibility: Provides the ability to call the same method with different types or numbers of arguments.

Example of Method Overloading:

Here's a simple example to demonstrate method overloading:

public class MethodOverloadingExample {

    // 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 double values
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        MethodOverloadingExample example = new MethodOverloadingExample();

        // Calling the first add method
        System.out.println("Sum of two integers: " + example.add(10, 20));

        // Calling the second add method
        System.out.println("Sum of three integers: " + example.add(10, 20, 30));

        // Calling the third add method
        System.out.println("Sum of two doubles: " + example.add(10.5, 20.5));
    }
}

Explanation:

  • First add Method: Takes two integers as parameters and returns their sum.
  • Second add Method: Takes three integers as parameters and returns their sum.
  • Third add Method: Takes two double values as parameters and returns their sum.
  • Main Method: Demonstrates calling each of the overloaded add methods.

Key Takeaway:

Method overloading enhances the readability and usability of code by allowing multiple methods with the same name to exist within a class, each performing similar but distinct tasks based on the parameters passed to them. This leads to cleaner and more intuitive code.

Program to try:Write a Java program to calculate the area of different shapes namely circle, rectangle, and triangle using the concept of method overloading.

public class AreaCalculator {

    // Method to calculate the area of a circle
    public double calculateArea(double radius) {
        return Math.PI * radius * radius;
    }

    // Method to calculate the area of a rectangle
    public double calculateArea(double length, double width) {
        return length * width;
    }

 
    // Method to calculate the area of a triangle using three sides (Heron's formula)
    public double calculateArea(double a, double b, double c) {
        // Calculate the semi-perimeter
        double s = (a + b + c) / 2;

        // Calculate the area using Heron's formula
        double area = Math.sqrt(s * (s - a) * (s - b) * (s - c));

        return area;
    }

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

        // Calculate and print the area of a circle
        double circleArea = calculator.calculateArea(5.0);
        System.out.println("Area of the circle: " + circleArea);

        // Calculate and print the area of a rectangle
        double rectangleArea = calculator.calculateArea(4.0, 6.0);
        System.out.println("Area of the rectangle: " + rectangleArea);

      
        // Calculate and print the area of a triangle (three sides)
        double triangleAreaBySides = calculator.calculateArea(3.0, 4.0, 5.0);
        System.out.println("Area of the triangle (three sides): " + triangleAreaBySides);
    }
}


Comments

Post a Comment

Popular posts from this blog

KTU OOP LAB JAVA CSL 203 BTech CS S3 - Dr Binu V P

About Me Scheme and Evaluation Syllabus and Practice Questions ******************************** How to do Java Programs in  Debian PART A Basic Java Programs Using Control  Statements 1.String Problems 2.Numerical Problems 3.Arrays 4.Matrix Lab Exercise Java-1 PART B  Object Oriented Programming 1.Creating classes and objects. constructor for initializing object 2.Method overloading in Java 3.Single Inheritance 4.Multilevel Inheritance 5.Method overriding in Java 6. Hierarchical Inheritance 7.Interface in Java 8.Abstract classes in java  PART C Exception and File Handling 1.Exception Handling in Java 2.Reading and Writing Text Files 3.Buffered Reader and String Tokenizer PART D Multi-Threading  Creating Threads in Java Thread Synchronization in Java Thread Priorities in Java Programs using Multi-Threading PART E Graphics and Database Programming Introduction to Java Swing Drawing Shapes Drawing  a Sine Wave Handling Mouse Events Handling Keyboard ...
Read more

Reading and Writing Text Files

Handling text files in Java involves performing operations like reading from, writing to, and appending to files. Here are some common techniques and examples for handling text files in Java: FileReader and BufferedReader are classes in Java used for reading text from files. Here’s a detailed explanation of each: FileReader FileReader is a class in Java that is used to read character files. It is a convenient class for reading text files using the default character encoding of the operating system. Key Points: Purpose : To read text files. Inheritance : It extends InputStreamReader , which in turn extends Reader . Encoding : Uses the default character encoding of the operating system unless specified otherwise. Basic Usage : Suitable for simple file reading tasks. Example: create a text file "example.txt" using any text editor and then run this program.In this example, FileReader reads the file character by character. import java.io.FileReader; import java.io.IOException; ...
Read more

String Problems

Reverse a String import java.util.Scanner; public class ReverseString { public static void main(String[] args) {      Scanner scanner = new Scanner(System.in);      System.out.print("Enter a string to reverse: ");      String input = scanner.nextLine();      String reversed = new StringBuilder(input).reverse().toString();      System.out.println("Reversed string: " + reversed);      scanner.close(); } } without using StringBuilder import java.util.Scanner; public class ReverseString {     public static void main(String[] args) {         Scanner scanner = new Scanner(System.in);         System.out.print("Enter a string to reverse: ");         String input = scanner.nextLine();         // Manually reverse the string         String reversed = "";         for (int i = input....
Read more