Using Functions, Parameters, and Return Values in Kotlin

Course: Android App Development

Topic: Using Functions, Parameters, and Return Values

Course Link: Android App Development Course

Demo Link: Register for Course Demo

Website: JustAcademy

1. Introduction to Functions in Kotlin

Functions are fundamental building blocks of Kotlin programming. A function is a reusable block of code designed to perform a specific task. Instead of writing the same code repeatedly, developers can define a function once and call it whenever required.

In Android app development, functions are used for validating user input, calculating prices, processing data, handling button clicks, communicating with APIs, updating application state, and managing business logic.

Kotlin functions are declared using the fun keyword. A function can accept input values through parameters, execute statements, and return a result to the code that called it.

Example

fun greetUser() {
    println("Welcome to Android Development!")
}

fun main() {
    greetUser()
}

Output:

Welcome to Android Development!

In this example, greetUser() is a function that prints a welcome message. The function is executed when it is called inside main().

2. Learning Objectives

After completing this topic, learners should be able to:

• Understand the purpose and advantages of functions.
• Define and call functions using Kotlin syntax.
• Work with parameters and arguments.
• Specify return types and return values.
• Understand single-expression functions.
• Use default and named arguments.
• Understand function overloading and local variables.
• Work with nullable return values.
• Understand extension and higher-order functions.
• Apply functions to practical Android application features.
• Write reusable, testable, and maintainable Kotlin code.

3. What Is a Function?

A function is a named or anonymous unit of code that performs an operation. Functions help divide a large program into smaller, manageable parts.

For example, an Android shopping application might contain separate functions for calculating the cart total, applying a discount, validating a coupon, and displaying the checkout summary.

3.1 Basic Function Syntax

fun functionName() {
    // Statements to execute
}

The main components are:

3.2 Creating and Calling a Function

fun displayMessage() {
    println("Learning Kotlin Functions")
}

fun main() {
    displayMessage()
    displayMessage()
}

Output:

Learning Kotlin Functions
Learning Kotlin Functions

The same function is called twice, demonstrating how reusable functions reduce duplicated code.

4. Types of Functions in Kotlin

Kotlin supports several ways to define functions depending on their parameters, return values, and intended use.

5. Functions Without Parameters

A function without parameters performs an operation without receiving input from its caller. It is useful for tasks that use fixed values or do not require external data.

Example

fun showAppInfo() {
    println("Application: Student Manager")
    println("Version: 1.0")
}

fun main() {
    showAppInfo()
}

This function displays application information. Each time showAppInfo() is called, the statements inside the function execute.

Practical Uses

• Displaying a welcome message.
• Printing application information.
• Executing a reusable formatting operation.
• Running a simple calculation that uses fixed values.

6. Functions with Parameters

Parameters allow a function to receive information from the calling code. This makes a function flexible because it can work with different values without changing its implementation.

6.1 Defining Parameters

fun greetUser(name: String) {
    println("Hello, $name!")
}

fun main() {
    greetUser("Aarav")
    greetUser("Priya")
}

Output:

Hello, Aarav!
Hello, Priya!

The function accepts a parameter named name of type String. The caller supplies different values when invoking the function.

6.2 Multiple Parameters

A function can accept multiple parameters separated by commas. Each parameter has a name and a declared type.

fun displayStudent(name: String, age: Int) {
    println("Student Name: $name")
    println("Student Age: $age")
}

fun main() {
    displayStudent("Rohan", 21)
}

The function receives a String and an Int, then displays both values.

6.3 Parameters with Different Data Types

fun displayProduct(
    name: String,
    price: Double,
    inStock: Boolean
) {
    println("Product: $name")
    println("Price: $price")
    println("Available: $inStock")
}

fun main() {
    displayProduct("Keyboard", 1499.50, true)
}

This example combines String, Double, and Boolean parameters to represent product information.

7. Parameters and Arguments: Understanding the Difference

Parameters and arguments are related concepts, but they have different meanings.

