Java从入门到放弃（十四）：switch多重选择

在Java中，switch语句是一种多分支选择结构，它允许根据表达式的值选择执行不同的代码块。switch语句特别适合于基于单个变量值进行多路分支的情况，比如用户选择不同的操作选项。

下面是一个使用switch语句的例子，演示了如何根据用户的输入选项执行不同的操作：

public class Main {
    public static void main(String[] args) {
        int option = 1; // 假设这是用户的输入选项
        switch (option) {
            case 1:
                System.out.println("选择了单人模式");
                break;
            case 2:
                System.out.println("选择了多人模式");
                break;
            case 3:
                System.out.println("退出游戏");
                break;
            default:
                System.out.println("无效的选项");
                break;
        }
    }
}

在这个例子中，switch语句根据变量option的值来执行匹配的case代码块。每个case后面跟着一个或多个执行语句，当匹配到相应的case时，这些语句将被执行。break关键字用于退出switch语句，防止执行后续的case代码块，这就是所谓的“case穿透性”。

如果option的值没有匹配到任何case，那么可以使用default子句来处理这种情况。例如，如果option的值为99，那么将执行default子句中的代码：

public class Main {
    public static void main(String[] args) {
        int option = 99;
        switch (option) {
            case 1:
            case 2:
            case 3:
                System.out.println("选择了一个有效的游戏模式");
                break;
            default:
                System.out.println("无效的选项，请输入1、2或3");
                break;
        }
    }
}

在这个例子中，如果option的值不是1、2或3，程序将输出“无效的选项，请输入1、2或3”。

需要注意的是，switch语句中的case标签后面跟着的是常量表达式，而不能是变量或者复杂的表达式。每个case代码块的末尾都应该有一个break语句，以防止执行其他case代码块，除非这是你想要的行为（例如，在某些情况下，你可能故意省略break以实现代码块的“穿透”）。然而，这通常是不推荐的做法，因为它可能会导致难以发现的逻辑错误。

尽管switch语句中的case分支顺序本身不影响程序的逻辑——因为每个case分支的末尾都使用了break语句来确保一旦匹配成功，执行流程就会跳出switch结构——但按照自然或逻辑顺序排列case分支仍然是一个好的编程习惯，这样做可以提高代码的可读性和维护性。

例如，下面的switch语句根据用户选择的选项执行不同的操作，每个case分支都以break结尾：

switch (option) {
    case 3:
        // 执行与选项3相关的操作
        break;
    case 2:
        // 执行与选项2相关的操作
        break;
    case 1:
        // 执行与选项1相关的操作
        break;
    default:
        // 处理未知选项的情况
        break;
}

此外，switch语句不仅可以用于基本数据类型，还可以用于字符串匹配。当switch的表达式是字符串时，它会比较字符串的内容是否相等。例如：

String fruit = "apple";
switch (fruit) {
    case "apple":
        System.out.println("选择了苹果");
        break;
    case "pear":
        System.out.println("选择了梨");
        break;
    case "mango":
        System.out.println("选择了芒果");
        break;
    default:
        System.out.println("未选择任何水果");
        break;
}

最后，switch语句还支持枚举类型，这使得switch语句在处理固定集合的常量值时变得更加强大和类型安全。关于枚举类型的使用，我们将在后续的讲解中详细介绍。

编译检查

当使用集成开发环境（IDE）编写Java代码时，IDE提供了许多有用的功能来帮助开发者避免常见的编程错误。其中之一就是编译检查功能，它可以自动检测代码中的潜在问题，包括switch语句中可能遗漏的break和default语句。

在Eclipse IDE中，你可以通过以下步骤启用这些检查：

1. 打开Eclipse IDE。
2. 选择菜单栏中的 “Preferences” 选项。
3. 在弹出的窗口中，展开 “Java” 部分。
4. 点击 “Compiler” 选项。
5. 选择 “Errors/Warnings” 部分下的 “Potential programming problems”。
6. 勾选 “‘switch’ is missing ‘default’ case” 以警告缺失default分支。
7. 勾选 “‘switch’ case fall-through” 以警告switch语句中的穿透问题。

