Functions in Kotlin

# CHAPTER 9

Functions in Kotlin #

1. Chapter Introduction #

2. Learning Objectives #

• Declare standard functions using the fun keyword.

• Define parameters and return types.

• Create single-expression functions.

• Use Default Arguments to reduce function overloading.

• Use Named Arguments to improve code readability.

3. Declaring a Basic Function #

// Declaring the function
fun greetUser() {
    println("Welcome to the application!")
}

fun main() {
    // Calling the function
    greetUser()
    greetUser() // Reusable!
}

4. Parameters and Return Types #

• Parameters: Variables passed into the function (inside the ()). You MUST define their type.

• Return Type: The type of data the function sends back. Defined after a colon : at the end of the parentheses. If a function returns nothing, it technically returns Unit (similar to void in Java), but you don't need to write it.

// Function takes two Int parameters and returns an Int
fun addNumbers(a: Int, b: Int): Int {
    val sum = a + b
    return sum // Sends the result back to the caller
}

fun main() {
    val result = addNumbers(10, 5) // Passes 10 and 5 into the function
    println("The sum is $result")
}

5. Single-Expression Functions (Concise Syntax) #

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

// Single-expression way (Idiomatic Kotlin)
fun multiplyConcise(a: Int, b: Int) = a * b

6. Default Arguments (Eliminating Overloading) #

You can assign a default value to a parameter right in the declaration. If the caller doesn't provide it, the default is used.

// 'title' has a default value of "User"
fun printProfile(name: String, title: String = "User") {
    println("Name: $name | Title: $title")
}

fun main() {
    printProfile("Alice", "Admin") // Overrides default -> Title: Admin
    printProfile("Bob")            // Uses default -> Title: User
}

7. Named Arguments (Improving Readability) #

fun formatText(text: String, isBold: Boolean, isItalic: Boolean) {
    // ... formatting logic
}

fun main() {
    // Calling with Named Arguments makes it perfectly clear
    formatText(text = "Hello", isItalic = true, isBold = false)
}

8. Mini Project: Tax Calculator #

// Default tax rate is 10% (0.1)
fun calculateTotal(price: Double, taxRate: Double = 0.1): Double {
    val taxAmount = price * taxRate
    return price + taxAmount
}

fun main() {
    val phonePrice = 1000.0
    
    // Normal purchase (uses default 10% tax)
    val standardTotal = calculateTotal(price = phonePrice)
    
    // Duty-free purchase (we pass 0% tax)
    val dutyFreeTotal = calculateTotal(price = phonePrice, taxRate = 0.0)
    
    println("Standard Total: $$standardTotal")
    println("Duty Free Total: $$dutyFreeTotal")
}

9. Common Mistakes #

• Mutating Parameters: In Kotlin, function parameters are read-only (val) by default. You cannot do fun add(a: Int) { a = 10 }. This is by design to prevent accidental side effects. If you need to change it, assign it to a new var inside the function.

• Forgetting the Return Type: If you use the return keyword inside a standard function block {}, you MUST explicitly define the return type (e.g., : Int). Only single-expression functions = can infer return types.

10. Best Practices #

• Use Single-Expression syntax: Whenever your function is just returning a simple calculation or a when expression, use the = syntax. It keeps your codebase incredibly clean.

11. Exercises #

1. 1. Write a function greet(name: String). It should print "Hello, $name".

1. 2. Write a single-expression function isEven(num: Int) = num % 2 == 0.

1. 3. Call both in main().

12. MCQs with Answers #

13. Interview Questions #

• Q: Contrast Kotlin's Default Arguments with Java's Method Overloading. Why is Kotlin's approach considered more maintainable?

• Q: Explain what a Single-Expression Function is and write a quick example on the whiteboard.

14. Summary #

15. Next Chapter Recommendation #