Handling multiple cases in Java switch statements

java

prompt-engineering

best-practices

command-pattern

byAnton Shumikhin·Jan 26, 2025

Leverage the "fall-through" feature of the switch statement to handle multiple cases similarly.

switch(expression) {
    case A:
    case B:
        // Code simultaneously for A and B (neat, huh?😉)
        break;
    case C:
        // Code for the mysterious case C only 🕵️‍♀️
        break;
    // Feel free to add more cases... it won't bite!
}

Dealing with multiple cases concisely

When dealing with multiple cases in a switch statement, we can avoid repeating ourselves by arranging the cases to share a block of code until the program hits a break.

Leveraging the fall-through feature

The "fall-through" behavior of the switch statement allows it execute the same code block for several cases. No need to restate the code for each case.

switch(dayOfTheWeek) {
    case "Saturday":
    case "Sunday":
        // It's the weekend, parties allowed 🎉
        throwParties();
        break;
    default:
        // Back to the salt mines...
        work();
}

Avoiding manual labor with preprocessing

When dealing with large ranges like 5..100, preprocess your variable to fit within manageable bounds... because why do manual labor when you don't have to?

int weekNumber = (daysPassed / 7) % 4;
switch(weekNumber) {
    case 0:
        // The first week of a month is always hopeful 🌷
        break;
    case 3:
        // Gear up! One week until you pay your rent 💸...again.
        break;
    // And so on...
}

Dealing with wide number ranges

Java switch statements don't directly support ranges like 5..100, but we can implement a workaround by preprocessing the variable before the switch.

int range = (value >= 5 && value <= 100) ? 1 : 0;
switch (range) {
    case 1: // Welcome to the range of 5 to 100!
        // Do something delicious
        break;
    // More case definitions to cover the rest of the world 
}

Untangling complex switch cases

When dealing with a large or unstructured set of cases, a few strategies can help you not get lost in your own code.

Preprocess to simplify

Streamline a wide range of case expressions by preprocessing them into a conveniently small number of labels, leading to a more readable and maintainable switch block.

Delegate to commands

Delegate your switch cases to command classes using the Command pattern, ideal for situations where we need to inject custom behavior into each case without turning our switch block into a Lasagna code.

// Say hello! to Command pattern
switch(command) {
    case INSERT:
        // Execute Order 66... Oh, it's just an insert command? 😅
        new InsertCommand().execute();
        break;
    case UPDATE:
        // Initiating update... hold my coffee ☕
        new UpdateCommand().execute();
        break;
    // More cases to be catered...
}