Exception Handling

# CHAPTER 20

Exception Handling #

1. Chapter Introduction #

2. Learning Objectives #

• Understand what an Exception is.

• Use try, catch, and finally blocks.

• Use try as an Expression to assign default values.

• Throw custom exceptions using the throw keyword.

• Build a Mini Project: Safe Calculator.

3. The try-catch Block #

fun main() {
    val input = "ABC"

    try {
        // This will crash! "ABC" is not a number.
        val number = input.toInt() 
        println("The number is $number") // This line is skipped!
    } catch (e: NumberFormatException) {
        // The crash is caught here!
        println("Error: The input was not a valid number.")
        println("System Message: ${e.message}")
    }
    
    println("Program continues running safely...")
}

4. The finally Block #

fun main() {
    try {
        val result = 10 / 0 // ArithmeticException (Divide by zero)
    } catch (e: ArithmeticException) {
        println("Math Error!")
    } finally {
        println("This will print no matter what happens.")
    }
}

5. try as an Expression (Kotlin Superpower) #

fun main() {
    val userInput = "Five"

    // If successful, 'number' equals the Int.
    // If it crashes, 'number' equals 0.
    val number: Int = try {
        userInput.toInt()
    } catch (e: Exception) {
        0 
    }

    println("Saved number: $number")
}

*(Note: For this specific scenario, Kotlin provides toIntOrNull(), but try as an expression is useful for complex network or database operations!)*

6. Throwing Exceptions #

fun setAge(age: Int) {
    if (age < 0) {
        // Trigger a custom crash!
        throw IllegalArgumentException("Age cannot be negative! Received: $age")
    }
    println("Age set to $age")
}

fun main() {
    try {
        setAge(-5)
    } catch (e: IllegalArgumentException) {
        println("Caught an error: ${e.message}")
    }
}

7. Checked Exceptions vs Unchecked Exceptions #

8. Mini Project: Safe Calculator #

fun main() {
    print("Enter numerator: ")
    val num1Str = readln()
    
    print("Enter denominator: ")
    val num2Str = readln()

    try {
        val num1 = num1Str.toInt()
        val num2 = num2Str.toInt()
        
        val result = num1 / num2
        println("Result: $result")
        
    } catch (e: NumberFormatException) {
        println("Error: Please enter numbers only, not letters.")
    } catch (e: ArithmeticException) {
        println("Error: You cannot divide by zero.")
    } catch (e: Exception) {
        // Catches any other unknown errors
        println("An unknown error occurred.")
    }
}

9. Common Mistakes #

• Catching global Exception for everything: Writing catch (e: Exception) is a "catch-all". It is bad practice because it hides specific bugs. Catch specific exceptions (like NumberFormatException) first, so you know exactly what failed.

• Empty Catch Blocks: Catching an error and doing nothing (catch(e: Exception) { }). If the app fails, you will have no idea why because the error was silently swallowed. Always log or print the error.

10. Best Practices #

• Use standard library safety features: Before writing a massive try-catch block, check if Kotlin has a safe alternative (like toIntOrNull() or ?.). Only use try-catch for operations involving external systems (File I/O, Network, Databases).

11. Exercises #

1. 1. Write a program that defines an array: val arr = arrayOf(1, 2, 3).

1. 2. Wrap println(arr[5]) in a try-catch block.

1. 3. Catch the ArrayIndexOutOfBoundsException and print "Index invalid!".

12. MCQs with Answers #

13. Interview Questions #

• Q: Why did the creators of Kotlin decide to remove "Checked Exceptions" which were prominent in Java? (Answer: Because forcing developers to catch exceptions often leads to bloated, unreadable code with empty catch blocks, reducing overall code quality).

• Q: Explain how try can be used as an expression in Kotlin.

14. Summary #

15. Next Chapter Recommendation #