Compact, Powerful, and Expressive

Java’s traditional switch statement has been a staple of the language since its inception. While functional, the old syntax has limitations, including verbosity and susceptibility to errors like missing break statements. To address these issues and make the language more modern and expressive, Java introduced a new switch expression starting with Java 12 (preview) and finalized in Java 14.

Let’s explore how the new switch works, its benefits, the role of yield, and when to use it over the traditional syntax.

Old switch Syntax

The traditional switch statement works like this:

switch (variable) {
    case value1:
        // Actions
        break;
    case value2:
        // Actions
        break;
    default:
        // Default actions
}

Example:

int day = 2;
String result;
switch (day) {
    case 1:
        result = "Monday";
        break;
    case 2:
        result = "Tuesday";
        break;
    case 3:
        result = "Wednesday";
        break;
    default:
        result = "Invalid day";
}
System.out.println(result);

Issues with the Old switch

1. Verbosity: Repeated break statements make the code unnecessarily long.
2. Error-prone: Forgetting a break can cause unintended fall-through behavior, where execution continues into the next case.
3. No return value: The old switch can’t return values directly, requiring external variables to store results.

The New switch Syntax

Java’s new switch solves these problems by introducing:

1. Arrow Syntax (->): For concise, one-line case statements.
2. Expression-based switch: Allows switch to return values directly.
3. yield Keyword: Used to return values in multi-line case blocks.

Basic Structure of the New switch

switch (variable) {
    case value1 -> action1;
    case value2 -> action2;
    default -> defaultAction;
}

Example:

int day = 2;
String result = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    default -> "Invalid day";
};
System.out.println(result); // Outputs: Tuesday

Key Differences: Old vs. New switch

yield: The Key to Returning Values

The yield keyword is introduced in the new switch to return a value from a multi-line case block. It replaces the need for a temporary variable and makes the logic cleaner.

Example with yield:

int knappNr = 2;
int pris = switch (knappNr) {
    case 0 -> 3145;
    case 1 -> 4295;
    case 2 -> {
        System.out.println("Processing case 2");
        yield 4995; // Returns this value
    }
    default -> 0;
};
System.out.println("Pris: " + pris); // Outputs: 4995

Why yield?

• When a case block has more than one line, yield is mandatory to specify the return value.
• It makes multi-line cases just as expressive as one-line cases.

Pros of the New switch

1. Compact Code: Eliminates the need for repetitive break statements.
2. Error Prevention: No accidental fall-through behavior.
3. Direct Value Return: Makes code cleaner and avoids intermediate variables.
4. Readability: Easier to read and maintain, especially with multiple cases.

When to Use the New switch

Use the new switch when:

1. You need a concise way to handle multiple cases.
2. You want switch to return a value directly.
3. You’re working in modern Java versions (Java 14+).

Use the old switch when:

1. You need to maintain compatibility with older Java versions.
2. Your case blocks require highly complex logic that might make the new syntax less intuitive.

Practical Examples

Example 1: Assigning Grades

char grade = 'B';
String feedback = switch (grade) {
    case 'A' -> "Excellent!";
    case 'B' -> "Good job!";
    case 'C' -> "Fair.";
    default -> "Invalid grade.";
};
System.out.println(feedback); // Outputs: Good job!

Example 2: Handling Weekends

int day = 6;
String message = switch (day) {
    case 6, 7 -> "Weekend!";
    default -> "Weekday.";
};
System.out.println(message); // Outputs: Weekend!

Key Takeaways

1. Modern Syntax: The new switch makes Java code more concise, readable, and expressive.
2. yield for Multi-line Logic: Use yield to return values from blocks of code.
3. Compatibility: Works only in Java 14+.
4. When to Use: Ideal for scenarios where multiple values map to simple outcomes.

The new switch is a significant improvement over the old syntax. It combines power with simplicity, making it a must-use feature for developers adopting modern Java practices.