Kotlin Function Overloading: Things to Know

Photo of author

Programming languages use a technique called function overloading that enables the definition of a single function with several implementations.

Kotlin permits the description of numerous functions with the same name but distinct parameters and return types. This makes constructing functions with different functionalities simple while maintaining a short and understandable code.

In every programming language, function overloading is a robust tool that, when utilized correctly, may be pretty effective. Keeping projects organized and reducing code duplication makes code simpler to understand and maintain. In this article, we will learn about kotlin function overloading.

Benefits of Kotlin Function Overloading

Let’s discuss all the benefits of Kotlin function overloading in detail:


By enabling programmers to utilize a single function name for a group of logically linked activities, function overloading enhances the readability of code.


Reusability of Code

Function overloading avoids the requirement to write distinct functions with distinct names for equivalent actions.

Reusability of Code

Alternatively, you may repurpose the same function name and offer many parameter changes depending on the needs.

See Also: What Is Class In C: Exploring Object-Oriented Features In C


Kotlin Function overloading offers flexibility in handling diverse circumstances, allowing for numerous argument combinations.


According to the particular use case, developers may select the appropriate overloaded function, leading to shorter, more adaptable code.

Functions in Kotlin

A chunk of code called a function is explicitly created for a given purpose. All contemporary programming languages currently support functions, often called methods or subroutines.

Functions in Kotlin

In its most basic form, a function accepts input, known as parameters, processes this information by performing specific operations, and then returns a value.

Visit: Function in Kotlin

Kotlin Built-in Functions

Many built-in functions are available in Kotlin; we have utilized a few in our examples. For instance, the most often used built-in functions we operate to print output to the screen are print() and println().


fun main(args: Array) {

println(“Hello, World!”)


User-Defined Functions

Using the term fun, Kotlin enables us to define our functions. A user-defined function accepts one or more inputs, executes a command, and then returns the command’s outcome as a value.


fun functionName(){

// body of function


Once a function has been defined, it can be used as often as necessary. The syntax for calling a Kotlin function is as follows:



The following example shows how to create and utilize a user-defined function that prints a straightforward “Hello, World!”

fun main(args: Array) {




fun printHello(){

println(“Hello, World!”)


Kotlin Function Overloading

Function overloading, sometimes called method overloading, is the capacity to create several functions with the same name but different implementations.

Program for method overloading in Kotlin

package com.include help

//Declare class

class Operation{

//Member function with two Int type Argument

fun sum(a:Int, b:Int){

println(“Sum($a,$b) = ${a+b}”)


//Overloaded Member function

//with three Int type Argument

fun sum(a:Int, b:Int,c:Int){

println(“Sum($a,$b,$c) = ${a+b+c}”)


//Overloaded Member function with

//four Int type Argument

fun sum(a:Int, b:Int,c:Int,d:Int){

println(“Sum($a,$b,$c,$d) = ${a+b+c+d}”)



//Main function, entry Point of Program

fun main(args:Array){

//Create Instance of Operation class

Val operation = Operation()

//Called function with two arguments


//Called function with three arguments


//Called function with four arguments




Sum(10,20) = 30

Sum(2,3,5) = 10

Sum(5,8,2,12) = 27

Kotlin Constructor Overloading

The most straightforward approach to initialize class properties is through the constructor.

It is a unique member function that is called at the creation of an object. However, they operate a little differently in Kotlin.

There are two constructors in Kotlin:

  • A simple approach to initialize a class using the primary constructor
  • Additional initialization logic may be added using the secondary constructor.

Constructor Overloading

A Kotlin class contains one or more secondary constructors besides the primary constructor. Constructor overloading refers to the situation when a class has many constructors.

See Also: Kotlin Tutorial: Add New Element To Array

Program for constructor overloading in Kotlin

package com.include help

//declare Class with Parameterized primary constructor

class ConstructorOverloading(len:Int){

//Init block, executed when class is instantiated,

//before secondary constructor body execution

init {

println(“Init Block : $len”)


//Secondary Constructor,

//delegate primary constructor with ‘this’ keyword

constructor() : this(10) {

println(“Secondary Constructor No Parameter”)


//Parameterized Secondary Constructor,

//delegate primary constructor with ‘this’ keyword


println(“Secondary Constructor with One Parameter : $name”)


//Parameterized Secondary Constructor with two parameter,

//call same class non Parameterized secondary constructor

//using ‘this()’

constructor(a:Int, b:Int) : this() {

println(“Secondary Constructor With Two Parameter [$a, $b]”)



//Main Function, Entry Point of Program

fun main(args:Array){

//Create instance of class , with Primary Constructor


//Create instance of class,

//with no argument secondary constructor


//Create instance of class,

//with one argument secondary constructor


//Create instance of class,

//with two argument secondary constructor




Init Block : 100

Init Block : 10

Secondary Constructor No Parameter

Init Block : 5

Secondary Constructor with One Parameter : India

Init Block : 10

Secondary Constructor No Parameter

Secondary Constructor With Two Parameter [10, 20]

See Also: Handling Optional Path Parameters With React Router


What is Kotlin function overloading?

In Kotlin, the ability to specify numerous functions with the same name but distinct argument lists within the same class or object is referred to as function overloading. Different numbers or types of parameters are required for these functions.

What distinguishes function overloading from function overriding?

Function overloading is the definition of numerous functions with the same name but distinct argument lists in the same class or object. Contrarily, function overriding is a notion connected to inheritance in which a subclass offers a particular implementation for a function that is already defined in its superclass.

What does function overloading serve as?

By providing several methods to call a function with various sets of parameters thanks to function overloading, you may provide developers who use your code additional flexibility and convenience. It is frequently employed to write functions with default parameters or to deal with various data formats

In Kotlin, is it possible to overload functions based on the return type?

No, Kotlin does not allow overloading of functions based simply on their return type. The name of the function and its parameter list, not the return type, decide if it is overloading.

Do I have the option of having two overloaded functions with distinct names but the same parameter types?

Contrary to popular belief, function overloading refers to the practise of calling the same function with distinct argument lists. They are merely different functions if you modify the names of the functions, they are not regarded as overloaded.


Important considerations before employing function overloading: Make sure the functions have unique arguments despite sharing the same name. Inspect the functions to ensure they are in the same class or namespace.

When designing overloaded functions, consider the parameters’ type and order. Avoid using confusing function overloads since they may cause compiler issues. Recognize that function overloading is handled according to the arguments used at compilation time.

In summary, Kotlin’s function overloading feature allows programmers to construct numerous functions with the same name but distinct parameter lists, enhancing the code’s readability, reuse, and flexibility.

See Also: Generic Array In Java: Best Practices And Techniques

Leave a Comment