What is Switch Statement
The switch statement assesses the value of an expression.. Match the value of the expression with a range of case clauses. Executes statements that match the first case clause until a break statement is encountered.
In simple terms, the Java switch statement executes an instruction based on several conditions. This statement is similar to an if-else-if ladder statement. It offers a straightforward method that controls the execution to various sections of code based on the expression’s value. The expression is fundamentally a byte, short, char, or int primitive data type. The primary goal of this evaluation is to figure out whether variables are equivalent to numerous values.
A few things to remember:
- One or N cases values can be used for a switch expression.
- Switch expression type is the only type of case value that can be used. The case value is required to be either literal or constant. Variables are not allowed by it.
- The case values must be distinct. When duplicated, it results in a compilation error..
- The Java switch statement allows for the expression to be of type byte, short, int, long (including its Wrapper type), enums, and chains.
- The case value may have a default labeling that is optional.
How Java Switch Statements works :
- The switch expression is evaluated once.
- The value of the expression is compared with the values of each case.
- If there is a match, the associated block of code is executed.
- The break and default keywords are optional, and will be described later in this chapter
The switch statement is a control flow construct used to make decisions based on the value of an expression. It provides an alternative way to write multiple if-else statements when you have several possible cases to handle.
Syntax for switch statement:
switch (expression) {
case value1:
// Code to execute when the expression is equal to value1
break;
case value2:
// Code to execute when the expression is equal to value2
break;
//More cases can be added as needed
default:
// Code to execute when none of the cases match the expression
}
Explanation:
- switch (expression): Evaluate a value or expression.
- case value1: If the value matches value1, proceed.
- break; : Stop the switch after value1 case.
- case value2: If the value matches value2, proceed.
- break; : Stop the switch after value2 case.
- // More cases can be added as needed: Add more cases if needed.
- default: If no match, proceed with default code.
Flowchart of switch Statement
Here’s an example of a simple switch statement that converts numeric values:
public class Switch {
public static void main(String[] args) {
int number = 3;
switch (number) {
case 1:
System.out.println("one");
break;
case 2:
System.out.println("Two");
break;
case 3:
System.out.println("Three");
break;
default:
System.out.println("Other");
break;
}
}
}
Output:
Three
Explanation:
- public class Switch { : Starts a Java class named “Switch”.
- public static void main(String[] args) { : Begins the main part of the program.
- int number = 3; : Sets the value of a number variable to 3.
- switch (number) { : Checks the value of the number variable.
- case 1: – If the number is 1:
- System.out.println(“one”); – Print “one” to the screen.
- break; – Stop checking cases.
- case 2: – If the number is 2:
- System.out.println(“Two”); – Print “Two” to the screen.
- break; – Stop checking cases.
- case 3: – If the number is 3:
- System.out.println(“Three”); – Print “Three” to the screen.
- break; – Stop checking cases.
- default: – If none of the cases match:
- System.out.println(“Other”); – Print “Other” to the screen.
- break; – Stop the switch.
- } : Ends the switch.
- } : Ends the main method.
- } : Ends the class.
The break keyword in Switch:
The break keyword is used within the switch statement to terminate the execution of the switch block. When Java encounters a break statement, it immediately exits the switch block, and the program continues to execute the code after the switch statement. It prevents fall-through behavior, which means without a break, the program will continue executing subsequent case blocks after the matching one, even if their conditions are not true.
Here’s an example to illustrate the usage of break:
public class Switch {
public static void main(String[] args) {
int dayOfWeek = 3;
switch (dayOfWeek) {
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("other day");
break;
}
}
}
Output:
Wednesday
Explanation:
- public class Switch { : Starts a class named “Switch“.
- public static void main(String[] args) { : The main part of the program begins.
- int dayOfWeek = 3; : Sets the day of the week as “Wednesday” (3).
- switch (dayOfWeek) { : Checks the day of the week.
- case 1: – If it’s 1 (Monday):
- System.out.println(“Monday”); – Prints “Monday“.
- break; – Stops checking cases.
- case 2: – If it’s 2 (Tuesday):
- System.out.println(“Tuesday”); – Prints “Tuesday“.
- break; – Stops checking cases.
- case 3: – If it’s 3 (Wednesday):
- System.out.println(“Wednesday”); – Prints “Wednesday“.
- break; – Stops checking cases.
- default: – If none match:
- System.out.println(“other day”); – Prints “other day“.
- break; – Stops the switch.
- } : Ends the switch.
- } : Ends the main method.
- } : Ends the class.
The default keyword in Switch:
The default keyword is used to specify a block of code that is executed when none of the case values match the value of the expression being evaluated. It provides a fallback option for situations where none of the defined cases apply. The default case is optional, and you can omit it if you don’t need to handle cases that don’t match the specified values.
Here’s an example:
public class Switch {
public static void main(String[] args) {
int dayOfWeek = 7;
switch (dayOfWeek) {
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("Weekend day");
break;
}
}
}
Output:
Weekend day
Explanation:
- public class Switch { : Starts a class named “Switch“.
- public static void main(String[] args) { : The main part of the program begins.
- int dayOfWeek = 7; – Sets the day of the week to 7 (which might represent Sunday in this context).
- switch (dayOfWeek) { – Checks the value of the day of the week.
- case 1: – If the day is 1 (Monday):
- System.out.println(“Monday”); – Prints “Monday“.
- break; – Stops checking cases.
- case 2: – If the day is 2 (Tuesday):
- System.out.println(“Tuesday”); – Prints “Tuesday“.
- break; – Stops checking cases.
- case 3: – If the day is 3 (Wednesday):
- System.out.println(“Wednesday”); – Prints “Wednesday“.
- break; – Stops checking cases.
- default: – If none of the above cases match:
- out.println(“Weekend day”); – Prints “Weekend day“.
- break; – Stops the switch.
- } : Ends the switch.
- } : Ends the main method.
- } : Ends the class.
