Switch Case Program in Java

Last Updated on February 6, 2024 by Abhishek Sharma

Switch case statements in Java are a powerful tool for handling multiple conditions in a concise and readable manner. This programming construct allows developers to execute different blocks of code based on the value of a variable or an expression. Unlike multiple nested if-else statements, switch cases provide a more structured and efficient way to handle multiple possibilities, enhancing the overall clarity and maintainability of Java programs.

In Java, the switch statement evaluates an expression, and based on its value, control is transferred to the matching case. Each case block contains specific code to be executed when the expression matches the corresponding value. The switch statement helps simplify code, making it easier to understand, write, and maintain, especially when dealing with a large number of possible values.

What is a Switch Statement in Java?

A switch statement in Java is a type of control statement used to execute specific blocks of code based on the value of a given expression or variable. It is primarily used when there are multiple options available for a single variable, and you need to perform different actions based on the value of that variable.

In switch statements, a single expression is evaluated, and the program checks the value of the expression against the values in the case statements. If the value of the expression matches any of the case statements, the code block associated with that case statement is executed. If none of the case statements match the value of the expression, the code block associated with the default statement is executed.

Syntax of Switch Statement in Java

The syntax of a switch statement in java is as follows:

switch (expression) {
    case value1:
        // code to be executed when the expression matches value1
        break;
    case value2:
        // code to be executed when the expression matches value2
        break;
    case value3:
        // code to be executed when the expression matches value3
        break;
    .
    .
    .
    default:
        // code to be executed when none of the cases match the expression
}

Point To Note: The expression being tested must evaluate to a primitive data type such as int, char, byte, or short. The switch statement can also work with enumerated types and strings starting from Java SE 7. Additionally, the case labels must be unique, and the default label is optional.

How does Switch Case Program in Java Works?

A switch case program in java works by evaluating the expression or variable provided in the switch statement and then matching it to a case label. When a matching case label is found, the corresponding block of code is executed.

Here is a step-by-step explanation of how a switch case program in java works:

• Step 1 – The switch statement is evaluated. The expression or variable provided in the parentheses is evaluated, and the resulting value is used as the basis for comparison.
• Step 2 – The value of the expression is compared to each of the case labels in the switch statement. If a match is found, the code block associated with that case label is executed.
• Step 3 – If none of the case labels match the expression, the default block of code is executed.
• Step 4 – When the code block associated with a matching case label is executed, any statements inside that block are executed until the end of the block is reached or until a break statement is encountered.
• Step 5 – The break statement is used to exit the switch statement and prevent any further code from being executed. If no break statement is used, the program will continue to execute the code in subsequent cases until a break statement is encountered or the end of the switch statement is reached.
• Step 6 – Once the code associated with a matching case label is executed and the break statement is encountered, control is passed to the next statement outside of the switch statement.

Flow Chart of Switch Case Program in Java

The flowchart of a switch case program in Java is as follows:

Examples of Switch Statement

Below are some examples which helps in understanding the different aspects of a switch case program in java.

Example 1: Omitting the break Statement
When break statement is omitted in a switch case program in java, the code will continue to execute through the next case statement until a break is encountered. This can lead to unexpected behavior and errors in the code.

Code Implementation:

class PrepBytes {
    public static void main(String[] args)
    {
        int num = 2;
        switch(num) {
          case 1:
            System.out.println("One");
          case 2:
            System.out.println("Two");
          case 3:
            System.out.println("Three");
            break;
        }
    }
}

Output:

Two
Three

Explanation: In this example, the variable num is set to 2. The switch case statement will evaluate the value of num and execute the corresponding block of code. However, since the break statement is omitted after the first case statement, the code will continue to execute and print "Two" and "Three" to the console.

Example 2: Nested Switch Case Statements
A switch case statement can be nested within another switch case statement to provide more complex control flow in a program.

Code Implementation:

class PrepBytes
{
    public static void main (String[] args) throws java.lang.Exception
    {
        int num1 = 1;
        int num2 = 2;
        switch(num1) {
          case 1:
            switch(num2) {
              case 1:
                System.out.println("One-One");
                break;
              case 2:
                System.out.println("One-Two");
                break;
            }
            break;
          case 2:
            System.out.println("Two");
            break;
          default:
            System.out.println("Default");
        }
    }
}

Output:

One-Two

Explanation: In this example, there are two variables num1 and num2. The first switch case statement will evaluate the value of num1 and execute the corresponding block of code. If num1 is 1, the second switch case statement will evaluate the value of num2 and execute the corresponding block of code. If num1 is 2, the program will print "Two" to the console. If neither of these conditions are met, the default block of code will be executed and print "Default" to the console.

Example 3: Changing the Place of default Statement
The default statement in a switch case program in java will be executed if none of the case statements match the value of the expression or variable being evaluated. By changing the position of the default statement, the program behavior can be altered.

Code Implementation:

import java.io.*;

class PrepBytes {
    public static void main (String[] args) {
        int i=5;
        switch(i){
        default:
            System.out.println("Default");
        case 1:
            System.out.println(1);
            break;
        case 2:
            System.out.println(2);
        case 3:
            System.out.println(3);
        }
    }
}

Output:

Default
1

Explanation: In this Java code, the variable i is set to 5, and the switch case statement evaluates its value. Since none of the case statements match the value of i, the default block of code will be executed and print "Default" to the console. But in this case, the default statement comes before all the other case statements. This means that if none of the case statements match the value of i, the default block of code will always be executed. After executing the default block, the program also executes case statement 1 and stops after encountering the break keyword.

Conclusion
In conclusion, the switch case construct in Java is a valuable feature for streamlining decision-making processes in a program. Its simplicity and readability make it an excellent choice when dealing with scenarios involving multiple conditions. However, it’s essential to note that switch cases work effectively when dealing with discrete values and constant expressions. For more complex conditions, a combination of if-else statements or other control flow structures may be more appropriate.

Understanding how to leverage switch case statements in Java allows developers to write cleaner and more efficient code, ultimately contributing to the overall success of software projects. As with any programming construct, it’s important to use switch cases judiciously and in alignment with the specific requirements of the task at hand.

FAQs Related to Switch Case Program in Java

Here are some frequently asked questions related to the switch case program in java.

Q1: What happens if no case label matches the value of the expression?
Ans: variable in a switch case program in java?
If no case label matches the value of the expression or variable in a switch case program, the default block of code is executed.

2. How does a switch case differ from an if-else statement?
Unlike an if-else statement, which evaluates a boolean expression, a switch case evaluates a specific variable or expression and executes the block of code associated with the matching case.

3. What types of values can be used in a switch case?
Switch cases work with integral types (byte, short, char, int), enumerations, and String objects in Java.

4. Can you have multiple case values executing the same block of code?
Yes, multiple case values can share the same block of code by omitting the break statement. This is known as "falling through."

5. What happens if there is no matching case in a switch statement?
If there is no matching case, the default case (if present) will be executed. If there is no default case, the switch statement will have no effect.

6. Can a switch case handle non-constant expressions?
No, switch cases in Java require constant expressions. For non-constant expressions or ranges, developers typically use if-else statements.