5. Control Flow in Kotlin

Control flow is a fundamental concept in programming that allows you to dictate the order in which your code is executed. In Kotlin, control flow is managed through a variety of constructs that include conditional statements, loops, and more advanced features like when expressions and exceptions. This section will guide you through these constructs, providing you with the tools necessary to handle complex decision-making processes in your Android app development.

Conditional Statements

Conditional statements allow you to execute certain parts of your code based on specific conditions. In Kotlin, the primary conditional statement is the if statement, which functions similarly to its counterparts in other programming languages like Java and C++.

val number = 10
if (number > 5) {
    println("The number is greater than 5.")
} else {
    println("The number is 5 or less.")
}

In Kotlin, if can also be used as an expression, meaning it can return a value. This allows you to assign the result of an if expression to a variable:

val max = if (a > b) a else b

This feature can make your code more concise and expressive, reducing the need for temporary variables and additional lines of code.

When Expressions

The when expression in Kotlin is a powerful alternative to the traditional switch statement found in other languages. It allows you to match a value against a series of conditions, executing the corresponding block of code for the first matching condition.

val x = 2
when (x) {
    1 -> println("x is 1")
    2 -> println("x is 2")
    else -> println("x is neither 1 nor 2")
}

The when expression can also be used without an argument, acting as a more flexible version of an if-else chain:

when {
    x.isOdd() -> println("x is odd")
    x.isEven() -> println("x is even")
    else -> println("x is neither odd nor even")
}

This flexibility makes the when expression an invaluable tool for handling multiple conditions in a clean and readable manner.

Loops

Loops are essential for executing a block of code multiple times. Kotlin provides several types of loops, including for, while, and do-while loops.

For Loops

In Kotlin, the for loop is used to iterate over ranges, arrays, or any iterable object. The syntax is concise, and the loop variable is defined directly within the loop:

for (i in 1..5) {
    println(i)
}

The for loop can also iterate over arrays and collections:

val items = listOf("apple", "banana", "kiwi")
for (item in items) {
    println(item)
}

While Loops

The while loop continues to execute a block of code as long as its condition is true. It is particularly useful when the number of iterations is not known beforehand:

var i = 0
while (i < 5) {
    println(i)
    i++
}

Do-While Loops

The do-while loop is similar to the while loop, but it guarantees that the block of code will be executed at least once. The condition is checked after the execution of the loop's body:

var i = 0
do {
    println(i)
    i++
} while (i < 5)

Break and Continue

Kotlin provides break and continue keywords to control the flow of loops. The break statement terminates the loop immediately, while the continue statement skips the current iteration and proceeds to the next one.

for (i in 1..10) {
    if (i == 5) break
    println(i)
}

In this example, the loop will terminate when i equals 5. The continue keyword can be used similarly to skip specific iterations:

for (i in 1..10) {
    if (i % 2 == 0) continue
    println(i)
}

This loop will print only odd numbers, skipping even numbers due to the continue statement.

Labels

In Kotlin, you can use labels to control the flow of nested loops more precisely. A label is an identifier followed by the @ sign, and it can be used with break and continue to specify which loop to terminate or continue.

outer@ for (i in 1..5) {
    for (j in 1..5) {
        if (i == 3 && j == 3) break@outer
        println("i = $i, j = $j")
    }
}

In this example, the break@outer statement exits the outer loop when both i and j equal 3, demonstrating how labels can enhance the control flow in complex loop structures.

Exception Handling

Exception handling is crucial for building robust applications that can gracefully handle unexpected situations. Kotlin uses try, catch, finally, and throw to manage exceptions.

try {
    val result = riskyOperation()
    println("Result: $result")
} catch (e: Exception) {
    println("Caught an exception: ${e.message}")
} finally {
    println("This will always execute.")
}

The try block contains the code that might throw an exception, the catch block handles the exception, and the finally block contains code that will execute regardless of whether an exception is thrown.

You can also throw exceptions explicitly using the throw keyword:

fun riskyOperation() {
    throw Exception("Something went wrong!")
}

By mastering these control flow constructs, you'll be well-equipped to handle complex logic in your Kotlin applications, ensuring they are both efficient and easy to maintain.

Next page of the Free Ebook:

6Functions in Kotlin

7 minutes