揭秘Java switch语句中的case穿透现象

最新推荐文章于 2024-09-21 11:12:00 发布
最新推荐文章于 2024-09-21 11:12:00 发布
阅读量1.2k 收藏 2
点赞数 2
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d812359/article/details/133921854
版权

揭秘Java switch语句中的case穿透现象

导语：在 Java 开发中，我们经常使用switch语句来进行条件判断和分支选择。然而，有一个令人困惑的现象就是，当某个case语句没有加上break关键字时，程序会继续执行下一个case语句，这被称为case穿透现象。本文将揭秘case穿透现象的原因，并解释为何会出现这种行为。

1. switch 语句简介

在开始揭秘case穿透现象之前，我们先简单回顾一下switch语句的基本用法。switch语句用于根据变量的不同取值执行相应的代码块。其语法结构如下：

switch (expression) {
    case value1:
        // 执行代码块1
        break;
    case value2:
        // 执行代码块2
        break;
    ...
    default:
        // 默认代码块
}

switch case支持的6种数据类型：switch 表达式后面的数据类型只支持byte、short、int整形类型、字符类型char、枚举类型和java.lang.String类型。

根据expression的值，程序会跳转到对应的case语句进行匹配并执行相应的代码块，直到遇到break关键字或者到达switch语句的结尾。

如果某个case语句没有break，程序会继续执行下一个case语句，这就是case穿透现象。

我们看下面这个例子。

public class Test {
    public static void main(String[] args) {
        int i = 0;
        switch (i) {
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
            case 2:
                System.out.println("2");
        }
    }
}

打印结果：

0
1
2

2. case穿透现象的原因

按照惯用套路，看看字节码能不能给个答案。

javac编译和javap查看：

> javap -c -l Test.class
Compiled from "Test.java"
public class com.atu.algorithm.aTest.Test {
  public com.atu.algorithm.aTest.Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
    LineNumberTable:
      line 8: 0

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_1
       2: iload_1
       3: tableswitch   { // 0 to 2
                     0: 28
                     1: 36
                     2: 44
               default: 52
          }
      28: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      31: ldc           #3                  // String 0
      33: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      36: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      39: ldc           #5                  // String 1
      41: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      44: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      47: ldc           #6                  // String 2
      49: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      52: return
    LineNumberTable:
      line 10: 0
      line 11: 2
      line 13: 28
      line 15: 36
      line 17: 44
      line 19: 52
}

根据提供的字节码，我们来解释一下case穿透的情况。

在main方法中，通过tableswitch指令实现了一个switch语句。switch语句会根据值进行跳转，并执行对应的代码块。

在这个例子中，根据tableswitch指令的参数 {0 to 2}，case的范围是从0到2。

  • 当switch的表达式的值为0时，程序会跳转到标签为28的位置，然后继续执行28标签处的代码块。
  • 为1时跳转到标号36代码处；
  • 为2时跳转到标号44代码处；
  • default则跳转到标号52代码处。

这不，答案就出来了，当case 0匹配了之后，直接跳转到标号28代码处开始执行，输出0，然后策马奔腾，一路下坡，顺序执行完后面所有代码，直到标号52 return，方法完执行完成，程序结束。

如果按照正常的思维，是不是case 0匹配之后，跳到28，执行完28、31、32输出0之后，就应该直接跳走，直接执行49。

那么，这个【跳走】用字节码应该怎么表示？

关于 goto

再写代码样例，这次我们在代码中给每个case都加上break。

public class Test {
    public static void main(String[] args) {
        int i = 0;
        switch (i) {
            case 0:
                System.out.println("0");
                break;
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
        }
        System.out.println("Hello World");
    }
}

打印结果：

0
Hello World

重新编译，再来看看字节码。

Compiled from "Test.java"
public class com.atu.algorithm.aTest.Test {
  public com.atu.algorithm.aTest.Test();   
    Code:                                  
       0: aload_0                                                                  
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
    LineNumberTable:
      line 8: 0

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_1
       2: iload_1
       3: tableswitch   { // 0 to 2
                     0: 28
                     1: 39
                     2: 50
               default: 58
          }
      28: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      31: ldc           #3                  // String 0
      33: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      36: goto          58
      39: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      42: ldc           #5                  // String 1
      44: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      47: goto          58
      50: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      53: ldc           #6                  // String 2
      55: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      58: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      61: ldc           #7                  // String Hello World
      63: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      66: return
    LineNumberTable:
      line 10: 0
      line 11: 2
      line 13: 28
      line 14: 36
      line 16: 39
      line 17: 47
      line 19: 50
      line 22: 58
      line 23: 66
}

如图，与第一次的字节码相比，在标号36、47都有了goto指令。如果case 0匹配成功，则跳到标号28执行，执行完代码块对应的31、33指令之后，执行36的goto指令跳转到标号58，这样就跳出了switch作用范围，case 1和2也不会被执行。

