Java Method Overloading

What is Method Overloading in Java?

The Basics of Method Overloading in Java

void methodName (int parameter1) {
    // Code
}

void methodName (double parameter1, double parameter2) {
    // Code
}

Key Characteristics of an Overloaded Method in Java

• Method overloading enhances code readability and re-usability since you can use the same method name for similar actions.
• Method overloading is determined at compile-time, hence also known as compile-time polymorphism.
• Methods can be overloaded in the same class or in subclasses.

class Geometry {
    void calculateArea(int side){
        int area = side * side;
        System.out.println("Area of square is: " + area);
    }
    
    void calculateArea(int length, int breadth){
        int area = length * breadth;
        System.out.println("Area of rectangle is: " + area);
    }
}

Methods of Overloading in Java

Constructs Used for Method Overloading

• Varying Number of Parameters: Overloaded methods can have a different number of parameters.
• Different Data Type of Parameters: The methods can have parameters of different data types.
• Different Order of Parameters: If two methods have the same number and type of parameters, the position (or sequence) of the parameters can be changed to overload the methods.

Guidelines for Overloading Methods in Java

Practical Method Overloading Examples in Java

public class Vehicle {
    void run(int speed){
        System.out.println("The vehicle is running at " + speed + "km/hr.");
    }
    
    void run(int speed, int gears){
        System.out.println("The vehicle is running at " + speed + "km/hr with " + gears + " gears.");
    }
}

Method Overloading vs Method Overriding in Java

Differences between Method Overloading and Method Overriding

Before you dive deep into the technicalities, draw a concrete distinction between Method Overloading and Method Overriding.

• Method Overloading is about having the same method name but with different parameters within the same class, while Method Overriding is all about providing a specific implementation to a method already provided by its superclass. Essentially, in Method Overriding, the method in a subclass has the same name, type, and parameters as the one in its superclass.
• Method Overloading is the example of compile-time (or static) polymorphism, while Method Overriding is an example of runtime (or dynamic) polymorphism.
• Method Overriding is done across classes that have inheritance relationships, while Method Overloading can be accomplished within a single class.
• The return type can be different in Method Overloading, but it must be the same or covariant in Method Overriding.

Understanding when to use Method Overloading vs Method Overriding

void addNumbers(int num1, int num2) {
    // addition code here
}

void addNumbers(int num1, int num2, int num3) {
    // addition code here
}

class Shape {
    void draw() {
      // draw a generic shape
    }
}

class Rectangle extends Shape {
    @Override
    void draw() {
      // draw a rectangle
    }
}

class Circle extends Shape {
    @Override
    void draw() {
      // draw a circle
    }
}

Analysing a Java Method Overloading Example

Breakdown of a Simple Method Overloading Example in Java

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

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

Interpreting a Complex Method Overloading Example in Java

class Geometry {
    // method to calculate area of square
    static double area(int side) {
        return Math.pow(side, 2);
    }

    // method to calculate area of rectangle
    static double area(int length, int breadth) {
        return length * breadth;
    }

    // method to calculate area of circle
    static double area(double radius) {
        return Math.PI * Math.pow(radius, 2);
    }
}

Delving into the Purpose of Java Method Overloading

Why is Method Overloading Important in Java Programming?

int multiply(int a, int b) {
    return a * b;
}

double multiply(double a, double b, double c) {
    return a * b * c;
}

Real-world applications of Java Method Overloading