Control Structures in Java

Java Control Structures

Creating resources for teaching Java Control Structures involves crafting content that clearly conveys the concept's importance and applications within the language. Below, you'll find a structured approach to defining the learning objective, topics covered, and an introduction for Java Control Structures. This structure aims to provide students with a solid foundation for understanding and applying Java's conditional statements and loops.

Learning Objective

By the end of this module, students will be able to:

Understand and apply Java's control structures effectively in their programming projects.
Gain proficiency in using conditional statements, loops, and jump statements to control the flow of execution in a Java program, enabling them to write more efficient, readable, and manageable code.
Apply these control structures to solve real-world problems through programming.

Topics Covered

Introduction to Control Structures: Understanding the importance of control structures in programming.
Conditional Statements: Detailed exploration of if, if-else, switch, and nested conditional statements.
Looping Constructs: Comprehensive coverage of for, while, and do-while loops, including their syntax, flow of execution, and practical use cases.
Jump Statements: Understanding the use of break, continue, and return statements to alter the flow of control.
Nested Loops and Conditions: Learning how to combine loops and conditional statements to solve complex problems.
Practical Applications of Control Structures: Demonstrating the use of control structures in data processing, user input handling, and implementing algorithms.
Advanced Topics: Introduction to the concept of recursion as a form of control flow.

Introduction

Control structures are fundamental to programming in Java, allowing developers to dictate the flow of execution in their programs. These structures enable the performance of tasks in a controlled manner, such as making decisions (if, switch), repeating operations (for, while, do-while), and altering the execution flow (break, continue, return). Understanding and applying these constructs is crucial for creating efficient and effective programs. This module will explore the various control structures provided by Java, offering students the knowledge and skills to implement them in real-world programming scenarios. Through practical examples and exercises, learners will see how control structures influence the behaviour of their code, enabling complex decision-making, repetitive tasks, and more dynamic and responsive programs.

Understanding Program Execution and Control

In programming, the sequence in which code executes typically follows the order in which it's written. This sequential flow of control is straightforward but needs more flexibility for decision-making processes, such as validating input or choosing between alternative actions. Control structures introduce the ability to deviate from this linear execution path, offering a way to implement decision-making by evaluating conditions and determining the course of action based on those evaluations.

The "flow of control" refers to the order in which individual statements, instructions, or function calls are executed or evaluated within a computer program. In the simplest case, code executes sequentially from the top down, with each statement running one after the other as they appear in the script or source code. This sequential flow represents the default behaviour of most programming environments, guiding the basic structure of how programs are written and understood.

"Control structures", on the other hand, are programming constructs that alter the flow of control based on specified conditions or by introducing loops. They provide the means to make decisions (selection), repeat operations (iteration), and break the linearity of the program execution, thereby offering a mechanism to execute code blocks conditionally or repeatedly. Control structures are fundamental to programming, enabling complex behaviours and logic to be implemented within the software. They include conditional statements like if and switch, which allow programs to choose different paths of execution based on boolean conditions or expressions, and loops like for, while, and do-while, which enable repeated execution of a code block until a certain condition is met or no longer holds true.

Together, the flow of control and control structures form the backbone of programming logic, allowing developers to create dynamic, efficient, and responsive applications. Through control structures, programmers can harness the computational power of the CPU more effectively, directing the program's execution flow in a way that handles a wide array of tasks, from simple decision-making to complex data processing and beyond.

The simplest form of control structure is the if statement, which allows for conditional execution based on the truthfulness of a specified condition. This condition is presented as an assertion, a statement that can either be true or false. If the assertion is true, a certain block of code executes; if false, another block may execute instead. This capability is fundamental for tasks like input validation, where the program must decide between multiple paths (e.g., proceeding with a calculation or displaying an error message).

Java supports several types of control structures, including:

Sequential Control: The default mode where statements execute one after the other.
Selection (Branching) Control Structures: These include if, if-else, and switch statements, allowing the program to choose between different paths based on conditions.
Logical Expressions: Used to form conditions in control structures, involving boolean values (true or false) and relational operators (e.g., ==, !=, <, >).

Control structures are essential for creating dynamic and flexible programs capable of responding to varying inputs and conditions. The control structures are better understood when we understand what these structures control. Programmers use a rich set of instructions and apply programming logic in developing solutions. In this course, we are using Java to achieve this control.

