What is a Switch Case in Java & How to Use It?

Imagine a vending machine. You press a specific code (a "case"), and it gives you a specific item. You don't have to check every single item one by one; you go directly to your choice. This is exactly what the switch case in Java does for your code. 

Instead of writing a long and messy chain of if-else if statements, the switch statement provides a clean and efficient way to execute different blocks of code based on a specific value.  

This guide will be your complete tutorial on how to use switch case in Java, breaking down the syntax with clear examples so you can start writing more organized code today. 

Improve your understanding of switch case in java with our online software engineering courses. Learn how to apply switch case in java, where to use across different industry applications!  

What is a switch case in Java?

Java supports three kinds of statements: expression statements for changing values of variables, calling methods and creating objects, declaration statements for declaring variables, and control-flow statements for determining the order of execution of statements.

If you're looking to master core Java concepts like the switch statement and build a strong foundation in programming, here are some top-rated courses from upGrad to help you get there: 

• AI-Driven Full-Stack Development Bootcamp 
• Master’s Degree in Artificial Intelligence and Data Science 
• Professional Certificate Program in Data Science and AI 

The Java switch case statement is a type of control-flow statement that allows the value of an expression or variable to change the control flow of program execution through a multi-way branch. In contrast to if-then and if-then-else statements, the Java switch statement has several execution paths. Switch case in Java works with short, byte, int, and char primitive data types. From JDK7, Java switch can also be used with String class, enumerated types, and Wrapper classes that wrap primitive data types such as Byte, Character, Integer, and Short.

The body of a switch case statement in Java is called a switch block. Every statement in the switch block is labelled using one or more cases or default labels. Hence, the switch statement evaluates its expression, followed by the execution of all the statements which follow the matching case label.

Given below is the syntax of the switch case statement:

// switch statement 

switch(expression)

{

   // case statements

   // values must be of same type of expression

   case value1 :

      // Statements

      break; // break is optional

   

   case value2 :

      // Statements

      break; // break is optional

   

   // We can have any number of case statements

   // below is default statement, used when none of the cases is true. 

   // No break is needed in the default case.

   default : 

      // Statements

}

Check out upGrad’s AI-Driven Full-Stack Development Bootcamp 

Example of the Java switch statement

The following Java code example declares an int named “month” whose value represents one of the 12 months of the year. The code uses the switch case statement to display the month’s name based on the month’s value.

public class SwitchExample {

    public static void main(String[] args) {

        int month = 6;

        String monthString;

        switch (month) {

            case 1:  monthString = “January”;

                     break;

            case 2:  monthString = “February”;

                     break;

            case 3:  monthString = “March”;

                     break;

            case 4:  monthString = “April”;

                     break;

            case 5:  monthString = “May”;

                     break;

            case 6:  monthString = “June”;

                     break;

            case 7:  monthString = “July”;

                     break;

            case 8:  monthString = “August”;

                     break;

            case 9:  monthString = “September”;

                     break;

            case 10: monthString = “October”;

                     break;

            case 11: monthString = “November”;

                     break;

            case 12: monthString = “December”;

                     break;

            default: monthString = “Invalid month”;

                     break;

        }

        System.out.println(monthString);

    }

}

Output: 
June

Purpose of break statement in Java switch case 

The break statement is an essential aspect of the Java switch case that terminates the enclosing switch statement. The break statement is required because without it, statements in the switch block would fall through. Thus, regardless of the expression of the succeeding case labels, all statements after the matching case label are sequentially executed until a break statement is encountered. 

The following code is an example to show a switch block falling through in the absence of the break statement.

public class SwitchExampleFallThrough {

    public static void main(String[] args) {

        java.util.ArrayList<String> futureMonths =

            new java.util.ArrayList<String>();

        int month = 6;

        switch (month) {

            case 1:  futureMonths.add(“January”);

            case 2:  futureMonths.add(“February”);

            case 3:  futureMonths.add(“March”);

            case 4:  futureMonths.add(“April”);

            case 5:  futureMonths.add(“May”);

            case 6:  futureMonths.add(“June”);

            case 7:  futureMonths.add(“July”);

            case 8:  futureMonths.add(“August”);

            case 9:  futureMonths.add(“September”);

            case 10: futureMonths.add(“October”);

            case 11: futureMonths.add(“November”);

            case 12: futureMonths.add(“December”);

                     break;

            default: break;

        }

        if (futureMonths.isEmpty()) {

            System.out.println(“Invalid month number”);

        } else {

            for (String monthName : futureMonths) {

               System.out.println(monthName);

            }

        }

    }

}

