Using switch Statements in Java

Course: Core Java Training

Topic: Using switch Statements in Java

Course Link: Core Java Training Course

Demo Link: Register for a Free Course Demo

JustAcademy Homepage: Visit JustAcademy

1. Introduction to the switch Statement

The switch statement in Java is a decision-making control structure used to execute one block of code from several possible alternatives. It evaluates an expression and compares its value against different case labels. When a matching case is found, the statements associated with that case can execute.

A switch statement is useful when a program must choose between several fixed options, such as displaying a menu, selecting a day of the week, determining a grade category, or processing a user-selected operation.

For example, if a user enters a number from 1 to 7, a switch statement can display the corresponding day of the week. This is often easier to read than writing many separate if-else-if conditions.

Why use switch?

• To handle multiple possible values of an expression.
• To make multi-option decision logic easier to read.
• To avoid repeating the same expression in several equality checks.
• To organize menu-based and option-based programs.
• To separate the actions associated with each possible case.

2. Basic Syntax of a switch Statement

The traditional switch statement uses the keywords switch, case, break, and default.

switch (expression) {
    case value1:
        // Statements for value1
        break;
    case value2:
        // Statements for value2
        break;
    case value3:
        // Statements for value3
        break;
    default:
        // Statements when no case matches
}

Explanation of the syntax

3. How a switch Statement Works

When Java executes a traditional switch statement, it evaluates the switch expression, looks for a matching case label, and begins executing from the matching label. If a break statement is encountered, execution exits the switch. Without a break or another control-flow transfer, execution may continue into subsequent case sections. This behavior is known as fall-through.

1. The switch expression is evaluated.
2. Java identifies a matching case label, if one exists.
3. Execution starts at the matching case.
4. Statements execute until a control-flow statement exits the switch or the switch ends.
5. If no case matches, the default branch runs when it is present.

4. A Simple switch Example

The following example displays a message based on a number representing a day of the week.

public class DayExample {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day number");
        }
    }
}

Output:

Wednesday

Explanation: The value of day is 3, so Java starts executing at case 3. The message is printed, and break prevents execution from continuing into the next case.

5. Understanding case Labels

A case label identifies a possible value of the switch expression. In a traditional switch statement, case labels must be compatible with the type of the switch selector and must be valid compile-time constants. Duplicate case values are not allowed.

int choice = 2;

switch (choice) {
    case 1:
        System.out.println("Create");
        break;
    case 2:
        System.out.println("Update");
        break;
    case 3:
        System.out.println("Delete");
        break;
    default:
        System.out.println("Unknown choice");
}

Output:

Update

Here, the value 2 matches the second case, so the program prints Update.

6. The Purpose of break

The break statement exits the nearest enclosing switch statement. In traditional switch syntax, it is commonly used at the end of each case to prevent accidental fall-through.

int number = 1;

switch (number) {
    case 1:
        System.out.println("One");
        break;
    case 2:
        System.out.println("Two");
        break;
    default:
        System.out.println("Other");
}

Output:

One

If the break after case 1 were removed, execution would continue into the statements under case 2 and potentially into the default section. This is why traditional switch statements need deliberate fall-through handling.

When can break be omitted?

A break is not needed when a branch intentionally continues into another case, or when execution exits by another means such as a return statement. However, intentional fall-through should be clear and documented where appropriate.

7. The default Case

The default branch runs when none of the case labels matches the switch expression. It is optional, but it is useful for handling unexpected or unsupported input.

int menuOption = 8;

switch (menuOption) {
    case 1:
        System.out.println("Open file");
        break;
    case 2:
        System.out.println("Save file");
        break;
    case 3:
        System.out.println("Close file");
        break;
    default:
        System.out.println("Please select a valid option");
}

Output:

Please select a valid option

The value 8 does not match any listed case, so the default branch runs. The default label can appear in different positions in a traditional switch, but placing it at the end is often clearer for readers.

8. Using Multiple Case Labels for One Action

Sometimes multiple values should trigger the same behavior. In a traditional switch statement, several case labels can be grouped together before a shared block of statements.

int day = 6;

switch (day) {
    case 6:
    case 7:
        System.out.println("Weekend");
        break;
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("Weekday");
        break;
    default:
        System.out.println("Invalid day");
}

Output:

Weekend

Both 6 and 7 lead to the same weekend message. The grouped labels share a single block, avoiding duplicated code.

9. Using switch with char Values