The following flow chart demonstrates the internal architecture of a digital computer.

graph TD
    subgraph CPU [Central Processing Unit]
        ALU[Arithmetic Logic Unit]
        CU[Control Unit]
        MU["Memory Unit 
 (Random Access Memory)"]
    end

    subgraph Storage ["Storage (Persistent Memory)"]
        HD[Hard Drive]
        SSD[Solid State Drive]
    end

    subgraph IP [Input/Output Devices]
        Keyboard
        Mouse
        Monitor
        Printer
    end

    ALU <--> CU
    ALU <-.-> MU
    CU <--> MU
    CU <--> Storage
    IP <--> CU

The flow chart underscores the importance of the CPU, particularly the Control Unit, in orchestrating the flow of information and execution of instructions within a computer. Control structures in programming directly influence how these components interact. Conditional statements, loops, and function calls dictate the operations performed by the ALU, the flow of data between the Memory Unit and the CPU, and how input/output operations are handled. Understanding the interplay between these components and how they relate to control structures in programming is crucial for optimising program performance and resource utilisation.

Program control refers to the mechanisms within a programming language that allow the flow of execution to be altered. This can include conditional statements, loops, and function calls, which can change the linear progression of instruction execution based on certain conditions or repetitions. The modification of program control is essential in developing dynamic and efficient software. It allows programmers to write code that can handle different inputs and situations flexibly, perform repetitive tasks without redundancy, and manage complex data structures more effectively.

Program control structures are utilised wherever decision-making, repetition, or modular code execution is required. This includes algorithms for data processing, user input handling, graphical user interface updates, and many other areas where dynamic behaviour is needed.

Modifying program execution is critical both during the development phase, to implement the desired logic and functionality, and after deployment, to address bugs, improve performance, or add new features. Understanding when and where to modify program control is a key skill for developers, affecting the software's effectiveness, efficiency, and maintainability.

The relationship between control structures in programming languages like Java and the internal workings of a computer can be understood by exploring how computers execute instructions and make decisions at the hardware level, especially in the context of the Central Processing Unit (CPU) and its control unit.

Sequential Execution and the Program Counter

At the most basic level, a computer executes instructions sequentially. This is managed by the program counter (PC), a register in the CPU that keeps track of the memory address of the next instruction to be executed. After each instruction is executed, the PC is incremented to point to the next instruction in memory, following the sequence laid out by the program. This mirrors the concept of sequential control in programming, where statements are executed one after the other in the order they appear in the code.

Branching and Conditional Execution

Control structures such as if statements and loops introduce non-sequential execution flows, allowing software to make decisions and repeat actions based on conditions. Internally, this is implemented through branching instructions that alter the value of the program counter based on the outcome of conditional tests.

Conditional Branching: When a program executes an if statement, the CPU evaluates the condition through a series of arithmetic and logical operations. Based on the result (true or false), the control unit may alter the program counter to jump to a different part of the program, skipping over blocks of code or executing alternative sections. This is analogous to the way if and else statements work at the software level.
Loops: For loops and while loops, the control structure involves repeatedly evaluating a condition and, as long as the condition remains true, redirecting the program counter back to the start of the loop block, effectively creating a cycle of repeated execution. This is managed internally by looping constructs and conditional branches that adjust the program counter accordingly.

Logical Operations and the ALU

The Arithmetic Logic Unit (ALU) of the CPU performs the logical operations needed to evaluate the conditions within control structures. It processes the binary data associated with these conditions (e.g., comparing two numbers to see if one is greater than the other) and determines the outcome of logical expressions. The result of these operations can then influence the control flow, directing which part of the program to execute next.

Integration with Memory and Registers

Control structures not only involve the CPU's control unit and ALU but also interact closely with memory and registers. Variables and conditions evaluated within these structures are stored in memory and processed through registers, with the CPU moving data between these components as needed to perform comparisons and execute conditional logic.

Control structures in programming abstract the underlying hardware mechanisms that manage the flow of execution within a computer. They provide a high-level way to control the sequential execution inherent to computer operation, introduce decision-making capabilities, and enable complex, dynamic behavior in software. This bridge between the abstract logic of programming and the concrete mechanisms of computer hardware is a fundamental aspect of computer science, allowing programmers to effectively harness the computational power of the CPU to solve problems and perform tasks.

graph TD
    CS["Control Structures"]
    CPU[("CPU")]
    Memory["Memory"]
    Registers["Registers"]

    CS -->|Manage Flow| CPU
    CPU -->|Interact With| Memory
    CPU -->|Use| Registers
    Memory -->|Store Variables| CS
    Registers -->|Process Data| CS

    class CS abstract;

A computer program is a set of instructions that a computer follows to perform specific tasks. These instructions are executed by the computer's central processing unit (CPU), which reads and processes them sequentially from the program's start to its end unless directed otherwise by the program's control structures.

By understanding and practising the contents of this page, the reader will have a strong grasp of the significance of control structures in programming, understand their syntax and usage, and apply them to solve problems.

Introduction to Conditional Statements

Conditional statements are a fundamental aspect of programming languages, providing the means to make decisions and control the flow of a program's execution based on certain conditions. These statements evaluate boolean expressions — logical statements that are either true or false — and determine the subsequent path the program will take. The ability to perform different actions under different conditions is essential for creating dynamic, flexible, and efficient software.

The significance of conditional statements in programming cannot be overstated. They allow programmers to write code that can adapt to varying inputs and environments, leading to programs that are not only more robust and error-resistant but also capable of complex decision-making processes. Whether it's validating user input, making calculations based on dynamic data, or navigating through complex algorithms, conditional statements provide the structure and flexibility needed to achieve these tasks effectively.

sequenceDiagram
    participant P as Program
    participant C as Condition
    participant TB as True Block
    participant FB as False Block

    P->>+C: Evaluate Boolean Expression
    alt is True
        C->>+TB: Execute True Block
        TB-->>-P: End of True Block
    else is False
        C->>+FB: Optionally Execute False Block
        FB-->>-P: End of False Block
    end

At their core, conditional statements work by evaluating a boolean expression and then executing a specific block of code if the expression is true. If the expression is false, the program can either skip the block of code entirely or execute an alternative block if provided. This simple yet powerful mechanism is what enables programs to react and make decisions, simulating a form of "logic" that is crucial for solving real-world problems through software.

There are several types of conditional statements used in programming, including but not limited to if, if-else, else-if ladders, and switch statements. Each serves a specific purpose and offers different ways to structure decision-making processes within a program. Understanding how to effectively use these statements is key to mastering programming and developing sophisticated software solutions.

The `if` Statement in Java

An if statement is one of the most basic control structures in programming, allowing a program to execute a certain block of code based on whether a condition is true or not. If the condition evaluates to true, the program will execute the block of code within the if statement. If the condition is false, the program skips this block and continues executing the rest of the code.

Working of an `if` Statement: Sequence Diagram

    sequenceDiagram
        participant P as Program
        participant C as Condition
        participant B as Block of Code

        P->>+C: Evaluate Condition
        alt is True
            C->>+B: Execute Block of Code
            B-->>-P: Continue Execution
        else is False
            C-->>-P: Skip Block of Code
        end

The syntax for the if statement in Java is straightforward and follows this basic structure:

if (condition) {
    // block of code to be executed if the condition is true
}

Explanation:

if: This keyword starts the declaration of an if statement.
(condition): The condition is a boolean expression that evaluates to either true or false. This expression is placed inside parentheses.
{}: The block of code inside the curly braces is executed if, and only if, the condition evaluates to true. If the condition is false, the program skips this block of code and continues with the next statement after the if block.

The condition in an if statement can be any boolean expression, such as a comparison between variables, the result of logical operations, or even direct boolean values (true or false).

Example:

Consider you have a variable age and you want to check if the person is eligible to vote (assuming the eligible age is 18 or older):

int age = 20;
if (age >= 18) {
    System.out.println("Eligible to vote.");
}

In this example:

The condition is age >= 18.
If age is 18 or more, the condition is true, and the program prints "Eligible to vote."
If age is less than 18, the condition is false, and the if block is skipped, meaning nothing is printed in this scenario.

The if statement is a fundamental control structure in Java that allows your programs to make decisions and execute code conditionally, making it essential for creating dynamic and responsive applications.

Java Code Example: Number Guessing Game

The following Java code illustrates a simple number guessing game using an if statement:

    import java.util.Scanner;

    public class GuessingGame {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int secretNumber = 7; // Secret number to guess
            System.out.print("Guess the number (1-10): ");
            int userGuess = scanner.nextInt();

            if(userGuess == secretNumber) {
                System.out.println("Congratulations! You've guessed the correct number.");
            } else {
                System.out.println("Sorry, wrong number. Try again!");
            }
        }
    }

