Replacing Switch with When Expressions

1. From Java switch to Kotlin when

Given your experience with Java, you are well-acquainted with the switch statement. It's useful, but it has some well-known drawbacks, such as the mandatory break statements to prevent "fall-through" and its limited applicability.

Kotlin's when expression addresses these issues directly. Let's start by seeing how when serves as a modern replacement for switch.

As you saw, when is syntactically cleaner and more intuitive. Let's recap the key differences from Java's switch:

• No break needed: when automatically executes only the code for the matching branch. This prevents the common bug of forgetting a break statement.
• -> operator: Branches are defined with an arrow (->) instead of a colon.
• else for default: The default case is replaced by a more conventional else branch.

Here's a side-by-side comparison:

Java switch

int day = 2;
String dayName;
switch (day) {
    case 1: dayName = "Monday"; break;
    case 2: dayName = "Tuesday"; break;
    default: dayName = "Some other day"; break;
}

Kotlin when (as a statement)

val day = 2
when (day) {
    1 -> println("Tuesday")
    2 -> println("Tuesday")
    else -> println("Some other day")
}

2. when as an Expression

Just like if, when is an expression in Kotlin, meaning it can evaluate to a value. This is where its power truly begins to show, allowing you to write even more concise and functional code.

Let's continue with the same video to see this in action.

By using when as an expression, we can refactor our previous example to be much cleaner:

val day = 2
val dayName = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    else -> "Some other day"
}
println(dayName) // Prints "Tuesday"

Notice that we can assign the result directly to an immutable val. When when is used as an expression, the compiler enforces that all possible paths return a value. This means the else branch is usually mandatory, ensuring your expression is exhaustive.

3. The Versatility of when

when is far more than just a switch replacement. It supports a variety of conditions that make it incredibly versatile. The following article from Baeldung provides a great overview of these advanced capabilities.

Let's summarize those powerful features with some examples:

• Combining multiple values:

  val code = 200
  when (code) {
      200, 201, 202 -> println("Success")
      else -> println("Not a success code")
  }
  

• Using ranges:

  val httpStatus = 404
  val statusCategory = when (httpStatus) {
      in 200..299 -> "Success"
      in 300..399 -> "Redirection"
      in 400..499 -> "Client Error"
      in 500..599 -> "Server Error"
      else -> "Unknown"
  }
  println(statusCategory) // Prints "Client Error"
  

• Checking types (with smart casting):

  fun processValue(value: Any) {
      when (value) {
          is String -> println("It's a String of length ${value.length}") // value is smart-cast to String
          is Int -> println("It's an Int with value $value") // value is smart-cast to Int
          else -> println("It's some other type")
      }
  }
  processValue("Hello Kotlin") // Prints "It's a String of length 12"
  

• when without an argument: This is perfect for replacing complex if-else-if chains.

  val name = "Alex"
  val number = 42
  when {
      name.startsWith("A") -> println("Name starts with A")
      number > 50 -> println("Number is large")
      else -> println("No condition met")
  }
  

4. Hands-On Practice

In the previous lesson, you wrote a function getStatusMessage using an if-else-if ladder. Let's refactor it to use when and add more sophisticated logic.

Goal: Refactor the getStatusMessage function to use a when expression and handle ranges of HTTP status codes.

1. Open the Kotlin file from your previous exercise.
2. Modify the getStatusMessage(statusCode: Int): String function.
3. Replace the if-else-if chain with a single when expression that returns the status category as a String.
4. Use ranges to categorize the codes:
   • 200..299 should return "Success".
   • 300..399 should return "Redirection".
   • 400..499 should return "Client Error".
   • 500..599 should return "Server Error".
5. Handle the specific code 418 separately to return "I'm a teapot".
6. For all other codes, use an else branch to return "Unknown Category".
7. In your main function, test your refactored function with codes like 200, 302, 404, 418, 503, and 100.

fun getStatusMessage(statusCode: Int): String {
    return when (statusCode) {
        in 200..299 -> "Success"
        in 300..399 -> "Redirection"
        418 -> "I'm a teapot" // Specific cases are checked before ranges if placed first
        in 400..499 -> "Client Error"
        in 500..599 -> "Server Error"
        else -> "Unknown Category"
    }
}

fun main() {
    println("Code 200: ${getStatusMessage(200)}")       // Expected: Success
    println("Code 302: ${getStatusMessage(302)}")       // Expected: Redirection
    println("Code 404: ${getStatusMessage(404)}")       // Expected: Client Error
    println("Code 418: ${getStatusMessage(418)}")       // Expected: I'm a teapot
    println("Code 503: ${getStatusMessage(503)}")       // Expected: Server Error
    println("Code 100: ${getStatusMessage(100)}")       // Expected: Unknown Category
}

Conclusion

In this lesson, you've mastered Kotlin's when expression, a powerful tool for conditional logic. You've seen how it improves upon Java's switch statement and provides a cleaner alternative to complex if-else structures.

Key Takeaways:

• when is Kotlin's modern replacement for switch, eliminating the need for break statements.
• Like if, when is an expression that returns a value, enabling more declarative and immutable code.
• The else branch is mandatory when when is used as an expression to ensure all possibilities are handled.
• when is highly versatile, supporting conditions like multiple values, ranges (in), and type checks (is) with smart casting.

Next Lesson Preview:

We are now concluding the "Kotlin Fundamentals" module. In our next lesson, we will begin a new module, "Null Safety and Advanced Functions". The first topic is one of Kotlin's most celebrated features: nullability. We will explore how Kotlin's type system is designed to help you avoid NullPointerExceptions, a frequent source of bugs in Java. You'll learn the difference between nullable and non-nullable types and how to work with them safely.