Output:
June

July

August

September

October

November

December

The above code displays the month of the year corresponding to the integer month and the months that follow. Here, the final break statement serves no purpose because the flow falls out of the switch statement. The use of the break statement is helpful because it makes the code less error-prone and modifications easier. The default section in the code handles all values not regulated by any of the case sections.

Java switch statement with multiple case labels

Switch statements in Java can have multiple case labels as well. The following code illustrates the same – here, the number of days in a particular month of the year is calculated.

class SwitchMultiple{

    public static void main(String[] args) {

        int month = 2;

        int year = 2020;

        int numDays = 0;

        switch (month) {

            case 1: case 3: case 5:

            case 7: case 8: case 10:

            case 12:

                numDays = 31;

                break;

            case 4: case 6:

            case 9: case 11:

                numDays = 30;

                break;

            case 2:

                if (((year % 4 == 0) && 

                     !(year % 100 == 0))

                     || (year % 400 == 0))

                    numDays = 29;

                else

                    numDays = 28;

                break;

            default:

                System.out.println(“Invalid month.”);

                break;

        }

        System.out.println(“Number of Days = “

                           + numDays);

    }

}

Output:
Number of Days = 29

Learn Online software development courses from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Nested Java switch case statements

A nested switch is when you use a switch as a part of the sequence of statements of an outer switch. In this case, there is no conflict between the case constants in the other switch and those in the inner switch because a switch statement defines its own block.

The following example demonstrates the use of nested Java switch-case statements:

public class TestNest {

public static void main(String[] args)

{

String Branch = “CSE”;

int year = 2;

switch (year) {

case 1:

System.out.println(“Elective courses : Algebra, Advance English”);

break;

case 2:

switch (Branch) // nested switch

{

case “CSE”:

case “CCE”:

System.out.println(“Elective courses : Big Data, Machine Learning”);

break;

case “ECE”:

System.out.println(“elective courses : Antenna Engineering”);

break;

default:

System.out.println(“Elective courses : Optimization”);

}

}

}

}

Output:
Elective courses: Big Data, Machine Learning

Use of strings in switch statements 

Beginning from JDK7, you can use a String object in the expression of a switch statement. The comparison of the string object in the switch statement’s expression with associated expressions of each case label is as if it was using the String.equals method. Also, the comparison of string objects in the switch statement expression is case-sensitive.

The following code example displays the type of game based on the value of the String named “game.” 

public class StringInSwitchStatementExample {  

    public static void main(String[] args) {  

        String game = “Cricket”;  

        switch(game){  

        case “Volleyball”: case”Football”: case”Cricket”:  

            System.out.println(“This is an outdoor game”);  

            break;  

        case”Card Games”: case”Chess”: case”Puzzles”: case”Indoor basketball”:  

            System.out.println(“This is an indoor game”);  

            break;  

        default:   

            System.out.println(“What game it is?”);  

        }  

    }  

}  

Output:
This is an outdoor game

Rules to remember when using Java switch statements

It would be best if you keep certain rules in mind while using Java switch statements. Following is a list of the same:

• The value for a case and the variable in the switch should have the same data type.
• Java switch statements do not allow duplicate case values.
• A case value should be literal or a constant. Variables are not allowed.
• The use of the break statement inside the switch terminates a statement sequence.
• The break statement is optional and omitting it will continue execution into the subsequent case.
• The default statement is also optional and can occur anywhere within the switch block. If it is not placed at the end, a break statement must be added after the default statement to skip the execution of the succeeding case statement. 

Conclusion 

The switch case in Java is a powerful and elegant tool for managing complex conditional logic. It provides a cleaner, more readable alternative to long if-else if chains, making your code easier to maintain and debug. 

This guide has shown you how to use switch case in Java effectively, from its basic syntax to modern enhancements like arrow cases and expressions. By mastering this fundamental control flow statement, you are taking a significant step toward writing more professional and efficient Java code. Keep practicing, and you'll find it an indispensable part of your programming toolkit. 

Way Forward

Java has unmatched popularity among programmers and developers and is one of the most in-demand programming languages today. Needless to say, budding developers and software engineers who want to upskill themselves for the ever-evolving job market need to get a stronghold over their Java skills.

If you want to kickstart your journey towards a promising career in software engineering, upGrad’s software development courses can make it possbile. 

Here are some additional courses that can boost your programming journey and prepare you for real-world development: 

• Executive Diploma in Data Science & AI 
• Node.js For Beginners 
• React.js For Beginners 
• JavaScript Basics from Scratch 
• Core Java Basics 

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software