Java流程控制——3.switch多重选择

目录

• Java中的switch语句：多重选择的高效实现
  • switch语句的基本用法
    • 示例：
  • switch的特性
    • case穿透性与break语句
    • 多个case共享代码块
    • default分支
  • 支持的表达式类型
    • 字符串类型的switch示例
  • Java 12+的switch表达式新特性
    • 新语法：箭头符号->
    • 作为表达式返回值
    • yield语句
  • 综合示例：石头剪刀布游戏
  • 总结

---

Java中的switch语句：多重选择的高效实现

在Java编程中，当需要根据一个表达式的不同结果执行不同代码块时，switch语句提供了比if-else if结构更清晰、更高效的解决方案。

switch语句的基本用法

switch语句通过判断一个表达式的结果，从多个分支中选择一个匹配的分支执行。其基本语法结构如下：

switch (表达式) {
    case 值1:
        // 当表达式结果等于值1时执行的代码
        break;
    case 值2:
        // 当表达式结果等于值2时执行的代码
        break;
    // 更多case分支...
    default:
        // 当没有任何case匹配时执行的代码
        break;
}

示例：

public class SwitchBasicExample {
    public static void main(String[] args) {
        int option = 2;
        switch (option) {
            case 1:
                System.out.println("选择了1");
                break;
            case 2:
                System.out.println("选择了2");
                break;
            case 3:
                System.out.println("选择了3");
                break;
            default:
                System.out.println("选择了其他选项");
                break;
        }
    }
}

上述代码中，switch语句判断option变量的值，当值为2时，执行case 2后的代码，然后遇到break语句退出switch结构。

switch的特性

case穿透性与break语句

switch语句最需要注意的特性是case穿透性：当某个case分支被匹配后，如果没有break语句，程序会继续执行后续所有case的代码，直到遇到break或switch语句结束。

示例：缺少break导致的穿透

public class SwitchFallthroughExample {
    public static void main(String[] args) {
        int option = 2;
        switch (option) {
            case 1:
                System.out.println("选择了1");
            case 2:
                System.out.println("选择了2");
            case 3:
                System.out.println("选择了3");
            default:
                System.out.println("选择了其他选项");
        }
    }
}

运行结果：

选择了2
选择了3
选择了其他选项

由于所有case都没有break语句，程序从case 2开始连续执行了所有后续代码。因此，在绝大多数情况下，每个case分支都应该以break语句结束。

多个case共享代码块

如果多个case需要执行相同的代码，可以将它们连续书写，共享同一个代码块：

public class SwitchSharedCaseExample {
    public static void main(String[] args) {
        int month = 2;
        switch (month) {
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            // 其他季节...
            default:
                System.out.println("未知季节");
        }
    }
}

上述代码中，12月、1月和2月都将执行"冬季"的输出语句。

default分支

default分支是可选的，当没有任何case分支与表达式结果匹配时，会执行default分支的代码。建议总是添加default分支来处理意外情况，提高程序的健壮性。

public class SwitchDefaultExample {
    public static void main(String[] args) {
        String day = "Sunday";
        switch (day) {
            case "Monday":
            case "Tuesday":
            case "Wednesday":
            case "Thursday":
            case "Friday":
                System.out.println("工作日");
                break;
            case "Saturday":
            case "Sunday":
                System.out.println("休息日");
                break;
            default:
                System.out.println("无效的日期");
                break;
        }
    }
}

支持的表达式类型

switch语句的表达式可以是以下类型：

• 基本类型：byte、short、char、int
• 包装类型：Byte、Short、Character、Integer
• 枚举类型（Enum）
• 字符串类型（String）

字符串类型的switch示例

public class SwitchStringExample {
    public static void main(String[] args) {
        String fruit = "apple";
        switch (fruit) {
            case "apple":
                System.out.println("苹果");
                break;
            case "banana":
                System.out.println("香蕉");
                break;
            case "orange":
                System.out.println("橙子");
                break;
            default:
                System.out.println("未知水果");
                break;
        }
    }
}

字符串的匹配基于内容相等性（相当于equals()方法），而不是引用相等性。

Java 12+的switch表达式新特性

从Java 12开始，switch升级为表达式形式，引入了新的语法和特性，解决了传统switch的一些痛点。

新语法：箭头符号->

新语法使用->替代了传统的冒号:，并且不需要break语句，因为新语法默认不会发生穿透：

public class SwitchExpressionExample {
    public static void main(String[] args) {
        String fruit = "mango";
        switch (fruit) {
            case "apple" -> System.out.println("选择了苹果");
            case "banana" -> System.out.println("选择了香蕉");
            case "mango" -> {
                System.out.println("选择了芒果");
                System.out.println("这是热带水果");
            }
            default -> System.out.println("选择了其他水果");
        }
    }
}

当分支代码超过一行时，需要用{}包裹。

作为表达式返回值

新的switch表达式可以直接作为值返回，赋值给变量：

public class SwitchReturnValueExample {
    public static void main(String[] args) {
        String fruit = "apple";
        int price = switch (fruit) {
            case "apple" -> 5;
            case "banana" -> 3;
            case "mango" -> 8;
            default -> 0;
        };
        System.out.println("价格：" + price);
    }
}

多个case可以合并为一行，用逗号分隔：

int price = switch (fruit) {
    case "apple", "pear" -> 5;
    case "banana", "orange" -> 3;
    default -> 0;
};

yield语句

当需要在switch表达式中执行复杂逻辑并返回值时，可以使用yield语句：

public class SwitchYieldExample {
    public static void main(String[] args) {
        String fruit = "apple";
        int discount = switch (fruit) {
            case "apple" -> {
                System.out.println("苹果有折扣");
                yield 10; // 返回折扣值
            }
            case "banana" -> {
                System.out.println("香蕉有折扣");
                yield 5;
            }
            default -> 0;
        };
        System.out.println("折扣：" + discount + "%");
    }
}

yield语句用于从switch表达式中返回一个值，类似于方法中的return。

综合示例：石头剪刀布游戏

import java.util.Scanner;

public class RockPaperScissors {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请选择：1.石头 2.剪刀 3.布");
        int playerChoice = scanner.nextInt();

        // 电脑随机选择1-3
        int computerChoice = (int) (Math.random() * 3) + 1;

        System.out.print("电脑选择了：");
        printChoice(computerChoice);

        System.out.print("你选择了：");
        printChoice(playerChoice);

        // 判断胜负
        String result = switch (playerChoice) {
            case 1 -> computerChoice == 1 ? "平局" :
                     computerChoice == 2 ? "胜利" : "失败";
            case 2 -> computerChoice == 1 ? "失败" :
                     computerChoice == 2 ? "平局" : "胜利";
            case 3 -> computerChoice == 1 ? "胜利" :
                     computerChoice == 2 ? "失败" : "平局";
            default -> "无效选择";
        };

        System.out.println("结果：" + result);
        scanner.close();
    }

    private static void printChoice(int choice) {
        switch (choice) {
            case 1 -> System.out.println("石头");
            case 2 -> System.out.println("剪刀");
            case 3 -> System.out.println("布");
            default -> System.out.println("无效");
        }
    }
}

总结

• 传统switch使用case:和break，需注意穿透性问题
• 支持整数、字符串、枚举等多种类型的表达式
• Java 12+引入的新语法使用->，无需break，更简洁安全
• 新的switch表达式可以返回值，支持yield语句处理复杂逻辑
• 合理使用default分支提高程序健壮性