❮❮ PREV NEXT ❯❯

KOTLIN - FUNCTION

A Function in Kotlin is a chunk of Code that is used to conduct a particular task. And that chunk is only executed when it is called.

Say if you want to add two numbers, you can have an add Function that would be dedicated to add the numbers.

Similarly, if you want to divide two numbers, you can have a divide Function that would divide the numbers.

So, instead of placing all the codes in a single place. You can distribute the work among different Functions. So, that your code looks more structured and clean.

How a Function in Kotlin is created?

Below are the rules to create a Function :

A Function should begin with a fun keyword - (i.e. fun).

Following the fun keyword, a Function should have a name - (i.e. fun myfunction).

And the name of the function should have a starting and ending bracket () - (i.e. fun myfunction()).

There can be(Or cannot be) something called as Arguments inside the bracket () - (i.e. fun myfunction(myarg: Int)).

After the bracket () there could be a return type, which means, we might have to specify the data type of the value we want to return. And if no value is returned, then we there is no need of specifying any data types - (i.e. fun myfunction(myarg: Int)): Int.

As said, a Function is a chunk of Code used to conduct a task. And the block of code should be inside starting brace { and an ending brace }.
```
fun myfunction() {
	println("This is my first function")
}
```

And thats how we define a Function.

But it was mentioned in the Function description that a Function only executes only when it is called.

So, how a Function is called?

Let us see in the below example.

Note : Let us omit the argument and return type for now.

Example :

fun main() {

	myfunction();			 	
}

fun myfunction() {
   	println("This is my first function");
}

Output :

This is my first function

So, in the above code, there are two parts,

The Function definition.

fun myfunction() {
	println("This is my first function")
}

And the Function, call, inside the main() Function.
```
myfunction()
```

So, in the above code we have defined a Function, myfunction(). You can give any name to the Function(In this case we have given the name myfunction()). Just don't forget to write the fun keyword before it.

fun myfunction() {
	println("This is my first function")
}

And the work of the Function, myfunction() is, just to print This is my first function.

Now, just remember one thing, the above Function, myfunction() will never execute until it is called.

And thus we have called the Function, myfunction() from main().

fun main() {
	myfunction();
}

And the Function, myfunction() is called, printing,

This is my first function

Now, let us look at another example of adding two numbers and returning the result using Functions.

Example :

fun main() {

	var firstNum: Int = 5
	var secondNum: Int = 4   	
	var value: Int = add(firstNum, secondNum)
	println("The added result is : "+value)			 	
}

fun add(firstNumber: Int, secondNumber: Int): Int {
   	var result: Int = firstNumber + secondNumber
   	return result	
}

Output :

The added result is : 9

Let us explain the above example with a practical scenario.

Say you are given a task of adding two numbers. And you would follow the below steps to achieve it :

You would ask the firstNumber and secondNumber from the person who has given you this task.

And the above Kotlin Function expects the same thing.
```
fun add(firstNumber: Int, secondNumber: Int): Int {
```
Here, firstNumber and secondNumber are the two numbers which a Kotlin Function expects just like you.

Note : firstNumber and secondNumber are called as arguments that we will be learning in a separate tutorial.

And add is the name of the Function. And just like the above example we have used the fun keyword to define a Function.

In addition to that, there is something called as the return type(i.e. Int). Which we will be explaining soon.

The next thing you would do is, add the numbers and give the added value to the caller.

Same thing is done by the Above Function.

It adds firstNumber and secondNumber and stores the added value in a variable called result.
```
var result: Int = firstNumber + secondNumber
```
It then returns the result to the caller(We will see next, who is a caller).
```
return result
```
And since the returned value result is of type Int. We have specified Int in the returned type.

So far, we have seen how a Function works. Now, let us see who is the caller?

When the program execution begins,

And we initialise the first variable firstNum with the value 5.

var firstNum: Int = 5

Then in the next line, we have initialised the second variable secondNum with the value 4.

var secondNum: Int = 4

Then we call the add(firstNum: Int, secondNum: Int) Function.

var value: Int = add(firstNum, secondNum)

And Kotlin searches for a Function with two arguments.

When it finds the Function, it assigns the value of firstNum to firstNumber and secondNum to secondNumber. And expects a value in return.

And gets into the block of the def add(firstNumber, secondNumber): Function.

This is where the numbers are added,

var result: Int = firstNumber + secondNumber

And the result is stored in a variable result.

And in the next line we return the added value(i.e. result).

return result

And the returned value goes back to the line, where the Function was called.

var value: Int = add(firstNum, secondNum)

And the variable value gets the added result(i.e. 9) from the variable result.

And in the next line the added value is printed as output.

println("The added result is : "+value)

❮❮ PREV NEXT ❯❯