Ugenz Academy/Tutorial

Functionoverloading

8 min read1,455 words

Reading progress

Keep learning

Function Overloading in Java

Introduction

Function Overloading in Java means defining multiple methods with the same name in the same class, but with different parameters.

The parameters can differ in:

  • Number of parameters
  • Type of parameters
  • Order of parameters

Function overloading is an example of compile-time polymorphism.

In Java, functions are generally called methods.

Why Use Function Overloading?

Function overloading is used when several methods perform a similar task but require different types or numbers of inputs.

Example

Instead of creating:

addTwoNumbers() addThreeNumbers() addDoubleNumbers()

We can use the same method name:

add()

with different parameters.

Basic Syntax

class Example { void methodName(int a) { // code } void methodName(int a, int b) { // code } void methodName(double a, double b) { // code } }

Here, all methods have the same name but different parameter lists.

Types of Function Overloading

Function overloading can be achieved mainly by changing:

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

1. Overloading by Number of Parameters

The methods have the same name but different numbers of parameters.

Example

class Addition { int add(int a, int b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } public static void main(String[] args) { Addition obj = new Addition(); System.out.println(obj.add(10, 20)); System.out.println(obj.add(10, 20, 30)); } }

Output

30 60

The first method accepts two parameters, while the second accepts three.

2. Overloading by Data Type

Methods can have the same name and same number of parameters but different data types.

Example

class Display { void show(int number) { System.out.println("Integer: " + number); } void show(double number) { System.out.println("Double: " + number); } void show(String text) { System.out.println("String: " + text); } public static void main(String[] args) { Display obj = new Display(); obj.show(10); obj.show(10.5); obj.show("Java"); } }

Output

Integer: 10 Double: 10.5 String: Java

3. Overloading by Order of Parameters

Methods can have the same number of parameters and the same data types, but the order of different data types can be changed.

Example

class Example { void display(int a, String b) { System.out.println("Integer first: " + a + ", String: " + b); } void display(String b, int a) { System.out.println("String first: " + b + ", Integer: " + a); } public static void main(String[] args) { Example obj = new Example(); obj.display(10, "Java"); obj.display("Java", 10); } }

Output

Integer first: 10, String: Java String first: Java, Integer: 10

Method Signature

For method overloading, Java uses the method signature to distinguish methods.

A method signature consists of:

  • Method name
  • Number of parameters
  • Type of parameters
  • Order of parameter types

Example

add(int, int) add(int, int, int) add(double, double)

These are different method signatures.

Return Type Alone Cannot Overload a Method

Changing only the return type does not create method overloading.

Incorrect Example

class Example { int show() { return 10; } double show() { return 20.5; } }

This causes a compilation error because both methods have the same name and parameter list.

Correct Example

class Example { int show(int a) { return a; } double show(double a) { return a; } }

Here, the parameter types are different.

Function Overloading with Static Methods

Static methods can also be overloaded.

Example

class Calculator { static int multiply(int a, int b) { return a * b; } static int multiply(int a, int b, int c) { return a * b * c; } public static void main(String[] args) { System.out.println(multiply(2, 3)); System.out.println(multiply(2, 3, 4)); } }

Output

6 24

Constructor Overloading

Constructors can also be overloaded in Java.

Example

class Student { String name; int age; Student() { name = "Unknown"; age = 0; } Student(String name) { this.name = name; age = 0; } Student(String name, int age) { this.name = name; this.age = age; } public static void main(String[] args) { Student s1 = new Student(); Student s2 = new Student("Anu"); Student s3 = new Student("Anu", 22); System.out.println(s1.name + " " + s1.age); System.out.println(s2.name + " " + s2.age); System.out.println(s3.name + " " + s3.age); } }

Function Overloading and Compile-Time Polymorphism

Function overloading is called compile-time polymorphism because the compiler determines which overloaded method should be called during compilation.

Example

class Calculator { int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; } public static void main(String[] args) { Calculator c = new Calculator(); System.out.println(c.add(10, 20)); System.out.println(c.add(10.5, 20.5)); } }

The compiler identifies the appropriate add() method based on the arguments.

Function Overloading with Type Promotion

Java can sometimes automatically promote a smaller numeric type to a larger numeric type.

Example

class Test { void show(int a) { System.out.println("Integer method"); } void show(double a) { System.out.println("Double method"); } public static void main(String[] args) { Test obj = new Test(); obj.show(10); obj.show(10.5f); } }

Output

Integer method Double method

The float argument can be promoted to double when needed.

Advantages of Function Overloading

  1. Improves readability because similar operations use the same method name.
  2. Reduces code duplication.
  3. Makes programs easier to understand and maintain.
  4. Provides compile-time polymorphism.
  5. Allows methods to work with different types or numbers of inputs.
  6. Makes APIs easier to use.

Disadvantages of Function Overloading

  1. Too many overloaded methods can make code confusing.
  2. Similar method signatures can sometimes cause ambiguity.
  3. The programmer must carefully choose parameter types.
  4. Complex overloading can make debugging more difficult.

Real-Life Example

Consider a calculator application.

We may need to add:

  • Two integers
  • Three integers
  • Two decimal numbers

Instead of using different method names, we can use one overloaded method called add().

class Calculator { int add(int a, int b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } double add(double a, double b) { return a + b; } public static void main(String[] args) { Calculator c = new Calculator(); System.out.println(c.add(10, 20)); System.out.println(c.add(10, 20, 30)); System.out.println(c.add(10.5, 20.5)); } }

Output

30 60 31.0

Function Overloading vs Function Overriding

Function OverloadingFunction Overriding
Same method nameSame method name
Different parameter listSame parameter list
Usually occurs in the same classOccurs between superclass and subclass
Compile-time polymorphismRuntime polymorphism
Inheritance is not requiredInheritance is required
Return type alone cannot distinguish methodsCompatible return type is required

Important Rules

  1. Methods must have the same name for overloading.
  2. Parameters must differ in number, type, or order.
  3. Changing only the return type is not enough.
  4. Static methods can be overloaded.
  5. Constructors can be overloaded.
  6. Function overloading provides compile-time polymorphism.
  7. Overloaded methods may have different access modifiers, as long as their parameter lists differ.
  8. Java selects the applicable overloaded method based on the arguments supplied.

Complete Example

class Calculator { // Two integers int calculate(int a, int b) { return a + b; } // Three integers int calculate(int a, int b, int c) { return a + b + c; } // Two double values double calculate(double a, double b) { return a + b; } // String values String calculate(String a, String b) { return a + " " + b; } public static void main(String[] args) { Calculator obj = new Calculator(); System.out.println("Two integers: " + obj.calculate(10, 20)); System.out.println("Three integers: " + obj.calculate(10, 20, 30)); System.out.println("Two double values: " + obj.calculate(10.5, 20.5)); System.out.println("Two strings: " + obj.calculate("Hello", "Java")); } }

Output

Two integers: 30 Three integers: 60 Two double values: 31.0 Two strings: Hello Java

Summary

Function Overloading allows multiple methods to have the same name but different parameter lists. It improves readability, reduces unnecessary method names, and provides compile-time polymorphism.

Key Points

  • Same method name
  • Different parameters
  • Number, type, or order can differ
  • Return type alone cannot overload a method
  • Constructor overloading is also possible
  • It is an example of compile-time polymorphism
Function Overloading ↓ Same Method Name ↓ Different Parameters ↓ Compile-Time Polymorphism

Keep learning. Keep building. Keep growing.

© 2026 Ugenz Academy