Flowchart: Number Guessing Game Logic

    graph TD;
        A([Start]) --> B[User Guesses Number];
        B --> C{Is Guess Correct?};
        C -->|Yes| D[Display Congratulations];
        C -->|No| E[Display Try Again Message];
        D --> F([End]);
        E --> B;

Console Output:

Guess the number (1-10): 7
Congratulations! You've guessed the correct number.

Guess the number (1-10): 5
Sorry, wrong number. Try again!

User guesses the correct number:
User guesses the wrong number:

Do's and Don'ts for `if` and `if-else` Statements

Do's:

Use Braces for Clarity: Always use braces {} around the blocks of code following if and if-else statements, even if there is only one statement to execute. This enhances readability and reduces the risk of errors when more lines are added later.
```
// Correct
if (condition) {
    System.out.println("Condition is true");
}
```
Be Explicit with Conditions: Make your conditions as clear as possible. Use boolean variables directly if they express the condition you're testing for.
```
// Assume 'isValid' is a boolean
if (isValid) { /*...*/ }
```
Maintain Logical Sequence: Ensure that conditions in an if-else if ladder are arranged from the most specific to the most general to avoid missing out on specific conditions.
```
if (score > 90) {
    // Excellent
} else if (score > 75) {
    // Good
} else {
    // Needs Improvement
}
```