在Java字节码中，goto指令用于无条件跳转到指定的目标代码块。它可以实现程序的跳转和循环控制。

等等，怎么少了一个goto，在标号58的上方应该还有一个goto才对！

其实这就涉及到了编译器优化技术，最后一个goto也是跳转到标号58的指令，但没有goto下一步也一样顺序执行此行指令，所以这个goto被编译器视为无用代码进行了消除。

3. switch和if的区别

先用if实现上面switch逻辑。

public class Test {
    public static void main(String[] args) {
        int i = 0;
        if (i == 0) {
            System.out.println(0);
        } else if (i == 1) {
            System.out.println(1);
        } else if (i == 2) {
            System.out.println(2);
        }
        System.out.println("Hello World");
    }
}

编译成字节码

Compiled from "Test.java"
public class com.atu.algorithm.aTest.Test {
  public com.atu.algorithm.aTest.Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
    LineNumberTable:
      line 8: 0

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_1
       2: iload_1
       3: ifne          16
       6: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: iconst_0
      10: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      13: goto          43
      16: iload_1
      17: iconst_1
      18: if_icmpne     31
      21: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      24: iconst_1
      25: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      28: goto          43
      31: iload_1
      32: iconst_2
      33: if_icmpne     43
      36: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      39: iconst_2
      40: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      43: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      46: ldc           #4                  // String Hello World
      48: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      51: return
}

「ifne」和「if_icmpne」是Java字节码指令中的两个条件分支指令，用于在程序执行过程中进行条件判断并跳转到相应的代码块。它们的区别在于操作数类型和比较方式。

  • ifne：操作数类型为int，功能是当栈顶元素不等于零时，跳转到指定的代码块。
  • if_icmpne：操作数类型为int，当两个int类型的数值不相等时，跳转到指定的代码块。

从字节码也可以看出if和switch的区别：

  • if条件和代码块的字节码是顺序的，switch条件和代码块是分开的；
  • if自动生成goto指令，switch只有加了break才生成goto指令。

4. 总结

  1. case穿透现象：指在switch语句中，当某个case语句没有break，程序会继续执行下一个case语句。
  2. case中的break作用是告诉前端编译器：「给每个case对应代码块的最后加上goto」。这样，执行完匹配上的代码之后，就可以略过后面的case代码块了。
  3. switch都支持哪些类型呢？
    • 基本数据类型：byte, short, char, int
    • 包装数据类型：Byte, Short, Character, Integer
    • 枚举类型：Enum
    • 字符串类型：String（Jdk 7+ 开始支持）