• Parameter: A variable declared in the function definition that receives an input value.
• Argument: The actual value or expression supplied when the function is called.

Example

fun calculateSquare(number: Int) {
    println(number * number)
}

fun main() {
    calculateSquare(5)
}

In this example, number is the parameter, while 5 is the argument passed to the function.

8. Understanding Return Values

A return value is the result produced by a function and sent back to the code that called it. Return values allow functions to perform calculations and provide results for further processing.

In Kotlin, the return keyword is used to return a value explicitly from a function.

8.1 Function with a Return Value

fun addNumbers(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    val result = addNumbers(10, 20)
    println("Sum: $result")
}

Output:

Sum: 30

The function accepts two Int values, calculates their sum, and returns an Int. The returned value is stored in the variable result.

8.2 Understanding the Return Type

The return type appears after a colon following the parameter list.

fun multiply(a: Int, b: Int): Int {
    return a * b
}

Here, : Int specifies that the function returns an integer. The returned expression must be compatible with the declared return type.

8.3 Functions Returning String

fun getWelcomeMessage(name: String): String {
    return "Welcome, $name!"
}

fun main() {
    val message = getWelcomeMessage("Ananya")
    println(message)
}

The function returns a String that can be displayed, stored, or passed to another function.

8.4 Functions Returning Boolean

fun isEligible(age: Int): Boolean {
    return age >= 18
}

fun main() {
    val eligible = isEligible(22)
    println(eligible)
}

The function returns true when the age is at least 18 and false otherwise. In a real application, eligibility rules should reflect the applicable requirements.

9. Functions Without an Explicit Return Value

A function that performs an action without returning a meaningful result can use Kotlin's Unit return type. For block-bodied functions, Kotlin infers Unit when no return type is specified and no value is returned.

Example

fun showNotification() {
    println("Your profile has been updated")
}

This function performs an action but does not return a value that can be assigned to a variable as its result.

An explicit Unit return type can also be used:

fun printMessage(): Unit {
    println("Hello from Kotlin")
}

Unit is similar in purpose to void in Java, although it is represented as a Kotlin type.

10. Returning Multiple Pieces of Information

A Kotlin function has one declared return type, but that type can represent multiple values. Common approaches include returning a data class, Pair, or Triple.

10.1 Returning a Pair

fun getUserInfo(): Pair<String, Int> {
    return Pair("Rahul", 25)
}

fun main() {
    val userInfo = getUserInfo()

    println(userInfo.first)
    println(userInfo.second)
}

The Pair contains a String and an Int. Its first and second properties provide access to the two values.

10.2 Returning a Data Class

For structured application data, a data class often communicates the meaning of each value more clearly than a Pair.

data class Student(
    val name: String,
    val age: Int,
    val grade: String
)

fun getStudent(): Student {
    return Student("Priya", 20, "A")
}

fun main() {
    val student = getStudent()

    println(student.name)
    println(student.age)
    println(student.grade)
}

This approach is useful in Android applications for representing users, products, API responses, and other structured information.

11. Single-Expression Functions

A single-expression function contains one expression whose result becomes the function's return value. Kotlin allows the return type to be inferred when appropriate.

Example

fun square(number: Int) = number * number

fun add(a: Int, b: Int) = a + b

fun greet(name: String) = "Hello, $name!"

fun main() {
    println(square(5))
    println(add(10, 15))
    println(greet("Karan"))
}

The compiler infers Int as the return type of square() and add(), and String as the return type of greet().

Advantages

• Reduces unnecessary syntax.
• Makes simple calculations easier to read.
• Supports concise utility functions.
• Helps express transformations clearly.

Use block-bodied functions when the logic requires several statements, detailed branching, or additional clarity.

12. Default Parameters

Kotlin allows developers to assign default values to function parameters. If the caller omits an argument, the default value is used.

Example

fun greetUser(name: String, message: String = "Welcome") {
    println("$message, $name!")
}

fun main() {
    greetUser("Aarav")
    greetUser("Priya", "Good morning")
}