Don'ts:

Avoid Unnecessary Complexity: Don’t nest if statements deeply when not necessary, as it can make the code hard to read and maintain. Try to simplify conditions or use switch-case statements if appropriate.
Don't Omit Braces in Multi-line Blocks: Failing to use braces in multi-line blocks after if or else statements can lead to logical errors where only the first line is considered part of the conditional block.
```
// Incorrect
if (condition)
    System.out.println("First line");
    System.out.println("This always executes, which might not be intended.");
```
Don't Use Semicolon After Condition: Placing a semicolon immediately after the if condition mistakenly terminates the statement, leading the subsequent block to always execute, disregarding the condition.
```
// Incorrect
if (condition);
{
    // This block always executes, ignoring the condition above.
}
```

Common Mistakes and Handling Errors

Misplaced Semicolons: As mentioned, a semicolon after the condition of an if statement can cause the block to always execute. Always check for unnecessary semicolons that can alter the logical flow.
Incorrect Logical Order: Placing broader conditions before more specific ones in an if-else if ladder can cause some conditions to be skipped. Always start with the most specific conditions.
Equality vs. Assignment: Using = (assignment) instead of == (equality) in conditions is a common mistake that can lead to unexpected behavior.

Logical Direction and Handling with Examples

Correct Sequence in Conditionals: Ensure the sequence of conditions in an if-else if ladder is logically ordered from most specific to least specific.

// Example of correct logical sequence
int number = 25;
if (number == 25) {
    System.out.println("Number is 25");
} else if (number > 20) {
    System.out.println("Number is greater than 20");
} else {
    System.out.println("Number is 20 or less");
}

In the example above, if the condition number > 20 were placed before number == 25, the specific check for number == 25 would never execute for the value 25, because the broader condition number > 20 would be true first.

By adhering to these do's and don'ts and understanding common mistakes, programmers can effectively utilise if and if-else statements to create clearer, more efficient, and error-free code.

The `switch` Statement in Java

The switch statement in Java provides an efficient way to dispatch execution to different parts of code based on the value of an expression. Unlike if-else statements, which evaluate boolean expressions, the switch statement compares the value of a variable or an expression to a series of constants and executes the block of code corresponding to the matching case.

Working of a `switch` Statement: Sequence Diagram

    sequenceDiagram
        participant P as Program
        participant S as Switch
        participant C1 as Case 1
        participant C2 as Case 2
        participant D as Default

        P->>+S: Evaluate Expression
        alt is Case 1
            S->>+C1: Execute Case 1
            C1-->>-P: Continue Execution
        else is Case 2
            S->>+C2: Execute Case 2
            C2-->>-P: Continue Execution
        else is Default
            S->>+D: Execute Default
            D-->>-P: Continue Execution
        end