在IntelliJ IDEA中，你可以按照以下步骤来设置编译检查：

1. 打开IntelliJ IDEA。
2. 选择 “Preferences” 或 “Settings”（取决于你的操作系统）。
3. 在设置窗口中，导航到 “Editor” -> “Inspections” -> “Java” -> “Control flow issues”。
4. 勾选 “Fallthrough in ‘switch’ statement” 以警告switch语句中的穿透问题。
5. 勾选 “‘switch’ statement without ‘default’ branch” 以警告没有default分支的switch语句。

一旦这些检查被启用，IDE将在你编写代码时实时检查switch语句，并在发现潜在问题时提供警告。这些警告将帮助你避免逻辑错误，确保你的switch语句按预期工作。例如，如果你忘记在switch语句的末尾添加break语句，或者没有为所有可能的情况提供一个default分支，IDE将会提醒你。这样的即时反馈可以显著提高代码质量和开发效率。

switch表达式

自Java 12起，switch语句得到了增强，引入了一种新的表达式语法，它允许使用模式匹配来简化switch语句的使用。这种新语法确保了一旦匹配成功，只有匹配的分支会被执行，无需使用break语句，从而消除了穿透效应的可能性。

下面是一个使用新switch表达式的示例，它根据传入的水果名称打印出相应的信息：

public class Main {
    public static void main(String[] args) {
        String fruit = "apple";
        // 使用新的switch表达式语法
        switch (fruit) {
            case "apple" -> System.out.println("Selected apple");
            case "pear" -> System.out.println("Selected pear");
            case "mango" -> {
                System.out.println("Selected mango");
                System.out.println("Good choice!");
            }
            default -> System.out.println("No fruit selected");
        }
    }
}

在这个例子中，每个case后面跟着一个箭头->，指向要执行的语句。如果一个case分支包含多条语句，这些语句需要用花括号{}括起来。由于新语法的特性，不需要显式地写break语句。

此外，新的switch表达式还可以用来给变量赋值，并且可以直接返回值。这使得代码更加简洁和表达力更强。以下是如何使用新switch表达式来赋值的示例：

public class Main {
    public static void main(String[] args) {
        String fruit = "apple";
        // 使用新的switch表达式来赋值并返回结果
        int opt = switch (fruit) {
            case "apple" -> 1;
            case "pear", "mango" -> 2; // 可以一次性匹配多个case
            default -> 0;
        }; // 注意赋值语句要以分号;结束
        System.out.println("opt = " + opt);
    }
}

在这个例子中，switch表达式被用来根据fruit的值来确定opt的值。每个case分支后面是一个表达式，它计算并返回一个值。由于switch表达式的特性，不需要使用break语句，且每个分支的执行是互斥的，确保了只有一个分支会被执行。

yield

除了简单的返回语句，我们还可以使用花括号{}来包含多条语句，并使用关键字yield来指定switch表达式的返回值。

例如，考虑以下场景，我们需要根据传入的水果名称计算出一个复杂的选项值opt。在这个例子中，如果fruit是默认值，我们需要计算水果名称的哈希码并返回它：

public class Main {
    public static void main(String[] args) {
        String fruit = "orange";
        int opt = switch (fruit) {
            case "apple" -> 1;
            case "pear", "mango" -> 2;
            default -> {
                int code = fruit.hashCode(); // 执行复杂的语句
                yield code; // 使用yield关键字返回值
            }
        };
        System.out.println("opt = " + opt);
    }
}

在这个switch表达式中，我们首先检查fruit是否匹配预定义的case。如果都不是，我们进入default分支。在default分支中，我们计算fruit字符串的哈希码并将其存储在变量code中。然后，我们使用yield关键字来指定switch表达式的返回值，这里是code变量的值。

yield关键字的使用确保了switch表达式可以返回一个值，而不仅仅是执行语句。这使得switch表达式在处理复杂的逻辑和计算时变得更加强大和灵活。通过这种方式，我们可以在switch表达式中执行任何需要的语句，并且返回一个有意义的值，而不是仅仅进行输出或赋值操作。