Output:

Welcome, Aarav!
Good morning, Priya!

Default parameters reduce the need to create multiple functions for similar operations.

Practical Example: Product Discount

fun calculateDiscount(
    price: Double,
    discountRate: Double = 10.0
): Double {
    return price * discountRate / 100
}

fun main() {
    println(calculateDiscount(1000.0))
    println(calculateDiscount(1000.0, 20.0))
}

The first call uses the default discount rate of 10%, while the second call supplies a rate of 20%.

13. Named Arguments

Named arguments allow callers to specify parameter names when passing values. They improve readability, especially when a function has multiple parameters of the same type.

Example

fun createProfile(
    name: String,
    age: Int,
    city: String
) {
    println("$name is $age years old and lives in $city")
}

fun main() {
    createProfile(
        city = "Mumbai",
        name = "Neha",
        age = 24
    )
}

Named arguments make it clear which value belongs to each parameter. Kotlin supports named arguments for Kotlin functions, but Java method calls generally do not support Kotlin-style named-argument syntax.

Benefits of Named Arguments

• Improve the readability of function calls.
• Reduce confusion when several parameters share the same data type.
• Allow arguments to be supplied in a different order when named explicitly.
• Work well with default parameter values.

14. Function Overloading

Function overloading means declaring multiple functions with the same name but different parameter lists. The compiler selects the appropriate overload based on the arguments and the available type information.

Example

fun add(a: Int, b: Int): Int {
    return a + b
}

fun add(a: Double, b: Double): Double {
    return a + b
}