Syntax of the `switch` Case Statement in Java

The switch statement in Java evaluates an expression once and compares its value against multiple case labels. If a matching case is found, the code associated with that case executes. The syntax is as follows:

switch (expression) {
    case value1:
        // Block of code to be executed if expression equals value1
        break;
    case value2:
        // Block of code to be executed if expression equals value2
        break;
    // You can have any number of case statements
    default:
        // Block of code to be executed if expression doesn't match any case
}

expression: This is evaluated once at the beginning of the switch statement. The result is then compared with the values of each case.
case value: These are the specific values that expression is compared to. If expression matches case value, the code block following that case executes.
break: This keyword is used to exit the switch statement. Without it, execution will continue into the next case, known as "fall-through".
default: This is an optional case that executes if none of the case values match the expression. There can only be one default block in a switch statement.

Detail Explanation

default Keyword: The default case in a switch statement acts as a catch-all for any value of expression that does not match any case label. It's similar to the "else" part of an if-else chain but is optional.

When is the `switch` case ideally chosen?

The switch statement is particularly useful when you have a single variable or expression to test against a series of constant values. It is ideally chosen in scenarios where:

Multiple conditions depend on the value of a single variable or expression.
The value being tested is an enum, an integer, or a String (from Java 7 onwards).
You are comparing the same variable/expression to multiple constant values.

Instances where the `switch` case is not a good choice:

Conditions based on ranges: Since switch cases require constant values, they are not suitable for range-based conditions without awkward workarounds.
Testing conditions that involve multiple variables: If the decision logic depends on more than one variable, switch may not be the best choice.
Complex logical conditions: switch cannot evaluate complex conditions involving logical operators directly within case labels.

Where will `switch` be a good case to use?

Menu selections: Handling user input where each option corresponds to a constant value.
State machines: Managing state transitions where each state can be represented as a constant value.
Handling predefined options: Such as command-line flags, configuration settings, or specific user roles that map directly to case labels.

The switch statement simplifies the code and improves readability when testing a variable against a series of constants. It can lead to more concise and organized code compared to an equivalent series of if-else statements, especially when dealing with enumerated values or strings that represent a limited set of possible values.

Java Code Example: Number Guessing Game with `switch`

Below is a Java code example that demonstrates the use of a switch statement in a number guessing game:

    import java.util.Scanner;

    public class GuessingGameSwitch {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.print("Guess a number between 1 and 3: ");
            int guess = scanner.nextInt();

            switch (guess) {
                case 1:
                    System.out.println("You guessed 1. Try again!");
                    break;
                case 2:
                    System.out.println("Correct! Number was 2.");
                    break;
                case 3:
                    System.out.println("You guessed 3. So close!");
                    break;
                default:
                    System.out.println("Invalid guess. Choose a number between 1 and 3.");
            }
        }
    }

Flowchart: Number Guessing Game Logic with `switch`

    graph TD;
        A[Start] --> B[Guess a Number];
        B --> C{Switch on Number};
        C -->|Case 1| D[You guessed 1. Try again!];
        C -->|Case 2| E[Correct! Number was 2.];
        C -->|Case 3| F[You guessed 3. So close!];
        C -->|Default| G[Invalid guess. Choose a number between 1 and 3.];
        D --> H[End];
        E --> H;
        F --> H;
        G --> H;

Sample Output

Guess a number between 1 and 3: 1
You guessed 1. Try again!

Guess a number between 1 and 3: 2
Correct! Number was 2.

Guess a number between 1 and 3: 3
You guessed 3. So close!

Guess a number between 1 and 3: 4
Invalid guess. Choose a number between 1 and 3.

For a guess of 1:
For the correct guess (2):
For a guess of 3:
For an invalid guess:

Do's and Don'ts for the `switch` Statement

Do's:

