JEP 361: Switch Expressions | Switch 表达式
摘要
扩展 switch
语句,使其既可以作为语句使用,也可以作为表达式使用,并且两种形式都可以使用传统的 case ... :
标签(具有穿透性)或新的 case ... ->
标签(无穿透性),以及一个新的语句,用于从 switch
表达式中返回值。这些更改将简化日常编码,并为在 switch
中使用模式匹配铺平道路。这是 JDK 12 和 JDK 13 中的 预览语言特性。
历史
JEP 325 在 2017 年 12 月 提出了 switch
表达式。JEP 325 在 2018 年 8 月 被 定位为 JDK 12 的预览特性。JEP 325 的一个方面是重载 break
语句以从 switch
表达式中返回一个结果值。JDK 12 的反馈表明,这种 break
的使用方式令人困惑。为了响应这些反馈,JEP 354 作为 JEP 325 的演进版本被创建。JEP 354 提出了一个新的语句 yield
,并恢复了 break
的原始含义。JEP 354 在 2019 年 6 月 被 定位为 JDK 13 的预览特性。JDK 13 的反馈表明,switch
表达式已经准备好在 JDK 14 中作为最终和永久特性使用,无需进一步更改。
动机
随着我们准备增强 Java 编程语言以支持 模式匹配(JEP 305),现有 switch
语句的一些不规则性——长期以来一直令用户感到烦恼——变成了障碍。这些不规则性包括 switch
标签之间的默认控制流行为(穿透)、switch
块中的默认作用域(整个块被视为一个作用域),以及尽管经常更自然地以表达式形式表示多路条件,但 switch
仅作为语句使用的事实。
Java 的 switch
语句的当前设计紧密遵循 C 和 C++ 等语言,并默认支持穿透语义。虽然这种传统的控制流对于编写低级代码(如二进制编码解析器)很有用,但随着 switch
在更高级别的上下文中使用,其容易出错的特性开始超过其灵活性。例如,在以下代码中,许多 break
语句使其变得不必要地冗长,这种视觉噪声常常掩盖了难以调试的错误,其中缺少 break
语句会导致意外的穿透。
switch (day) {
case MONDAY:
case FRIDAY:
case SUNDAY:
System.out.println(6);
break;
case TUESDAY:
System.out.println(7);
break;
case THURSDAY:
case SATURDAY:
System.out.println(8);
break;
case WEDNESDAY:
System.out.println(9);
break;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
我们提议引入一种新型的 switch
标签形式,“case L ->
”,用于表示如果标签匹配,则仅执行标签右侧的代码。我们还提议允许每个 case
使用多个常量,常量之间用逗号分隔。前面的代码现在可以写成:
switch (day) {
case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
case TUESDAY -> System.out.println(7);
case THURSDAY, SATURDAY -> System.out.println(8);
case WEDNESDAY -> System.out.println(9);
}
2
3
4
5
6
"case L ->
" switch
标签右侧的代码仅限于一个表达式、一个块或(为了方便起见)一个 throw
语句。这样做有一个令人愉快的结果,即如果一个分支引入了局部变量,它必须包含在一个块中,因此不在 switch
块中任何其他分支的作用域内。这消除了传统 switch
块中局部变量作用域为整个块的另一个烦恼:
switch (day) {
case MONDAY:
case TUESDAY:
int temp = ... // 'temp'的作用域持续到}
break;
case WEDNESDAY:
case THURSDAY:
int temp2 = ... // 不能将此变量命名为'temp'
break;
default:
int temp3 = ... // 不能将此变量命名为'temp'
}
2
3
4
5
6
7
8
9
10
11
12
许多现有的 switch
语句本质上都是对 switch
表达式的模拟,其中每个分支要么赋值给一个公共目标变量,要么返回一个值:
int numLetters;
switch (day) {
case MONDAY:
case FRIDAY:
case SUNDAY:
numLetters = 6;
break;
case TUESDAY:
numLetters = 7;
break;
case THURSDAY:
case SATURDAY:
numLetters = 8;
break;
case WEDNESDAY:
numLetters = 9;
break;
default:
throw new IllegalStateException("Wat: " + day);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
以语句的形式表达这种方式是间接的、重复的,并且容易出错。作者的本意是表达我们应该为每一天计算 numLetters
的值。应该可以直接使用 switch
表达式 来直接表达这一点,这样更清晰也更安全:
int numLetters = switch (day) {
case MONDAY, FRIDAY, SUNDAY -> 6;
case TUESDAY -> 7;
case THURSDAY, SATURDAY -> 8;
case WEDNESDAY -> 9;
};
2
3
4
5
6
反过来,将 switch
扩展到支持表达式也提出了一些额外的需求,例如扩展流分析(表达式必须始终计算一个值或突然完成),以及允许 switch
表达式的某些分支抛出异常而不是返回值。
描述
箭头标签
除了传统的 switch
块中的 "case L :
" 标签外,我们还定义了一种新的简化形式,即使用 "case L ->
" 标签。如果某个标签匹配,则仅执行箭头右侧的表达式或语句;不会执行后续的标签。例如,给定以下使用新形式标签的 switch
语句:
static void howMany(int k) {
switch (k) {
case 1 -> System.out.println("one");
case 2 -> System.out.println("two");
default -> System.out.println("many");
}
}
2
3
4
5
6
7
以下代码:
howMany(1);
howMany(2);
howMany(3);
2
3
将产生以下输出:
one
two
many
2
3
Switch 表达式
我们扩展了 switch
语句,使其可以用作表达式。例如,前面的 howMany
方法可以重写为使用 switch
表达式,从而只使用一个 println
。
static void howMany(int k) {
System.out.println(
switch (k) {
case 1 -> "one";
case 2 -> "two";
default -> "many";
}
);
}
2
3
4
5
6
7
8
9
在常见情况下,switch
表达式看起来像这样:
T result = switch (arg) {
case L1 -> e1;
case L2 -> e2;
default -> e3;
};
2
3
4
5
switch
表达式是一个多态表达式;如果目标类型已知,该类型将被推送到每个分支中。switch
表达式的类型是其目标类型(如果已知);如果未知,则通过组合每个分支的类型来计算一个独立类型。
返回值
大多数 switch
表达式的右侧都有一个与 "case L ->
" 切换标签相对应的单个表达式。如果需要一个完整的代码块,我们引入了一个新的 yield
语句来返回一个值,这个值将成为包含它的 switch
表达式的值。
int j = switch (day) {
case MONDAY -> 0;
case TUESDAY -> 1;
default -> {
int k = day.toString().length();
int result = f(k);
yield result;
}
};
2
3
4
5
6
7
8
9
与 switch
语句类似,switch
表达式也可以使用带有 "case L:
" 切换标签的传统切换块(暗示穿透语义)。在这种情况下,值是通过新的 yield
语句返回的:
int result = switch (s) {
case "Foo":
yield 1;
case "Bar":
yield 2;
default:
System.out.println("Neither Foo nor Bar, hmmm...");
yield 0;
};
2
3
4
5
6
7
8
9
break
(带或不带标签)和 yield
这两个语句有助于轻松区分 switch
语句和 switch
表达式:switch
语句但不是 switch
表达式可以是 break
语句的目标;而 switch
表达式但不是 switch
语句可以是 yield
语句的目标。
yield
不是一个关键字,而是一个受限标识符(如 var
),这意味着名为 yield
的类是非法的。如果在作用域内存在一元方法 yield
,则表达式 yield(x)
会有歧义(可能是方法调用,也可能是操作数为括号表达式的 yield 语句),这种歧义会倾向于解析为 yield 语句。如果更倾向于方法调用,则应该通过 this
(对于实例方法)或类名(对于静态方法)来限定该方法。
完备性
switch
表达式的各个情况必须是 完备的;对于所有可能的值,都必须有一个匹配的切换标签。(显然,switch
语句不要求完备。)
在实践中,这通常意味着需要一个 default
子句;然而,在 enum
switch
表达式的情况下,如果它覆盖了所有已知的常量,编译器会插入一个 default
子句,以指示 enum
定义在编译时和运行时之间已经发生了更改。依赖这种隐式的 default
子句插入可以使代码更加健壮;现在,当代码重新编译时,编译器会检查所有情况是否都已明确处理。如果开发者插入了显式的 default
子句(就像现在的情况),则可能隐藏了潜在的错误。
此外,switch
表达式必须正常完成并返回一个值,或者通过抛出异常来突然完成。这有几个后果。首先,编译器会检查每个切换标签,如果它被匹配,那么必须可以产生一个值。
int i = switch (day) {
case MONDAY -> {
System.out.println("Monday");
// 错误!代码块中不包含 yield 语句
}
default -> 1;
};
i = switch (day) {
case MONDAY, TUESDAY, WEDNESDAY:
yield 0;
default:
System.out.println("Second half of the week");
// 错误!代码组中不包含 yield 语句
};
2
3
4
5
6
7
8
9
10
11
12
13
14
另一个后果是控制语句 break
、yield
、return
和 continue
不能跳过 switch
表达式,例如:
z:
for (int i = 0; i < MAX_VALUE; ++i) {
int k = switch (e) {
case 0:
yield 1;
case 1:
yield 2;
default:
continue z;
// 错误!非法跳过 switch 表达式
};
...
}
2
3
4
5
6
7
8
9
10
11
12
13
依赖关系
这个 JEP 是从 JEP 325 和 JEP 354 演变而来的。然而,这个 JEP 是独立的,并不依赖于这两个 JEP。
未来对模式匹配的支持,从 JEP 305 开始,将基于这个 JEP 进行构建。
风险和假设
有时,对带有 case L ->
标签的 switch
语句的需求并不明确。以下考虑因素支持了其包含:
有些
switch
语句通过副作用进行操作,但通常仍然是“每个标签一个动作”。将这些语句与新型标签结合起来,可以使语句更加直接且不易出错。在 Java 早期历史中,
switch
语句块中的默认控制流是穿透而非跳出,这是一个不幸的选择,并且仍然是开发人员关注的一个重大问题。通过针对一般的switch
构造(而不仅仅是switch
表达式)解决此问题,这一选择的影响得以减少。通过将期望的好处(表达式化、更好的控制流、更合理的作用域)分解为正交特性,
switch
表达式和switch
语句可以拥有更多的共同点。switch
表达式和switch
语句之间的差异越大,语言的学习难度就越大,开发人员遇到的棘手问题也就越多。