fun add(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

fun main() {
    println(add(10, 20))
    println(add(2.5, 3.5))
    println(add(1, 2, 3))
}

These functions share the name add, but their parameter types or counts differ.

Important Rules

• Overloaded functions must have distinguishable parameter signatures.
• Changing only the return type is not sufficient to create a valid overload.
• Ambiguous overloads can cause compilation errors.
• Overloading can make APIs easier to use when related operations need different input forms.

15. Local Variables and Scope in Functions

Scope defines where a variable or function can be accessed. A local variable declared inside a function is generally available only within its enclosing scope.

Example

fun calculateTotal() {
    val price = 500
    val quantity = 3
    val total = price * quantity

    println(total)
}

fun main() {
    calculateTotal()
}

The variables price, quantity, and total are local to calculateTotal(). They cannot be directly accessed from main().

Why Scope Matters

• Prevents unnecessary exposure of internal variables.
• Reduces naming conflicts.
• Makes functions easier to understand and maintain.
• Encourages modular program design.

16. Returning Nullable Values

A function can return a nullable type when a result may be unavailable. The question mark after a type indicates that the return value can be null.

Example

fun findUserName(userId: Int): String? {
    return if (userId == 1) {
        "Aarav"
    } else {
        null
    }
}

fun main() {
    val userName = findUserName(2)

    println(userName ?: "User not found")
}

The function returns a username for the matching ID and null otherwise. The caller uses the Elvis operator to provide a fallback message.

Safe Handling of Nullable Results

fun getEmail(): String? {
    return null
}

fun main() {
    val email = getEmail()

    if (email != null) {
        println(email.length)
    } else {
        println("Email is not available")
    }
}

Nullable return types are helpful when retrieving optional data from databases, API responses, or user profiles.

17. Extension Functions

An extension function allows developers to call a new function using the syntax of an existing type without modifying that type's original source code.

Example

fun String.firstCharacter(): Char? {
    return this.firstOrNull()
}

fun main() {
    val name = "Android"

    println(name.firstCharacter())
}

The extension receiver is String, represented by the keyword this inside the extension function. The function returns the first character or null if the string is empty.

Practical Example: Formatting a Name

fun String.toDisplayName(): String {
    return trim().replaceFirstChar {
        if (it.isLowerCase()) it.titlecase() else it.toString()
    }
}

fun main() {
    println("  rahul".toDisplayName())
}

This example trims leading and trailing whitespace and capitalizes the first character when it is lowercase. More comprehensive name formatting may require additional rules for multiple words and different languages.

18. Higher-Order Functions and Lambda Parameters

A higher-order function accepts another function as a parameter or returns a function. Kotlin supports lambdas, which provide a concise way to represent function values.

18.1 Function as a Parameter

fun performOperation(
    a: Int,
    b: Int,
    operation: (Int, Int) -> Int
): Int {
    return operation(a, b)
}

fun main() {
    val sum = performOperation(10, 20) { x, y ->
        x + y
    }

    val product = performOperation(10, 20) { x, y ->
        x * y
    }

    println(sum)
    println(product)
}

The parameter operation represents a function that receives two Int values and returns an Int. Different lambdas can be supplied to perform different calculations.

18.2 Using Lambdas with Collections

fun main() {
    val prices = listOf(100, 250, 400, 550)

    val discountedPrices = prices.map { price ->
        price * 0.9
    }

    println(discountedPrices)
}

The map function accepts a lambda and applies it to every price, returning a new list of transformed values.

18.3 Benefits of Higher-Order Functions

• Encourage reusable and flexible logic.
• Reduce repeated code.
• Support concise collection processing.
• Help separate what an operation does from how it is executed.
• Provide a foundation for callbacks and many Kotlin APIs.

19. Recursive Functions

A recursive function calls itself to solve a problem by reducing it into smaller subproblems. A recursive function needs a base case to stop further calls.

Example: Factorial

fun factorial(number: Int): Long {
    require(number >= 0) {
        "Number must be non-negative"
    }

    require(number <= 20) {
        "Number is too large for this example"
    }

    return if (number <= 1) {
        1L
    } else {
        number.toLong() * factorial(number - 1)
    }
}

fun main() {
    println(factorial(5))
}

Output: 120.

The base case returns 1 when the number is 0 or 1. Otherwise, the function calls itself with a smaller number. The input limit avoids overflow of the Long result for this implementation.

Important Considerations

• Always define a valid base case.
• Ensure recursive calls move toward the base case.
• Be aware that deep recursion can cause a stack overflow.
• Consider iteration or Kotlin's tailrec support when appropriate.

20. Functions in Android Application Development

Functions help separate UI code, calculations, validation, and application logic. A well-designed function usually performs one clearly defined responsibility.

20.1 Input Validation

fun isValidPassword(password: String): Boolean {
    return password.length >= 8
}

fun main() {
    println(isValidPassword("android123"))
    println(isValidPassword("abc"))
}

This is a basic length check for demonstration. Real password validation and authentication require stronger security practices and should not rely on length alone.

20.2 Calculating a Cart Total

fun calculateCartTotal(
    prices: List
): Double {
    var total = 0.0

    for (price in prices) {
        total += price
    }

    return total
}

fun main() {
    val prices = listOf(100.0, 250.0, 350.0)

    println(calculateCartTotal(prices))
}

The function accepts a list of prices and returns their total. Production financial software should use an appropriate monetary representation rather than relying on binary floating-point arithmetic for exact decimal values.

20.3 Handling a Button Click

In an Android application using traditional Views, a function can be called from a button click listener.

fun getWelcomeMessage(name: String): String {
    return "Welcome, $name!"
}

// Example inside an initialized Activity:
button.setOnClickListener {
    val message = getWelcomeMessage("Aarav")
    textView.text = message
}

The listener calls the function and uses its returned String to update the TextView. This example assumes that button and textView are valid, initialized views in the Activity.

20.4 Functions with Jetpack Compose

Jetpack Compose uses Kotlin functions annotated with @Composable to describe UI elements. Ordinary Kotlin functions can prepare values that are then passed to composables.

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable

fun formatGreeting(name: String): String {
    return "Hello, $name!"
}

@Composable
fun GreetingScreen() {
    val greeting = formatGreeting("Priya")
    Text(text = greeting)
}

The ordinary function formats the message, and the composable displays it. This separation helps keep formatting logic reusable and testable.

20.5 Separating Business Logic from UI Logic

Instead of placing all calculations inside a button listener or composable, create dedicated functions for business rules. This makes code easier to test and maintain.

fun calculateFinalPrice(
    price: Double,
    discountPercentage: Double
): Double {
    require(price >= 0)
    require(discountPercentage in 0.0..100.0)

    return price - (price * discountPercentage / 100)
}

fun main() {
    val finalPrice = calculateFinalPrice(1000.0, 15.0)
    println(finalPrice)
}

The function validates its inputs and returns the discounted price. A production application should also handle invalid input appropriately at the UI or domain boundary.

21. Common Mistakes and Troubleshooting

Example: Correcting a Return Type Error

Incorrect code:

// Compilation error
fun getAge(): Int {
    return "Twenty"
}

Correct code:

fun getAge(): Int {
    return 20
}

The function declares an Int return type, so it must return a compatible integer value.

22. Best Practices for Writing Kotlin Functions

• Give each function one clear responsibility.
• Use meaningful names such as calculateTotal() and validateEmail().
• Choose parameter types that clearly express the required inputs.
• Specify return types when they improve readability or public API clarity.
• Use single-expression functions for simple operations.
• Use default arguments to avoid unnecessary overloads.
• Use named arguments when they improve the readability of function calls.
• Validate inputs when the function has specific requirements.
• Return nullable types when a result may genuinely be absent.
• Avoid excessive numbers of parameters; consider a data class for related values.
• Prefer pure functions for calculations when practical. A pure function returns the same result for the same inputs and has no observable side effects.
• Keep UI operations separate from reusable business logic.
• Write unit tests for important calculations and validation rules.
• Avoid deeply recursive implementations for large inputs unless the approach is suitable.
• Use higher-order functions when they improve clarity, not merely to shorten code.

23. Practical Exercises

Exercise 1: Greeting Function

Create a function named greetUser() that accepts a name and prints a personalized welcome message.

Exercise 2: Addition Function

Write a function that accepts two integers and returns their sum. Call the function with at least three different sets of values.

Exercise 3: Area Calculator

Create separate functions to calculate the area of a rectangle and a circle. Choose suitable numeric parameter and return types.

Exercise 4: Default Parameters

Write a function that displays a user's name and city. Provide a default city and test the function with and without a custom city.

Exercise 5: Named Arguments

Create a function for registering a student with name, age, and course parameters. Call it using named arguments in a different order.

Exercise 6: Nullable Return Value

Write a function that searches for a product ID and returns the product name when found or null when no match exists.

Exercise 7: Function Overloading

Create overloaded functions named calculateArea() for different shapes. Use distinguishable parameter signatures and test each overload.

Exercise 8: Higher-Order Function

Create a function that accepts two integers and a calculation lambda. Test it with addition, subtraction, and multiplication.

Exercise 9: Password Validation

Write a validation function that checks password length and other basic requirements. Return a Boolean result and test valid and invalid inputs.

Exercise 10: Android Profile Formatter

Create a function that accepts a user's name, age, and city, then returns a formatted profile summary as a String.

24. Mini Project: Student Profile Manager

Project Objective: Create a small Kotlin program that manages student profile information through reusable functions, parameters, and return values.

Project Requirements

• Create a data class to represent student details.
• Write a function to create a student profile.
• Write a function to format the profile as readable text.
• Write a function to check whether the student meets a specified age requirement.
• Return results from functions instead of printing every value inside each function.
• Use meaningful names and appropriate parameter types.

Sample Implementation

data class Student(
    val name: String,
    val age: Int,
    val course: String
)

fun createStudent(
    name: String,
    age: Int,
    course: String
): Student {
    require(name.isNotBlank())
    require(age >= 0)
    require(course.isNotBlank())

    return Student(name, age, course)
}

fun formatStudent(student: Student): String {
    return """
        Student Name: ${student.name}
        Age: ${student.age}
        Course: ${student.course}
    """.trimIndent()
}

fun isAdult(student: Student): Boolean {
    return student.age >= 18
}

fun main() {
    val student = createStudent(
        name = "Ananya",
        age = 21,
        course = "Android Development"
    )

    println(formatStudent(student))
    println("Adult: ${isAdult(student)}")
}

Expected Learning Outcomes

• Define functions that accept multiple parameters.
• Return structured data using a data class.
• Separate data creation, formatting, and validation.
• Use named arguments for clearer function calls.
• Apply reusable function design to Android application logic.

25. Interview Questions and Answers

Q1. What is a function in Kotlin?

A function is a reusable block of code that performs a specific task. It can accept parameters, execute statements, and return a result.

Q2. Which keyword is used to declare a function?

The fun keyword is used to declare a function in Kotlin.

Q3. What are parameters and arguments?

Parameters are variables declared in a function definition. Arguments are the actual values supplied when the function is called.

Q4. What is a return value?

A return value is the result a function produces and sends back to its caller.

Q5. How do you declare a return type in Kotlin?

Place a colon and the return type after the parameter list, as in fun add(a: Int, b: Int): Int.

Q6. What is the Unit type?

Unit represents the absence of a meaningful return value. Kotlin infers Unit for a block-bodied function that does not return a value when no other return type is specified.

Q7. What is a single-expression function?

A single-expression function uses an equals sign followed by an expression whose result becomes the return value.

Q8. What are default parameters?

Default parameters have predefined values that are used when callers omit the corresponding arguments.

Q9. What are named arguments?

Named arguments specify parameter names in a function call, improving readability and allowing arguments to be supplied in a different order when named explicitly.

Q10. What is function overloading?

Function overloading allows multiple functions to share a name when their parameter signatures differ in a way the compiler can distinguish.

Q11. Can Kotlin infer a function's return type?

Yes. Kotlin can infer return types for single-expression functions and many other expressions. Explicit return types are often useful for block-bodied functions and public APIs.

Q12. What is a nullable return type?

A nullable return type, such as String?, allows a function to return either a String or null.

Q13. What is an extension function?

An extension function provides additional callable functionality for an existing type without modifying its original source code.

Q14. What is a higher-order function?

A higher-order function accepts another function as a parameter or returns a function as its result.

Q15. What is recursion?

Recursion occurs when a function calls itself. A base case is needed to stop the recursive process.

Q16. Why are functions important in Android development?

Functions help separate UI behavior, data processing, validation, and business logic, improving reusability, readability, and testability.

Q17. How can a function return multiple values?

A function can return a compound type such as Pair, Triple, or a data class that contains multiple properties.

Q18. What is the difference between a parameter and a local variable?

A parameter receives input from the caller. A local variable is declared within a function or another local scope to store an intermediate or temporary value.

26. Quick Revision Checklist

• Understand the syntax of Kotlin functions.
• Know how to define and call functions.
• Differentiate parameters from arguments.
• Declare suitable return types and return values.
• Understand Unit and single-expression functions.
• Practice default and named arguments.
• Understand function overloading and scope.
• Handle nullable return values safely.
• Learn extension, higher-order, and recursive functions.
• Use data classes to return structured information.
• Apply functions to Android UI and business logic.
• Test functions with normal, boundary, and invalid inputs.

27. Conclusion

Functions, parameters, and return values are essential concepts in Kotlin programming and Android app development. Functions divide complex tasks into smaller reusable units, parameters allow them to receive different inputs, and return values make their results available to other parts of a program.

By learning default arguments, named arguments, function overloading, nullable results, extension functions, and higher-order functions, developers can create cleaner and more maintainable applications. Consistent practice with calculations, validation, profile management, and Android UI examples builds a strong foundation for advanced Kotlin programming.

Learn Android App Development with JustAcademy

Strengthen your Kotlin programming skills and learn how to build practical Android applications with the JustAcademy Android App Development course.

Course Details: View Android App Development Course

Book a Demo: Register for Course Demo

JustAcademy Website: Visit JustAcademy