Use Braces for Each Case Block: Although not mandatory, it's good practice to use braces {} for the code block of each case for better readability and to avoid mistakes when adding more lines of code.
```
// Good practice
case 1: {
    System.out.println("Case 1");
    break;
}
```
Always Include the break Statement: To prevent fall-through (where execution moves to the next case block unintentionally), always include a break statement at the end of each case block, unless you intentionally want to group cases.
```
// Correct usage
case 1:
    System.out.println("Case 1");
    break;
```
Use default Case: Always include a default case to handle any unexpected values. This ensures that your switch statement always has a predictable outcome.
```
// Important for covering all possibilities
default:
    System.out.println("Default case");
```

Don'ts:

Don't Use Variables as Case Labels: Case labels must be constant expressions. Variables or runtime expressions are not allowed.
```
// Incorrect
int a = 10;
switch (x) {
    case a: // ERROR: variable 'a' cannot be used as a case label
        break;
}
```
Avoid Unnecessary Fall-Through: Unless intentionally grouping cases, avoid fall-through by forgetting to include a break statement. It can lead to bugs that are hard to detect.
```
// Potential mistake
case 1:
    System.out.println("Accidental fall-through?");
// Missing break statement
case 2:
    System.out.println("Case 2");
    break;
```
Don't Ignore the default Case: Failing to include a default case can leave unhandled conditions, which might lead to unpredictable behaviour or bugs.

Common Mistakes and Handling Errors

Misuse of the break Statement: One of the most common mistakes is forgetting to include a break after each case, leading to fall-through. Always review your switch statements to ensure that each case ends with a break, unless you have a good reason for wanting to fall through to the next case.
Incorrect Sequence in Cases: The sequence of cases doesn't affect the execution logic in a switch statement, unlike an if-else if ladder. However, organising cases logically or numerically can improve readability.
Using Non-Constant Expressions as Case Labels: Trying to use variables or non-constant expressions as case labels results in a compilation error. Only constant expressions, enum constants, or string literals (in Java 7 and later) are allowed.

Logical Direction of Handling with Examples

Intentional Fall-Through Example: In some situations, you might want multiple cases to execute the same block of code. In such cases, omitting the break statement can be intentional and useful.

switch (dayOfWeek) {
    case MONDAY:
    case TUESDAY:
    case WEDNESDAY:
        System.out.println("Midweek");
        break;
    default:
        System.out.println("Other days");
}

Here, MONDAY, TUESDAY, and WEDNESDAY share the same execution block intentionally.

By following these guidelines and being mindful of common pitfalls, you can effectively utilise the switch statement in Java to make your code more readable and maintainable.

flowchart TD
    A[Start] --> B{Day of Week}
    B -->|MONDAY| C[Midweek]
    B -->|TUESDAY| C
    B -->|WEDNESDAY| C
    B -->|OTHER| D[Other days]
    C --> E[End]
    D --> E

Control Structures in Java

Java Control Structures

Learning Objective

Topics Covered

Introduction

Understanding Program Execution and Control

Sequential Execution and the Program Counter

Branching and Conditional Execution

Logical Operations and the ALU

Integration with Memory and Registers

Introduction to Conditional Statements

The if Statement in Java

Working of an if Statement: Sequence Diagram

Explanation:

Example:

Java Code Example: Number Guessing Game

Flowchart: Number Guessing Game Logic

Console Output:

Do's and Don'ts for if and if-else Statements

Do's:

Don'ts:

Common Mistakes and Handling Errors

Logical Direction and Handling with Examples

The switch Statement in Java

Working of a switch Statement: Sequence Diagram

Syntax of the switch Case Statement in Java

Detail Explanation

When is the switch case ideally chosen?

Instances where the switch case is not a good choice:

Where will switch be a good case to use?

Java Code Example: Number Guessing Game with switch

Flowchart: Number Guessing Game Logic with switch

Sample Output

Do's and Don'ts for the switch Statement

Do's:

Don'ts:

Common Mistakes and Handling Errors

Logical Direction of Handling with Examples

The `if` Statement in Java

Working of an `if` Statement: Sequence Diagram

Do's and Don'ts for `if` and `if-else` Statements

The `switch` Statement in Java

Working of a `switch` Statement: Sequence Diagram

Syntax of the `switch` Case Statement in Java

When is the `switch` case ideally chosen?

Instances where the `switch` case is not a good choice:

Where will `switch` be a good case to use?

Java Code Example: Number Guessing Game with `switch`

Flowchart: Number Guessing Game Logic with `switch`

Do's and Don'ts for the `switch` Statement