A switch can select a branch based on a char value. This is useful for single-character commands, menu shortcuts, or grade categories.

char grade = 'B';

switch (grade) {
    case 'A':
        System.out.println("Excellent");
        break;
    case 'B':
        System.out.println("Very good");
        break;
    case 'C':
        System.out.println("Good");
        break;
    case 'D':
        System.out.println("Needs improvement");
        break;
    default:
        System.out.println("Unknown grade");
}

Output:

Very good

Character literals use single quotation marks. For example, 'B' is a character literal, whereas "B" is a string literal.

10. Using switch with String Values

Java supports switching on String values. This can be useful for commands, categories, and textual menu options. String matching in a switch is case-sensitive, so "start" and "START" are different values.

public class CommandExample {
    public static void main(String[] args) {
        String command = "start";

        switch (command) {
            case "start":
                System.out.println("Application started");
                break;
            case "stop":
                System.out.println("Application stopped");
                break;
            case "pause":
                System.out.println("Application paused");
                break;
            default:
                System.out.println("Unknown command");
        }
    }
}

Output:

Application started

Important: A traditional switch that selects on a String throws a NullPointerException if the selector evaluates to null. Validate input or handle null before switching when null is possible.

11. Building a Calculator with switch

A calculator is a practical example of using switch statements to select an operation. The operator determines which calculation should be performed.

public class Calculator {
    public static void main(String[] args) {
        double a = 20;
        double b = 5;
        char operator = '*';

        switch (operator) {
            case '+':
                System.out.println("Result: " + (a + b));
                break;
            case '-':
                System.out.println("Result: " + (a - b));
                break;
            case '*':
                System.out.println("Result: " + (a * b));
                break;
            case '/':
                if (b != 0) {
                    System.out.println("Result: " + (a / b));
                } else {
                    System.out.println("Cannot divide by zero");
                }
                break;
            default:
                System.out.println("Invalid operator");
        }
    }
}

Output:

Result: 100.0

This example shows that switch handles the operation choice, while an if statement can handle a condition within one branch. The two decision-making structures can be combined when necessary.

12. Traditional switch Statements and Fall-Through

In traditional switch syntax, a matching case does not automatically stop execution at the end of its statements. If the code does not execute break, return, or another control-flow transfer, it may continue into the next case. This is called fall-through.

int value = 1;

switch (value) {
    case 1:
        System.out.println("First");
    case 2:
        System.out.println("Second");
    case 3:
        System.out.println("Third");
        break;
    default:
        System.out.println("Other");
}

Output:

First
Second
Third

This behavior is sometimes intentional, but it can also cause bugs. Add break statements when each case should operate independently.

13. Modern switch Expressions

Modern Java versions support switch expressions, which can produce a value. They commonly use arrow labels (->) and avoid the traditional fall-through behavior between arrow-style branches. Switch expressions were finalized in Java 14 after earlier preview versions.

public class SwitchExpressionExample {
    public static void main(String[] args) {
        int day = 3;

        String dayType = switch (day) {
            case 1, 2, 3, 4, 5 -> "Weekday";
            case 6, 7 -> "Weekend";
            default -> "Invalid day";
        };

        System.out.println(dayType);
    }
}

Output:

Weekday

In this example, the switch expression returns a String, which is assigned to dayType. Multiple labels can be grouped with commas.

Using yield in a switch expression

When an arrow-style branch needs multiple statements, a block can be used. The yield keyword supplies the value returned by that branch.

int score = 85;

String result = switch (score / 10) {
    case 10, 9 -> "Excellent";
    case 8 -> {
        System.out.println("Score is in the 80s");
        yield "Very good";
    }
    case 7 -> "Good";
    default -> "Keep practicing";
};

System.out.println(result);

Output:

Score is in the 80s
Very good

Use yield when a switch-expression block must return a value after executing additional statements. Do not confuse it with break, which exits a traditional switch statement.

14. Supported Types and Case Values

The types accepted by switch depend on the Java language version and the form of switch being used. Traditional switch statements support types such as byte, short, char, int, their corresponding wrapper types, enumerations, and String. Newer Java versions also support additional forms, including pattern matching in switch, subject to the language version and feature status.

Case labels must be compatible with the selector type and satisfy the rules for the Java version in use. If a switch example fails to compile, check both the data type and the configured Java language level.

15. switch vs. if-else

Example: Use switch to select a menu command such as Open, Save, or Exit. Use if-else to determine whether a score is above or below a threshold.

