In Kotlin, functions are used to encapsulate a piece of behavior that can be executed multiple times. Functions can accept input parameters, return values, and provide a way to encapsulate complex logic into reusable blocks of code.
What is Functions?
A function is a unit of code that performs a special task. In programming, the function is used to break the code into smaller modules which makes the program more manageable.
We can call sum(x, y) at any number of times and it will return the sum of two numbers. So, the function avoids the repetition of code and makes the code more reusable.
Note: There is a space between closing bracket ')' and opening '{' .
Example of a Function
For example: If we have to compute the sum of two numbers then define a fun sum().
fun sum(a: Int, b: Int): Int {
Int c = a + b
return c
}Parameters in Function
Function parameters are the defined as the elements that are passed to the function for further processing where operations are performed.
In above example, there are two parameters passed mentioned:
- a of Integer type
- b of Integer type
Body of Function
Here in the body we perform the operations to be performed in the function like in the above Example:
val c = a + b
Return Value
Return value is the value which is returned after the operation is performed in the function. In above example c is the value which is returned.
Types of Functions in Kotlin
In Kotlin, there are two types of functions:
- User-defined function
- Standard library function
1. Kotlin User-Defined Function
A function that is defined by the user is called a user-defined function. As we know, to divide a large program into small modules we need to define function. Each defined function has its own properties like the name of the function, return type of a function, number of parameters passed to the function, etc.
-> Creating User-Defined Function
In Kotlin, the function can be declared at the top, and no need to create a class to hold a function, which we are used to doing in other languages such as Java or Scala. Generally, we define a function as:
fun fun_name(a: data_type, b: data_type, ......): return_type { // other codes return }- fun- Keyword to define a function.
- fun_name - Name of the function which later used to call the function.
- a: data_type - Here, a is an argument passed and data_type specify the data type of argument like integer or string.
- return_type - Specify the type of data value return by the function.
- {....} - Curly braces represent the block of function.
Kotlin function mul() to Multiply two Numbers having same type of Parameters:
Kotlin fun mul(num1: Int, num2: Int): Int { var number = num1.times(num2) return number }
Explanation: We have defined a function above starting with fun keyword whose return type is an Integer.
>> mul() is the name of the function >> num1 and num2 are names of the parameters being accepted by the function and both are Integer type.
Kotlin function student() having different types of parameters:
Kotlin fun student(name: String , roll_no: Int , grade: Char) { println("Name of the student is : $name") println("Roll no of the student is: $roll_no") println("Grade of the student is: $grade") }
Explanation: We have defined a function using fun keyword whose return type in Unit by default.
>> student is the name of the function. >> name is the parameter of String data type. >> roll_no is the parameter of Integer data type >> grade is the parameter of Character data type
-> Calling of User-Defined Function
We create a function to assign a specific task. Whenever a function is called the program leaves the current section of code and begins to execute the function.
The flow-control of a function:
- The program comes to the line containing a function call.
- When function is called, control transfers to that function.
- Executes all the instruction of function one by one.
- Control is transferred back only when the function reaches closing braces or there any return statement.
- Any data returned by the function is used in place of the function in the original line of code.
Kotlin program to call the mul() function by passing two arguments:
Kotlin fun mul(a: Int, b: Int): Int { var number = a.times(b) return number } fun main(args: Array<String>) { var result = mul(3,5) println("The multiplication of two numbers is: $result") } Output:
The multiplication of two numbers is: 15
Explanation: In the above program, we are calling the mul(3, 5) function by passing two arguments. When the function is called the control transfers to the mul() and starts execution of the statements in the block. Using in-built times() it calculates the multiple of two numbers and store in a variable number. Then it exits the function with returning the integer value and controls transfer back to the main() where it calls mul(). Then we store the value returned by the function into mutable variable result and println() prints it to the standard output.
Kotlin program to call the student() function by passing all arguments:
Kotlin fun student( name: String , grade: Char , roll_no: Int) { println("Name of the student is : $name") println("Grade of the student is: $grade") println("Roll no of the student is: $roll_no") } fun main(args: Array<String>) { val name = "Praveen" val rollno = 25 val grade = 'A' student(name,grade,rollno) student("Gaurav",'B',30) } Output:
Name of the student is : Praveen Grade of the student is: A Roll no of the student is: 25 Name of the student is : Gaurav Grade of the student is: B Roll no of the student is: 30n
Explanation: In the above program, we are calling the student() function by passing the arguments in the same order as required. If we try to jumble the arguments then it gives the type mismatch error. In the first call, we pass the argument using variables and in the second call, we pass the arguments values without storing in variables. So, both methods are correct to call a function.
2. Kotlin Standard Library Function
In Kotlin, there are different numbers of built-in functions already defined in the standard library and available for use. We can call them by passing arguments according to requirements. In the below program, we will use built-in functions arrayOf(), sum() and println(). The function arrayOf() requires some arguments like integers, double, etc to create an array and we can find the sum of all elements using sum() which does not require any argument.
Below is the implementation of the standard library function:
Kotlin fun main(args: Array<String>) { var sum = arrayOf(1,2,3,4,5,6,7,8,9,10).sum() println("The sum of all the elements of an array is: $sum") } Output:
The sum of all the elements of an array is: 55
In below program, we will use rem() to find the remainder.
Kotlin fun main(args: Array<String>) { var num1 = 26 var num2 = 3 var result = num1.rem(num2) println("The remainder when $num1 is divided by $num2 is: $result") } Output:
The remainder when 26 is divided by 3 is: 2
The list of different standard library functions and their use :
- sqrt() - Used to calculate the square root of a number.
- print() - Used to print a message to standard output.
- rem() - To find the remainder of one number when divided by another.
- toInt() - To convert a number to integer value.
- readline() - Used for standard input.
- compareTo() - To compare two numbers and return boolean value.
Advantages and Disadvantages in Kotlin Function
-> Advantages of Using functions in Kotlin
- Modularity: Functions provide a way to modularize your code and break it down into smaller, more manageable parts. This makes your code more readable, maintainable, and easier to test.
- Reusability: Functions can be called from multiple locations in your code, making it easy to reuse your code and avoid duplication.
- Improved Readability: Functions provide a way to encapsulate complex logic into reusable blocks of code, which can make your code more readable and easier to understand.
- Improved Abstraction: Functions can be used to abstract away complex logic, making it easier to understand what a piece of code does without having to examine its implementation details.
-> Disadvantages of Using functions in Kotlin
- Overhead: Functions can increase the size of your code and increase the amount of memory required to execute it, especially if you have many functions.
- Debugging: Functions can make debugging more difficult if you have complex logic inside your functions, especially if you have multiple functions that call each other.
Similar Reads
Kotlin Tutorial
This Kotlin tutorial is designed for beginners as well as professional, which covers basic and advanced concepts of Kotlin programming language. In this Kotlin tutorial, you'll learn various important Kotlin topics, including data types, control flow, functions, object-oriented programming, collecti
4 min read
Overview
Introduction to Kotlin
Kotlin is a statically typed, general-purpose programming language developed by JetBrains, which has built world-class IDEs like IntelliJ IDEA, PhpStorm, Appcode, etc. It was first introduced by JetBrains in 2011 as a new language for the JVM. Kotlin is an object-oriented language, and a better lang
4 min read
Kotlin Environment setup for Command Line
To set up a Kotlin environment for the command line, you need to do the following steps: Install the Java Development Kit (JDK): Kotlin runs on the Java virtual machine, so you need to have the JDK installed. You can download the latest version from the official Oracle website.Download the Kotlin co
2 min read
Kotlin Environment setup with Intellij IDEA
Kotlin is a statically typed, general-purpose programming language developed by JetBrains that has built world-class IDEs like IntelliJ IDEA, PhpStorm, Appcode, etc. It was first introduced by JetBrains in 2011. Kotlin is object-oriented language and a better language than Java, but still be fully i
2 min read
Hello World program in Kotlin
Hello, World! It is the first basic program in any programming language. Let's write the first program in the Kotlin programming language. The "Hello, World!" program in Kotlin: Open your favorite editor, Notepad or Notepad++, and create a file named firstapp.kt with the following code. // Kotlin He
2 min read
Basics
Kotlin Data Types
The most fundamental data type in Kotlin is the Primitive data type and all others are reference types like array and string. Java needs to use wrappers (java.lang.Integer) for primitive data types to behave like objects but Kotlin already has all data types as objects. There are different data type
3 min read
Kotlin Variables
In Kotlin, every variable should be declared before it's used. Without declaring a variable, an attempt to use the variable gives a syntax error. The declaration of the variable type also decides the kind of data you are allowed to store in the memory location. In case of local variables, the type o
2 min read
Kotlin Operators
Operators are the symbols that operate on values to perform specific mathematical or logical computations on given values. They are the foundation of any programming language. Example: [GFGTABS] Kotlin fun main(args: Array<String>) { var a= 10 + 20 println(a) } [/GFGTABS]Output: 30Explanation:
4 min read
Kotlin Standard Input/Output
In this article, we will discuss how to take input and how to display the output on the screen in Kotlin. Kotlin standard I/O operations are performed to flow a sequence of bytes or byte streams from an input device, such as a Keyboard, to the main memory of the system and from main memory to an out
5 min read
Kotlin Type Conversion
Type conversion (also called as Type casting) refers to changing the entity of one data type variable into another data type. As we know Java supports implicit type conversion from smaller to larger data types. An integer value can be assigned to the long data type. Example: [GFGTABS] Java public cl
2 min read
Kotlin Expression, Statement and Block
Every Kotlin program is made up of parts that either calculate values, called expressions, or carry out actions, known as statements. These parts can be organized into sections called blocks. Table of Content Kotlin ExpressionKotlin StatementKotlin Block Kotlin ExpressionAn expression in Kotlin is m
4 min read
Control Flow
Kotlin if-else expression
Decision Making in programming is similar to decision-making in real life. In programming too, a certain block of code needs to be executed when some condition is fulfilled. A programming language uses control statements to control the flow of execution of a program based on certain conditions. If t
4 min read
Kotlin while loop
In programming, loop is used to execute a specific block of code repeatedly until certain condition is met. If you have to print counting from 1 to 100 then you have to write the print statement 100 times. But with help of loop you can save time and you need to write only two lines. While loopIt con
2 min read
Kotlin do-while loop
Like Java, do-while loop is a control flow statement which executes a block of code at least once without checking the condition, and then repeatedly executes the block, or not, it totally depends upon a Boolean condition at the end of do-while block. It contrast with the while loop because while lo
2 min read
Kotlin for loop
In Kotlin, for loop is equivalent to foreach loop of other languages like C#. Here for loop is used to traverse through any data structure which provides an iterator. It is used very differently then the for loop of other programming languages like Java or C. The syntax of for loop in Kotlin: for(it
4 min read
Kotlin when expression
In Kotlin, when replaces the switch operator of other languages like Java. A certain block of code needs to be executed when some condition is fulfilled. The argument of when expression compares with all the branches one by one until some match is found. After the first match is found, it reaches to
6 min read
Kotlin Unlabelled break
When we are working with loops and want to stop the execution of loop immediately if a certain condition is satisfied, in this case, we can use either break or return expression to exit from the loop. In this article, we will discuss learn how to use break expression to exit a loop. When break expre
4 min read
Kotlin labelled continue
In this article, we will learn how to use continue in Kotlin. While working with a loop in the programming, sometimes, it is desirable to skip the current iteration of the loop. In that case, we can use the continue statement in the program. Basically, continue is used to repeat the loop for a speci
4 min read
Functions
Kotlin functions
In Kotlin, functions are used to encapsulate a piece of behavior that can be executed multiple times. Functions can accept input parameters, return values, and provide a way to encapsulate complex logic into reusable blocks of code. Learn Kotlin Functions What is Functions?Example of a FunctionType
8 min read
Kotlin | Default and Named argument
In most programming languages, we need to specify all the arguments that a function accepts while calling that function but in Kotlin, we need not specify all the arguments that a function accepts while calling that function so it is one of the most important features. We can get rid of this constra
7 min read
Kotlin Recursion
In this tutorial, we will learn Kotlin Recursive function. Like other programming languages, we can use recursion in Kotlin. A function that calls itself is called a recursive function and this process of repetition is called recursion. Whenever a function is called then there are two possibilities:
3 min read
Kotlin Tail Recursion
In traditional recursion call, we perform our recursive call first, and then we take the return value of the recursive call and calculate the result. But in tail recursion, we perform the calculation first, and then we execute the recursive call, passing the results of the current step to the next r
2 min read
Kotlin | Lambdas Expressions and Anonymous Functions
In this article, we are going to learn lambdas expression and anonymous function in Kotlin. While syntactically similar, Kotlin and Java lambdas have very different features. Lambdas expression and Anonymous function both are function literals means these functions are not declared but passed immedi
6 min read
Kotlin Inline Functions
In Kotlin, the higher-order functions or lambda expressions, all stored as an object so memory allocation, for both function objects and classes, and virtual calls might introduce runtime overhead. Sometimes we can eliminate the memory overhead by inlining the lambda expression. In order to reduce t
5 min read
Kotlin infix function notation
In this article, we will learn infix notation used in Kotlin functions. In Kotlin, a functions marked with infix keyword can also be called using infix notation means calling without using parenthesis and dot. There are two types of infix function notation in Kotlin-  Standard library infix functio
5 min read
Kotlin Higher-Order Functions
Kotlin language has superb support for functional programming. Kotlin functions can be stored in variables and data structures, passed as arguments to and returned from other higher-order functions. Higher-Order Function - In Kotlin, a function which can accept a function as parameter or can return
6 min read
Collections
Kotlin Collections
In Kotlin, collections are used to store and manipulate groups of objects or data. There are several types of collections available in Kotlin, including: Lists - Ordered collections of elements that allow duplicates.Sets - Unordered collections of unique elements.Maps - Collections of key-value pair
6 min read
Kotlin list : Arraylist
ArrayList class is used to create a dynamic array in Kotlin. Dynamic array states that we can increase or decrease the size of an array as pre requisites. It also provide read and write functionalities. ArrayList may contain duplicates and is non-synchronized in nature. We use ArrayList to access th
6 min read
Kotlin list : listOf()
In Kotlin, listOf() is a function that is used to create an immutable list of elements. The listOf() function takes a variable number of arguments and returns a new list containing those arguments. Here's an example: [GFGTABS] Kotlin val numbers = listOf(1, 2, 3, 4, 5) [/GFGTABS] In this example, we
8 min read
Kotlin Set : setOf()
Kotlin Set interface is a generic unordered collection of elements and it does not contain duplicate elements. Kotlin supports two types of sets mutable and immutable. setOf() is immutable means it supports only read-only functionalities and mutableSetOf() is mutable means it supports read and write
5 min read
Kotlin hashSetOf()
Kotlin HashSet is a generic unordered collection of elements and it does not contain duplicate elements. It implements the set interface. hashSetOf() is a function that returns a mutable hashSet, which can be both read and written. The HashSet class store all the elements using the hashing mechanism
5 min read
Kotlin Map : mapOf()
Kotlin map is a collection that contains pairs of objects. Map holds the data in the form of pairs which consists of a key and a value. Map keys are unique and the map holds only one value for each key. Kotlin distinguishes between immutable and mutable maps. Immutable maps created with mapOf() mea
6 min read
Kotlin Hashmap
Kotlin HashMap is a collection which contains pairs of object. Kotlin Hash Table based implementation of the MutableMap interface. It stores the data in the form of key and value pair. Map keys are unique and the map holds only one value for each key. It is represented as HashMap<key, value> o
7 min read
OOPs Concept
Kotlin Class and Objects
In Kotlin, classes and objects are used to represent objects in the real world. A class is a blueprint for creating objects (a particular data structure), providing initial values for state (member variables or fields), and implementations of behavior (member functions or methods). An object is an i
4 min read
Kotlin Nested class and Inner class
Nested Class In Kotlin, you can define a class inside another class, which is known as a nested class. Nested classes have access to the members (fields and methods) of the outer class. Here is an example of a nested class in Kotlin: [GFGTABS] Kotlin class Car { var make: String var model: String va
5 min read
Kotlin Setters and Getters
Properties are an important part of any programming language. In Kotlin, we can define properties in the same way as we declare another variable. Kotlin properties can be declared either as mutable using the var keyword or as immutable using the val keyword. Syntax of Property var <propertyName
5 min read
Kotlin | Class Properties and Custom Accessors
The basic and most important idea of a class is Encapsulation. It is a property to encapsulate code and data, into a single entity. In Java, the data are stored in the fields and these are mostly private. So, accessor methods - a getter and a setter are provided to let the clients of the given class
2 min read
Kotlin Constructor
A constructor is a special member function that is invoked when an object of the class is created primarily to initialize variables or properties. A class needs to have a constructor and if we do not declare a constructor, then the compiler generates a default constructor. Kotlin has two types of co
7 min read
Kotlin Visibility Modifiers
In Kotlin, visibility modifiers are used to control the visibility of a class, its members (properties, functions, and nested classes), and its constructors. The following are the visibility modifiers available in Kotlin: private: The private modifier restricts the visibility of a member to the cont
6 min read
Kotlin Inheritance
Kotlin supports inheritance, which allows you to define a new class based on an existing class. The existing class is known as the superclass or base class, and the new class is known as the subclass or derived class. The subclass inherits all the properties and functions of the superclass, and can
10 min read
Kotlin Interfaces
In Kotlin, an interface is a collection of abstract methods and properties that define a common contract for classes that implement the interface. An interface is similar to an abstract class, but it can be implemented by multiple classes, and it cannot have state. Interfaces are custom types provid
7 min read
Kotlin Data Classes
We often create classes to hold some data in it. In such classes, some standard functions are often derivable from the data. In Kotlin, this type of class is known as data class and is marked as data. Example of a data : data class Student(val name: String, val roll_no: Int) The compiler automatical
4 min read
Kotlin Sealed Classes
Kotlin introduces a powerful concept that doesn't exist in Java: sealed classes. In Kotlin, sealed classes are used when you know in advance that a value can only have one of a limited set of types. They let you create a restricted class hierarchy, meaning all the possible subclasses are known at co
4 min read
Kotlin Abstract class
In Kotlin, an abstract class is a class that cannot be instantiated and is meant to be subclassed. An abstract class may contain both abstract methods (methods without a body) and concrete methods (methods with a body). An abstract class is used to provide a common interface and implementation for i
6 min read
Enum Classes in Kotlin
In programming, sometimes there arises a need for a type to have only certain values. To accomplish this, the concept of enumeration was introduced. Enumeration is a named list of constants. In Kotlin, like many other programming languages, an enum has its own specialized type, indicating that somet
5 min read
Kotlin extension function
Kotlin gives the programmer the ability to add more functionality to the existing classes, without inheriting them. This is achieved through a feature known as extensions. When a function is added to an existing class it is known as Extension Function. To add an extension function to a class, define
5 min read
Kotlin generics
Generics are the powerful features that allow us to define classes, methods and properties which are accessible using different data types while keeping a check on the compile-time type safety. Creating parameterized classes - A generic type is a class or method that is parameterized over types. We
6 min read