Method Overloading in Java

Introduction

Method Overloading is a fundamental concept in Java that allows a class to have more than one method with the same name, as long as their parameter lists are different. It is a prime example of Compile-Time Polymorphism (or Static Polymorphism).

Overloading improves code readability and reusability by allowing developers to use a single, meaningful method name to perform similar operations on different types of inputs.

Rules for Method Overloading

For two methods to be overloaded, they must share the same method name but have different parameter lists (method signatures).

The parameter list can differ in three ways:

1. Number of parameters
2. Data type of parameters
3. Order of data types of parameters

Note: The return type alone is not sufficient to overload a method. If two methods have the same name and parameters but different return types, the compiler will throw an error.

Code Examples

1. Changing the Number of Parameters

public class MathOperations {
    // Method with two parameters
    public int add(int a, int b) {
        return a + b;
    }

    // Overloaded method with three parameters
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

2. Changing the Data Type of Parameters

public class Printer {
    // Prints an integer
    public void print(int i) {
        System.out.println("Integer: " + i);
    }

    // Prints a String
    public void print(String s) {
        System.out.println("String: " + s);
    }
}

3. Changing the Order of Parameters

public class Profile {
    public void setup(String name, int age) {
        System.out.println("Name first: " + name + ", " + age);
    }

    public void setup(int age, String name) {
        System.out.println("Age first: " + age + ", " + name);
    }
}

Advanced Scenarios and Edge Cases

1. Autoboxing and Overloading

When dealing with primitives and wrapper classes, Java follows specific resolution rules:

1. Exact match
2. Implicit casting (e.g., int to long)
3. Autoboxing (e.g., int to Integer)
4. Varargs

public class AutoboxingExample {
    public void display(long a) {
        System.out.println("Primitive long");
    }
    
    public void display(Integer a) {
        System.out.println("Wrapper Integer");
    }

    public static void main(String[] args) {
        AutoboxingExample obj = new AutoboxingExample();
        obj.display(10); // Matches `long` before it matches `Integer` (widening beats boxing)
    }
}

2. Overloading with Null

Passing null can sometimes cause ambiguity if multiple overloaded methods accept objects.

public class NullExample {
    public void show(String s) {
        System.out.println("String method");
    }

    public void show(Object o) {
        System.out.println("Object method");
    }

    public static void main(String[] args) {
        NullExample obj = new NullExample();
        obj.show(null); // Resolves to String because String is a more specific type than Object
    }
}

If you had a method show(Integer i) alongside show(String s), passing null would result in a compile-time ambiguity error, because neither Integer nor String is more specific than the other.

3. Method Overloading vs. Overriding

• Overloading happens at compile-time within the same class (or via inheritance) when method signatures differ.
• Overriding happens at runtime in a subclass when a method has the exact same signature as a method in the parent class.

Summary

• Method Overloading increases readability by grouping conceptually identical operations under one name.
• Methods must differ by the number, type, or order of parameters.
• Return types and access modifiers have no impact on overloading rules.
• Understanding how the compiler resolves overloaded methods (especially with varargs, boxing, and nulls) is crucial to avoiding tricky compile-time errors.