16. Common Errors When Using switch

• Forgetting break: In traditional switch statements, later case statements may execute unintentionally.
• Using unsupported types: A traditional switch cannot directly select on a boolean or double value.
• Repeating case labels: Duplicate case constants cause a compilation error.
• Incorrect String capitalization: String case matching is case-sensitive.
• Assuming default is mandatory: The default branch is optional, though it is often useful.
• Ignoring null input: A null String selector can cause a NullPointerException in a traditional String switch.
• Confusing switch statements and expressions: A switch expression must produce a value on every possible path.
• Using a case label for a range: Traditional case labels do not work like arbitrary Boolean conditions such as score > 80.

17. Best Practices for Writing switch Statements

• Use switch when selecting among a clear set of discrete values.
• Include a default branch when it helps handle unexpected inputs.
• In traditional switch statements, use break unless fall-through is intentional.
• Group cases when they should produce the same result.
• Keep each case focused on one action or a small, understandable group of actions.
• Validate user input before processing it.
• Consider switch expressions for value selection when the Java version supports them.
• Use if-else for ranges, compound Boolean conditions, and comparisons that do not fit naturally into case labels.
• Use clear names for variables that represent choices or commands.
• Compile and test boundary values, unsupported values, and unexpected input.

18. Practice Exercises

Exercise 1: Month Name

Write a program that accepts a number from 1 to 12 and prints the corresponding month name. Display an error message for any number outside this range.

Exercise 2: Grade Description

Create a switch statement using a character grade such as A, B, C, D, or F. Print a description for each grade and handle invalid characters.

Exercise 3: Simple Calculator

Write a calculator that uses a character operator to perform addition, subtraction, multiplication, or division. Include a check to prevent division by zero.

Exercise 4: Traffic Light

Use a String variable containing "red", "yellow", or "green" to print the appropriate action. Handle unknown values and consider capitalization.

Exercise 5: Switch Expression

Use a modern switch expression to convert a number from 1 to 7 into a weekday name. Return an appropriate message for an invalid number.

19. Interview Questions and Answers

Q1. What is a switch statement in Java?

A switch statement is a control-flow structure that selects a branch based on the value of an expression.

Q2. What is the purpose of the break statement?

In a traditional switch statement, break exits the switch and prevents execution from falling through into subsequent cases.

Q3. Is the default case compulsory?

No. The default branch is optional, but it is useful when no case matches the supplied value.

Q4. What happens if break is omitted?

In a traditional colon-style switch, execution may continue into later case sections until another control-flow statement exits the switch or the switch ends.

Q5. Can String be used in a switch statement?

Yes. String is supported by traditional switch statements in modern Java versions. Matching is case-sensitive, and a null selector needs to be handled separately.

Q6. Can we use double in a traditional switch statement?

No. Traditional switch statements do not directly support double selectors. Use if-else or another suitable approach.

Q7. What is fall-through?

Fall-through occurs when execution continues from one traditional case section into following case sections because no control-flow statement stops it.

Q8. What is a switch expression?

A switch expression produces a value that can be assigned to a variable or used in another expression. Modern switch expressions commonly use arrow labels and may use yield inside a block.

Q9. When should we use if-else instead of switch?

Use if-else for ranges, complex Boolean expressions, and conditions such as whether a score is above a threshold. Use switch for selecting among discrete values.

Q10. Can multiple case labels share one block?

Yes. In traditional switch syntax, case labels can be placed consecutively before a shared block. Modern switch syntax can group labels using commas.

20. Quick Revision Checklist

• Understand the purpose and syntax of the switch statement.
• Know how switch expressions are evaluated and how case labels match values.
• Use break correctly in traditional switch statements.
• Understand the default branch and fall-through behavior.
• Practice using int, char, String, and enum selectors.
• Recognize which selector types are not supported by traditional switch.
• Understand the difference between switch statements and switch expressions.
• Choose if-else for ranges and complex Boolean conditions.
• Test invalid input and possible null values.

21. Conclusion

The Java switch statement is an important decision-making tool for programs that must choose among several discrete options. Understanding case labels, break, default, and fall-through helps you write correct traditional switch statements. Modern switch expressions provide a concise way to return values, while if-else remains the better choice for ranges and complex conditions.

To continue learning Java programming, explore the Core Java Training Course, visit the course demo registration page, or visit the JustAcademy homepage.

Official reference: Oracle Java Tutorial: The switch Statement.