徐俊生
关注
专栏目录
如何利用Java switch……case的穿透
PWQ002的博客
06-26 368
如何利用JAVA switch……case的穿透 switch一般使用： 判断所处月份所处的季度 (简单却繁琐的用法) /* 判断月份所处的季度： 第一季度：1月－3月 第二季度：4月－6月 第三季度：7月－9月 第四季度：10月－12月 */ //月份 byte month = 4 //定义一个默认第四季
Java-switch语句的case穿透现象
浮华′的博客
11-04 2139
文章目录一、switch语句二、case穿透 一、switch语句 详细可以看此链接学习——Java流程控制语句2020年 二、case穿透 case穿透：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整体switch语句结束。 不使用case穿透输出十二个月份分别所处季节的代码： switch(month) { case 1: System.out.println("冬季"); break
关于case穿透
最新发布
m0_63790427的博客
09-21 142
关于case穿透，default语句的位置
Java，利用switch的穿透
二狗mao的博客
10-19 301
如果用单纯的case后跟break的方法，month为1的时候，直接输出day。month为3的时候，结果为31+28+day。在switch语句中，case就是一个入口，表达式与case后面的表达式匹配上后，就进入后面的语句，其他case后面的语句也会进入执行，直到遇到break才停止执行跳出switch语句。通常情况下，会在每一个case后的语句中，以break结尾，防止发生穿透，执行其他case后面的语句。比如输入的month为7，就会从case 7：进入，进行前六个月的天数的相加。
switch case穿透Java_Switch语句的case穿透
weixin_39915605的博客
02-25 285
Switch语句的case穿透一 switch语句几点说明:1.case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的.2.case后面表达式可以接受:基本数据类型,byte,short,char,int.换句话说能自动类型自动提升为int的都可以接受;引用数据类型可以接受枚举(JDK1.5),String字符串(JDK1.7)3.default不是一定要放到最后,放到中间...
switch语句中的case穿透
2303_78660417的博客
07-18 532
case穿透的规则：1.首先还是根据小括号中表达式的结果去匹配对应的case。2.接着执行case里面的代码。3.如果在执行的过程中，遇到了break，那么就会直接结束整个switch语句；但是如果没有遇到break，就会继续执行下面case中的代码，直到遇到break,或者把整个switch语句中所有的代码全部执行完了，才会结束。
switch case 穿透
zz526546982的博客
04-28 1228
switch case 穿透
PHP中的switch语句的用法实例详解
10-23
`break`语句用于在执行完当前case分支后退出switch语句，防止继续向下执行其他case分支的代码（这是所谓的“穿透”现象）。如果没有匹配到任何case值，那么将执行`default`分支。 需要注意的是，如果在case后面没有...
Java 零基础控制语句 - switch 语句.md
08-08
- **字符串作为 case 值**：从 Java 7 开始，`switch` 语句支持字符串作为 case 值，这使得代码更加直观易懂。例如： ```java String str = "hello"; switch (str) { case "hello": System.out.println("欢迎...
Java 18 Switch语句更强大了
Trouvailless的博客
05-18 694
自Java13以来，Switch表达式被添加到Java核心库中。如果您使用的是Java版本13或更高版本，那么您肯定可以将旧Switch转换为新Switch。 本文将讨论它如何在不破坏现有更改的情况下提供某些功能。当然，其他语言用户可能会评论“多年前，它就已经存在于我们的编程语言中了”。但让我们微笑一下，继续用Java编程，好吗？注意，我将在帖子中交替使用“switch expression”和“switch statement”，所以请记住，我想说的是同一件事。 旧的Java Switch语句...
Java switch-case扩展 (case穿透、JDK12 switch新特性)
weixin_52337823的博客
06-26 712
case穿透是指在switch-case中，执行完当前case语句，因为省略了break语句，导致无法跳出switch，所以继续向下执行下一条case语句的情况。对switch的语法进行了扩展，这个特性可以大大简化代码，并且避免因为遗忘break语句引发bug。
java switch语句中case穿透
toBeBest_ok的博客
11-13 1026
case穿透：switch语句中case：后面不加break。 下面是一个利用case穿透的一个小例子。
Java中switch语句case穿透
weixin_42622803的博客
06-12 673
注意：当switch语句中，如果case控制的语句后面不写break，将出现穿透现象。 现象：当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行，直到看见break，或者将整体switch语句执行完毕，才会结束。 应用场景：当发现switch语句中，多个case给出的语句体出现了重复的，就可以考虑使用case穿透现象优化代码。 ...
java-switch穿透
ITGGU的博客
01-04 823
switch穿透 据用于指定月份， 打印该月份所属的季节。 3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季 [课堂练习, 提示 使用穿透 ] 思路分析 1. 创建Scanner对象， 接收用户输入 2. 使用 int month 接收 3. 使用switch 来匹配 ,使用穿透来完成，比较简洁 import java.util.Scanner; public class Switch02{ public static void main(String[] args){
关于switch-case在Java中的穿透性
m0_64989426的博客
06-16 848
case的执行语句只有在遇到break的时候才会终止运行，在没有遇到break之前会一直往下进行。我们把这种性质叫做switch-case的穿透性。
switch语句的case穿透
weixin_52397672的博客
12-17 381
1.原理 case语句块中如果缺失break；语句，会出现穿透现象 2.代码 Scanner data = new Scanner(System.in); System.out.print("请输入一个数字（0-3）:"); int num = data.nextInt(); switch(num){ case 1: System.out.println("我通过了case1"); case 2: System.out.println("我通过了case
1.5-Java-switch语句-case穿透
热门推荐
yangkai的博客
06-13 1万+
一,switch语句中的case穿透现象1.switch语句语句格式: switch(表达式) { case 值1: 语句1: break; case 值2: 语句2: break;
java入门switch-case穿透
WoWBOOM的博客
12-03 967
switch-case穿透
Java中switch case的用法
09-18
在Java中，switch-case语句用于根据不同的条件执行不同的代码块。它的一般格式如下： switch(参数){ case 常量表达式1: // 执行语句 break; case 常量表达式2: // 执行语句 break; // ... default: // 执行语句 break; } 在switch语句中，参数可以是整型数据（byte、short、int、char）或枚举类型。当参数的值与某个case的常量表达式匹配时，就会执行该case下的代码块。如果没有匹配的case，就会执行default下的代码块。 在一个switch语句中，可以有多个case，每个case后面需要使用break关键字来结束该case下的代码块。如果没有使用break，那么程序会继续执行下一个case的代码块，这称为"case穿透"。default下的代码块是可选的，它表示当参数的值与所有case的常量表达式都不匹配时，执行default下的代码块。 除了一般的switch语句，还可以使用嵌套switch语句。嵌套switch语句是指在一个switch语句的case代码块中再嵌套另一个switch语句。由于每个switch语句都有自己的块，所以内部和外部的case常量不会产生冲突。 例如，下面是一个使用switch-case语句的示例： switch(dayOfWeek){ case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; case 3: System.out.println("Wednesday"); break; case 4: System.out.println("Thursday"); break; case 5: System.out.println("Friday"); break; default: System.out.println("Weekend"); break; } 在这个例子中，根据dayOfWeek的值不同，输出对应的星期几。如果dayOfWeek的值不在1-5之间，就会输出"Weekend"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值