switch 语句是 Java 中一个多路分支控制结构，它根据一个变量的值来决定执行哪一段代码，它就像是 if-else if-else 结构的一种更清晰、更高效的替代方案,特别是在处理多个离散值时。

switch 语句的基本语法

一个基本的 switch 语句结构如下：

switch (expression) {
    case value1:
        // 当 expression 的值等于 value1 时，执行这里的代码
        break; // 可选，但强烈推荐
    case value2:
        // 当 expression 的值等于 value2 时，执行这里的代码
        break; // 可选，但强烈推荐
    case value3:
        // 当 expression 的值等于 value3 时，执行这里的代码
        break; // 可选，但强烈推荐
    default:
        // expression 的值不匹配任何一个 case，则执行这里的代码
        break; // 可选，但强烈推荐
}

语法要点解析：

1. switch (expression):

   • expression 是一个表达式,其结果会被计算出来。
   • 在 Java 7 之前，expression 的类型只能是 byte, short, char, int。
   • 从 Java 7 开始，expression 的类型也可以是 String 和 枚举 (Enum) 类型。
   • 从 Java 14 开始，expression 也可以是 包装类 (如 Integer, Character) 和 枚举 类型。

2. case value::

   • value 必须是一个常量或常量表达式。
   • value 的类型必须与 switch 表达式的类型兼容（可以自动向上转型）。
   • 每个 case 的 value 必须是唯一的,不能重复。
   • case 语句只是一个，当匹配到时，程序会从这个标签开始执行，并继续向下执行，直到遇到 break 语句或 switch 语句的末尾，这被称为 "贯穿" (fall-through)。

3. break;:

   
   （图片来源网络，侵删）
   • break 语句的作用是立即终止 switch 语句的执行，跳出 switch 结构。
   • 如果没有 break，程序会继续执行下一个 case 的代码，即使它的 value 也不匹配，这通常是一个 bug，但有时会被有意利用（见下文）。

4. default::

   • default 是一个可选的“默认”分支。
   • expression 的值不匹配任何一个 case 的 value，程序就会执行 default 分支中的代码。
   • default 分支可以放在 switch 语句的任何位置,但通常放在最后。

switch 的工作流程

1. 计算 switch 后面的 expression 的值。
2. 将计算出的值与每个 case 后面的 value 进行比较。
3. 如果找到第一个匹配的 case，程序就从该 case 处开始执行代码。
4. 如果没有找到任何匹配的 case，程序就执行 default 分支（如果存在）。
5. 如果没有 break 语句，程序会继续执行下一个 case 的代码，直到遇到 break 或 switch 结束。

代码示例

示例 1：基本用法（带 break）

这是最常见、最推荐的使用方式，可以避免意外的“贯穿”。

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;
        switch (day) {
            case 1:
                dayName = "Monday";
                break;
            case 2:
                dayName = "Tuesday";
                break;
            case 3:
                dayName = "Wednesday";
                break;
            case 4:
                dayName = "Thursday";
                break;
            case 5:
                dayName = "Friday";
                break;
            case 6:
                dayName = "Saturday";
                break;
            case 7:
                dayName = "Sunday";
                break;
            default:
                dayName = "Invalid day";
                break;
        }
        System.out.println("The day is: " + dayName); // 输出: The day is: Wednesday
    }
}

示例 2：“贯穿” (Fall-through) 的特性

虽然不常见，但有时可以利用“贯穿”特性来简化代码，当多个 case 执行相同的操作时。

public class SwitchFallThrough {
    public static void main(String[] args) {
        int month = 2;
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println("This month has 31 days.");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println("This month has 30 days.");
                break;
            case 2:
                System.out.println("This month has 28 or 29 days.");
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        // 输出: This month has 28 or 29 days.
    }
}

示例 3：使用 String 类型 (Java 7+)

public class SwitchWithString {
    public static void main(String[] args) {
        String fruit = "Apple";
        switch (fruit) {
            case "Apple":
                System.out.println("Apples are red or green.");
                break;
            case "Banana":
                System.out.println("Bananas are yellow.");
                break;
            case "Orange":
                System.out.println("Oranges are orange.");
                break;
            default:
                System.out.println("Unknown fruit.");
                break;
        }
        // 输出: Apples are red or green.
    }
}

switch 表达式 (Java 14+)

从 Java 14 开始，switch 不仅可以作为语句，还可以作为表达式使用，可以直接返回一个值，这大大简化了代码，并减少了 break 的使用。

主要特性：

1. 可以直接赋值：switch 可以直接将结果赋给一个变量。
2. yield 关键字：在 switch 表达式中，使用 yield 来返回一个值，而不是 break。
3. 箭头 ->：推荐使用箭头 -> 来分隔 case 标签和执行代码，它会自动处理 break，防止“贯穿”，使代码更安全、更简洁。

示例 4：switch 表达式

public class SwitchExpressionExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;
        // 使用 switch 表达式 (Java 14+)
        dayName = switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            case 4 -> "Thursday";
            case 5 -> "Friday";
            case 6 -> "Saturday";
            case 7 -> "Sunday";
            default -> "Invalid day";
        };
        System.out.println("The day is: " + dayName); // 输出: The day is: Wednesday
    }
}

示例 5：switch 表达式与 yield

case 分支需要多行代码，可以使用大括号 ，并在其中使用 yield 返回值。

public class SwitchExpressionWithYield {
    public static void main(String[] args) {
        int score = 85;
        String grade;
        grade = switch (score / 10) {
            case 10, 9 -> {
                System.out.println("Excellent!");
                yield "A";
            }
            case 8 -> "B";
            case 7 -> "C";
            case 6 -> "D";
            default -> {
                System.out.println("Failed.");
                yield "F";
            }
        };
        System.out.println("Grade: " + grade);
        // 输出:
        // Excellent!
        // Grade: A
    }
}

switch vs. if-else if-else

• 当你需要根据一个变量的具体值（而不是一个范围或复杂条件）来执行不同代码块时，优先使用 switch。
• 当你的条件涉及范围（如 score > 90）、布尔逻辑（如 isLogged && isAdmin）或复杂的表达式时，使用 if-else if-else。

希望这份详细的解释能帮助你完全理解 Java 中的 switch 语句！