7.7. Flow control (if, else, switch, loops): Break into switch

Flow control is a fundamental concept in programming, as it allows a program to make decisions and execute different blocks of code depending on certain conditions. In Java, flow control is mainly carried out through structures such as if, else, switch and loops (for, while, do-while). In this text, we will focus on a specific part of flow control: the use of break in a switch structure.

The switch statement is a way to simplify a series of if-elses when it comes to comparing a single variable with a series of constant values. The basic structure of a switch is as follows:

switch (variable) {
    case value1:
        // Block of code to be executed if variable == value1
        break;
    case value2:
        // Block of code to be executed if variable == value2
        break;
    // ...
    default:
        // Block of code to be executed if variable does not match any of the values
}

The role of break within each case (case) is fundamental. Without break, the program's flow of execution will continue to the next case, regardless of whether it matches the condition or not. This is known as "fall-through", and although it can be useful in some scenarios, it is generally undesirable. The break effectively tells the program to exit the switch and continue executing the code that follows the switch block.

A classic example of using the switch is to create an options menu:

int option = getUserInput(); // Hypothetical method that takes user input

switch (option) {
    case 1:
        System.out.println("You chose option 1.");
        break;
    case 2:
        System.out.println("You chose option 2.");
        break;
    case 3:
        System.out.println("You chose option 3.");
        break;
    default:
        System.out.println("Invalid option.");
}

In this example, if the user enters the number 1, the message "You chose option 1." will be displayed and the program will exit the switch. If break were omitted after case 1, the program would also execute the code under case 2 and so on, which would not be the case. desired behavior.

Now, let's consider an example where "fall-through" is used intentionally:

int month = getMonthNumber(); // Hypothetical method that returns the current month number

switch (month) {
    case 12:
    case 1:
    case 2:
        System.out.println("It's summer in the southern hemisphere.");
        break;
    case 3:
    case 4:
    case 5:
        System.out.println("It's autumn in the southern hemisphere.");
        break;
    // ... other cases for the other months
}

In the example above, the months of December, January and February share the same message that it is summer in the southern hemisphere. By omitting break after case 12 and case 1, we allow the program to continue executing until it encounters a break , in this case after case 2.

It is important to note that the intentional use of "fall-through" must be well documented to avoid confusion for anyone reading the code. In Java, it is common to add a comment, such as // fall through, to indicate that the omission of break is intentional.

Additionally, Java SE 12 introduced the ability to use the yield keyword to return values ​​from a switch, which can replace the use of break in some cases. This is part of switch expressions, which are a more modern and concise way of handling flow control using switches.

In summary, break is an essential component of the switch statement in Java, and its proper use is crucial to ensuring that program flow control works as expected. At the same time, "fall-through" can be a powerful tool when used consciously. As with many aspects of programming, code clarity and intent should always be prioritized to maintain program readability and maintainability.