The switch statement in Java is a control flow structure that allows you to execute different parts of your code based on the value of a given variable. It is often used as an alternative to long chains of if-else statements, making the code more readable and easier to manage when multiple conditions are checked.
This tutorial will walk you through how the switch statement works in Java, along with several examples demonstrating its usage.
Table of Contents:
Table of Contents
1. Introduction to switch Statement
The switch statement evaluates a variable and compares it against a list of predefined values (called case values). Based on which case matches, the corresponding block of code is executed. It is commonly used when you need to check multiple potential values for a single variable.
2. Syntax of switch Statement
Syntax:
switch (expression) {
case value1:
// Code to be executed when expression equals value1
break;
case value2:
// Code to be executed when expression equals value2
break;
default:
// Code to be executed if none of the above cases match
}
expression: The value being evaluated (must be a byte, short, char, int, String, or an enum).
case: Specifies possible values for expression.
break: Exits the switch block after a case is matched (prevents fall-through to other cases).
default: Optional block that runs if no case matches the expression.
3. How the switch Statement Works
The switch statement compares the expression with each case. If a match is found, the corresponding block of code is executed, and the break statement ensures that the program exits the switch block. If no case matches, the default block is executed, if provided.
Example 1: Basic switch Statement
public class Main {
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;
default:
System.out.println("Invalid day");
}
}
}
Output:
Wednesday
In this example, the value of day is 3, which matches the third case, so “Wednesday” is printed.
4. Using break and default in switch
break: The break statement terminates the switch block once a matching case is executed. Without break, the program will continue to execute the subsequent cases, leading to fall-through.
Example 2: Fall-Through Without break
public class Main {
public static void main(String[] args) {
int day = 2;
switch (day) {
case 1:
System.out.println("Monday");
case 2:
System.out.println("Tuesday");
case 3:
System.out.println("Wednesday");
default:
System.out.println("Invalid day");
}
}
}
Output:
Tuesday Wednesday Invalid day
Here, since there’s no break, the code “falls through” to the subsequent cases after matching day = 2, leading to unexpected output.
default: The default case runs when none of the case values match the expression.
Example 3: Using default Case
public class Main {
public static void main(String[] args) {
int day = 7;
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
default:
System.out.println("Invalid day");
}
}
}
Output:
Invalid day
Here, the value of day doesn't match any of the cases, so the default case is executed.
5. Using switch with Strings (Java 7 and above)
Starting from Java 7, you can use switch with String values, which was not possible in earlier versions.
Example 4: switch with Strings
public class Main {
public static void main(String[] args) {
String fruit = "apple";
switch (fruit) {
case "apple":
System.out.println("Fruit is apple");
break;
case "banana":
System.out.println("Fruit is banana");
break;
default:
System.out.println("Unknown fruit");
}
}
}
Output:
Fruit is apple
In this example, the value of fruit is “apple”, which matches the first case.
6. Using switch with Enums
Enums are a good fit for the switch statement, as they represent a set of predefined constants. Using enums with switch can make your code more readable and robust.
Example 5: switch with Enums
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
public class Main {
public static void main(String[] args) {
Day today = Day.WEDNESDAY;
switch (today) {
case MONDAY:
System.out.println("It's Monday");
break;
case WEDNESDAY:
System.out.println("It's Wednesday");
break;
case FRIDAY:
System.out.println("It's Friday");
break;
default:
System.out.println("Not a special day");
}
}
}
Output:
It's Wednesday
Here, the enum Day is used in the switch statement, making it more readable when handling multiple constants.
7. Nested switch Statements
You can nest switch statements within each other, but it's generally advisable to avoid deep nesting for readability reasons.
Example 6: Nested switch Statement
public class Main {
public static void main(String[] args) {
int outerVar = 1;
int innerVar = 2;
switch (outerVar) {
case 1:
System.out.println("Outer: Case 1");
switch (innerVar) {
case 2:
System.out.println("Inner: Case 2");
break;
case 3:
System.out.println("Inner: Case 3");
break;
}
break;
case 2:
System.out.println("Outer: Case 2");
break;
}
}
}
Output:
Outer: Case 1 Inner: Case 2
This example demonstrates a nested switch structure where outerVar and innerVar control different layers of the decision-making.
8. Best Practices for Using switch
Use enums or constants: Enums and constants make your code more readable and prevent errors from using arbitrary values.
Avoid fall-through behavior: Ensure that each case block ends with a break unless you explicitly want fall-through behavior.
Use default for safety: Always include a default case to handle unexpected values, even if you don’t expect it to run.
9. Limitations of the switch Statement
Limited types: switch only supports int, byte, short, char, String, and enum. It doesn't support types like double, float, or boolean.
Duplicate cases: You cannot have duplicate case labels within the same switch statement. Doing so will cause a compilation error.
Conclusion
The switch statement in Java is a powerful control structure for handling multiple conditions based on a single variable. It provides a clear and concise way to deal with multiple possible values without using lengthy if-else chains.
By using switch with types like String and enums, you can write cleaner and more maintainable code.
Always be cautious with fall-through behavior and use the default case to handle unexpected values.