黑马程序员技术交流社区

标题: 关于switch语句的·问题 [打印本页]

作者: 黑马无敌 时间: 2015-7-11 10:43
标题: 关于switch语句的·问题
default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。

我想问下上面这句话是不是错的,这，我发现这个不对，不知道是不是我搞错了。。。求解释。。。。。。。。。

作者: 孟卫严 时间: 2015-7-11 10:43
首先你是对的！
选择结构switch语句
      switch语句格式：
            switch(表达式) {
                     case 值1：
                              语句体1;
                              break;
                  case 值2：
                              语句体2;
                              break;
                  …
                  default：
                              语句体n+1;
                              break;
            }
      格式解释
            switch表示这是switch语句
            表达式的取值：byte,short,int,char
            JDK5以后可以是枚举
            JDK7以后可以是String
            case后面跟的是要和表达式进行比较的值
            语句体部分可以是一条或多条语句
            break表示中断，结束的意思，可以结束switch语句
            default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

      执行流程
            首先计算出表达式的值
            其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
            最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

      注意事项
            case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
            default可以省略吗?
                     可以省略。一般不建议。除非判断的值是固定的。(单选题)
            break可以省略吗?
                     可以省略，一般不建议。否则结果可能不是你想要的
            default的位置一定要在最后吗?
                     可以出现在switch语句任意位置。
            switch语句的结束条件
                     遇到break
                     执行到程序的末尾

作者: 形而上孤独 时间: 2015-7-11 14:51
学习一下

作者: 强强_U00ts 时间: 2015-7-11 17:06
恩恩,学习学习,就是先执行case,再执行default,default未必会执行么??

作者: αメ炫 时间: 2015-7-11 18:06
本帖最后由 αメ炫于 2015-7-11 18:08 编辑

部分对部分不对，为了还原本来的执行顺序，下面代码我都不写break，因为break破坏了正常顺序和正常思维

switch执行分两步，先找匹配的case，然后进入代码区，没有匹配到case则通过default进去代码区

记住两点1.case default的匹配工作只做一次 2.一旦进入代码区，就是从头执行到尾直到遇到break

例1：
int a=1;
switch (a) {

      default:
         printf("exe default\n");

      case 1:
         printf("exe case 1\n");

      case 2:
         printf("exe case 2\n");

}
结果：
exe case 1
exe case 2

如果匹配不到case 就走default进入代码区，代码区是啥？就是除了前面case default剩下的部分

int a=1;
switch (a) {

      default:
         printf("exe default\n");

      case 2:
         printf("exe case 2\n");

      case 3:
         printf("exe case 3\n");

}

这里没有匹配到case就从default进入代码区，代码区就是

         printf("exe default\n");

         printf("exe case 2\n");

         printf("exe case 3\n");

所以结果就是
exe default
exe case 2
exe case 3

你这样放

      case 2:
         printf("exe case 2\n");

      default:
         printf("exe default\n");

      case 3:
         printf("exe case 3\n");

没有匹配到case从default进入代码区
结果就是
exe default
exe case 3

这就是switch本来应该执行的顺序，每个case后面的代码本来都是连在一起的，代码部分就是一个整体，从头执行到尾

可是代码区里面插入了break，打破规则，让每个case独立感觉像是一个分支，执行完就结束

printf("exe case 2\n");
break;
printf("exe default\n");
break;
printf("exe case 3\n");
break;

有了break的代码区变成了一段一段的，从而产生错觉，感觉像是分支，还纠结究竟执行哪个，其实没有break捣蛋，只要进入代码区，管它啥从头执行到尾

作者: 段培峰 时间: 2015-7-11 18:15
不管default放哪都是先执行case的，case不匹配才执行default。之后，如果default不是放在末尾，则执行default下面的case，遇到break或者}就退出。

作者: Poskey 时间: 2015-7-11 21:06
选择语句

作者: 1木头1 时间: 2015-7-11 21:53
switch中首先找case 中匹配的value值，如果匹配直到遇到break跳出switch，如若不匹配则会依次找匹配的value 如果都不匹配最后去执行default语句然后遇到break跳出switch，如果在遇到break之前中间夹杂很多case语句不判断直接执行里面的语句

作者: 徐会会 时间: 2015-7-11 22:25
这句话是错的，你是对的，不论default放在前面后面？都先读case，case读完，才能读它

作者: mengxun 时间: 2015-7-11 23:16
这句话是不对的，无论default放在switch语句的任何位置，都是从case1开始匹配，如果有符合条件的自然执行对应的执行语句，如果所有case都匹配失败，则执行default。无论是case还是default一旦被执行且执行语句后面没有break，则程序不会停止，而且执行下面所有可以执行的语句，无需任何判断条件。

作者: kime 时间: 2015-7-11 23:43
case之间与default没有顺序

作者: ALin 时间: 2015-7-11 23:49
int a=1;
switch (a) {


      case 1:
         printf("\n");

      case 2:
         printf("\n");

   default:
         printf(" default\n");


   }

作者: 扶摇丶 时间: 2015-7-12 00:14
我们老师曾经举过一个例子,记得不太清了，大概就是：把switch语句看成仓库； break 看成仓库管理员；Case 就是仓库内的门；而 default 就是仓库的后门，里面放着打开其他门的钥匙。当函数运行的时候，不管default在前面还是在后面都是先对case语句判断。
假如default在最前面的情况，而其他门（case）都打不开，那么他可以从后门（default）中得到其他门的钥匙，然后依次打开其他的门，拿到里面的东西，直到遇见仓库管理员（break），把他抓住了，结束程序.

作者: yongwei 时间: 2015-7-12 00:18
defaul无论放在前面还是最后，都是最后执行的我，只有所有case都不执行时才执行defaul语句

作者: 黑马和大灰狼 时间: 2015-7-12 00:56
default不管放在哪里都是最后执行的哦

作者: 秀丽xl 时间: 2015-7-12 06:49
default可以写在switch结构中的任意位置；这句话没错。但不管default语句放在哪里，expression都会先与case中的value匹配，如果找到匹配的，那就执行相应case里面的语句，然后继续往下执行；如果没有找到匹配的case。那么就找default语句。从default开始执行，直到遇到break或者是程序结束，如果没有找到匹配的case。程序中也没有default，那么switch语句直接结束。

作者: 鲁枝权双元 时间: 2015-7-12 09:57
switch case break default 这些的重要性理解
switch语句
格式:
switch(表达式)
{
case 值1:
//执行语句1;
break;
case 值2:
//执行语句2;
break;
case 值3:
//执行语句3;
break;
...
default:
//默认执行语句;
break;

}
表达式:
byte 、 short、 int 、 char
jdk5之后增加:枚举
jdk7之后增加:String

执行流程:
表达式的值从上往下依次匹配每一个case的值, 如果匹配上,就执行该case的执行语句,
如果没有匹配,就走default.
结束条件:
遇到break或者执行到switch语句的末尾.

特别注意如果没有break也没有满足的case那就是这样的情况：
int x=2,y=3;
switch(x)
{
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);

结果是6

作者: xiaoqiao 时间: 2015-7-12 11:26
看到那么多人替你解答都很对啊

作者: 猫咪先生 时间: 2015-7-12 15:51
当default出现在第一行时程序还是会先去从case开始去找匹配对象，当case中没有匹的，则执行default，执行完default后，程序不再判断case中的条件而是直接执行case中的语句，知道出现break。

作者: 用晦而明 时间: 2015-7-12 17:08
switch 中的case 只是标识一个路口，如果case标识的路口不符合switch后的表达式结果那么就执行default

作者: likang 时间: 2015-7-12 17:16
不管default放哪都是先执行case的，如果表达式的值与所有case后的常量表达式值均不相同时才执行default后的语句

作者: 雏鹰起飞 时间: 2015-7-12 17:57
确实不对
应该是这样的：首先它会检查是否有匹配

1、若是没有匹配到，就从default开始执行直到遇到break或者结束大括号

2、若是匹配到了，则是从匹配到的case哪儿开始往下执行，知道遇到break或者结束大括号

作者: zhangfurui 时间: 2015-7-12 19:42
给你说的简单点吧：
switch一执行他会去找case ，如果没有找到他会去找default，找到default后他会把default后面的语句依次执行，一直到break停止。

作者: Sky丶 时间: 2015-7-12 20:27
本帖最后由 Sky丶于 2015-7-12 20:28 编辑

你的问题可以看最下面注意事项
switch语句的格式：
      switch(表达式)
      {
            case 值1:
                     语句体1;
                     break;
            case 值2:
                     语句体2;
                     break;
            case 值3:
                     语句体3;
                     break;
            ...
            default:
                     //语句体n;
                     break;
      }

            A:针对格式的解释
                     switch:表示这里使用的是switch语句，后面跟的是选项。
                              表达式：byte,short,int,char
                                    JDK5以后可以是枚举(以后讲)
                                    JDK7以后可以是字符串(后面讲)
                     case:表示这里就是选项的值，它后面的值将来和表达式的值进行匹配。
                           case后面的值是不能够重复的。
                     break:
                              switch语句执行到这里，就结束了。
                     default:
                              当所有的case和表达式都不匹配的时候，就走default的内容。
                              它相当于if语句的else。一般不建议省略。
            B:执行流程
                     进入switch语句后，就会根据表达式的值去找对应的case值。
                     如果最终没有找到，那么，就执行default的内容。

            C:注意事项：
                     a:default整体可以省略吗?
                              可以，但是不建议。
                     b:default的位置可以放到前面吗?
                              可以，但是不建议。
                     c:break可以省略吗?
                              可以，但是不建议。
                              default在最后，break是可以省略的。
                              case后面的break可以省略，但是结果可能有问题。
                     d:switch语句什么时候结束呢?
                              就是遇到break或者执行到程序的末尾。

作者: fmi110 时间: 2015-7-12 20:42

αメ炫发表于 2015-7-11 18:06
部分对部分不对，为了还原本来的执行顺序，下面代码我都不写break，因为break破坏了正常顺序和正常思维

sw ...

讲的非常仔细学习了

作者: A等待着 时间: 2015-7-12 20:45
switch语句的执行顺序是先找case,找不到的话,在找default,如果default中没有break,则执行到语句的结尾

作者: 无峰 时间: 2015-7-12 21:03
后面那部分是错的，下面为毕老师课件上的内容。就是说switch放在第一行，也是先执行case，没有匹配的case才执行default
switch语句特点：
  a,switch语句选择的类型只有四种：byte，short，int ， char。
  b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
  c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
  d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
下面代码为视频中一例子，红色被注释部分就是先default的
class SwitchDemo
{
public static void main(String[] args)
{
        int x = 3;
/*
switch(x)//byte short int char
{
default:
System.out.println("d");
//break;
case 4:
System.out.println("a");
//break;
case 6:
System.out.println("b");
break;
case 2:
System.out.println("c");
break;
}
*/
/*
int a=4,b =2;

char ch = '+';

switch(ch)
{
case '-':
System.out.println(a-b);
break;
case '+':
System.out.println(a+b);
break;
case '*':
System.out.println(a*b);
break;
case '/':
System.out.println(a/b);
break;
default:
System.out.println("feifa");
}
*/
System.out.println("Hello World!");
}
}

作者: lsunshine 时间: 2015-7-12 22:16

孟卫严发表于 2015-7-11 12:50
首先你是对的！
选择结构switch语句
switch语句格式：

学习了

作者: 鹰隼展翼 时间: 2015-7-12 22:21
先匹配case中的值再执行value值，如果不匹配再从default执行，直到遇到break或者执行完程序结束。

作者: norwood 时间: 2015-7-12 22:51
懂是懂就是说不出来，还是学习学习

作者: 紫夜灵魂 时间: 2015-7-12 23:52
先判断 case，都不符合那么执行default,或者case语句中没有break

作者: cheng_xu_yuan_ 时间: 2015-7-12 23:56
如果有与case匹配的就先从case执行，然后执行那个case中的break结束，如果都没有符合的case，会回到第一行的defaul执行，由于default没有break结束语句，所以下边的case会都执行一遍到结尾结束

作者: 莘莘学子 时间: 2015-7-13 00:23
switch语句执行语句case 和default 是同等级关系 , 并且switch语句结束的两种可能 , 1,break中断,程序结束 ; 2,程序运行至末尾结束  .
执行过程中 ,  程序会先查看case语句 , 如果case语句没有找到值, 那么就走default.
这其中会涉及到 case穿透 ,  就是如果case语句或者default  没有break中断语句 , 那么就进行case穿透 , 就是程序一直向下执行,一直到程序末尾 , 程序结束.

图片1.jpg (81.28 KB, 下载次数: 154)

switch

图片1.jpg (81.28 KB, 下载次数: 150)

switch

作者: 编程小黑 时间: 2015-7-13 00:41
已学习，大神啊，这么牛逼

作者: 你说呢 时间: 2015-7-13 12:50
我觉得是会先匹配case中的数据，只有匹配不了的时候才会执行default

作者: 你说呢 时间: 2015-7-13 12:51
无论default那个位置

作者: 0618张军 时间: 2015-7-13 21:10
你是对的，，先执行case,,没有匹配的，执行default

作者: y137123606 时间: 2015-7-13 22:38
有那么详细的简答，我也过来观摩一下吧

作者: 莱克神 时间: 2015-7-13 23:35
不错不错，学习学习

作者: wing-SF 时间: 2015-7-14 07:21
在这里借楼上哥们的代码，给你说下，你的问题，希望能有所帮助
首先，这句话是有问题的，在switch语句中，肯定首先执行case语句，然后执行default语句；
情况1：如果case中的value值没有匹配的，那么会在所有的case检查过后，执行defaule语句
情况2：如果default语句中没有break语句，那么在default中的语句执行完后，接下来会顺序执行下面的代码，直到遇到break或者大括号“}”

如下代码，case值不匹配，那么最后会执行default语句，default语句执行完后，顺序执行case3，然后遇到大括号结束整个代码块（ps：能叫代码块不，我也不知道雷。。。）
int a=1;
switch (a) {

      case 2:
         printf("exe case 2\n");
、
      default:
         printf("exe default\n");

      case 3:
         printf("exe case 3\n");

}

作者: hakey 时间: 2015-7-15 11:08
看完了，相信楼主已经得到了答案，上面的回复说得很清楚了。

作者: 黑马无敌 时间: 2015-7-15 19:11
谢谢大家，我已经明白了

作者: 反文旁 时间: 2015-7-15 23:48
default确实可以放在switch的任意位置，如果放在第一行，switch还是会先执行“找case”，也就是执行expression那个部分。如果所有的case中没有满足条件的，然后才开始执行default，然后就是直接执行到break或者执行完了。

也就说，“不管expression与case中的value是否匹配”这段话是错的

作者: zhuhoulin 时间: 2015-7-16 20:20
default是默认的情况，在没有任何匹配的情况下的输出值，如果有匹配的话，就不会执行default语句

作者: nine789 时间: 2015-7-16 20:34
本帖最后由 nine789 于 2015-7-16 20:38 编辑

这句话是对的，default放在第一行的话，程序还是会从第一个case执行，当所有case都不匹配的时候，default会开始执行，如果default不在最后一行的时候，default会继续往下执行，当执行到第一个break出现的时候才会跳出，

作者: nine789 时间: 2015-7-16 20:39

猫咪先生发表于 2015-7-12 15:51
当default出现在第一行时程序还是会先去从case开始去找匹配对象，当case中没有匹的，则执行default，执行完 ...

这个是对的

作者: 醉演星松 时间: 2015-7-16 23:41
不对，首先expression与case中的value向比较，如果有匹配的话，就从这个“case”开始执行，并依次往下执行，如果遇到break就提出，如果没有break,依次按顺序执行完所有的语句，自然结束，即使default放在第一行也不会执行。如果所有的value都不匹配就从第一行的default依次往下执行，遇到break退出，没有遇到break一直向下执行，自然结束

作者: 408205555 时间: 2015-7-18 19:55
楼主，你上面说的这些话是错误的。
首先default 默认的意思。
在switch（）语句块中，当（）中的变量、常量或者表达式的值与switch语句块中任何一个case的值相符，就会执行所符合case语句块中的代码。
如果没有符合的case块，则会执行默认的代码块，也就是default代码块。
如果把default放到switch语句块第一的位置，如果这个代码块中没有break，那么default代码块会像case代码块不加break一样，都具有穿透性（也就是执行完default的代码后，会继续向下执行，直到第一个break出现）。
如果位于switch语句块中第一位置的default代码块中有break，那么它就不具备穿透性，也就不会继续向下执行代码，在执行完default代码块中break之前的代码后，就会跳出switch代码块。
如果把default放到switch语句块最后的位置，无论default代码块中有没有break，都会跳出switch代码块，因为程序代码是从上向下运行。default已经是switch中最后一个代码块，执行完default的代码后，就相当于完成了整个switch代码块的代码，即使没有berak，也不会去执行其他case块的代码。

作者: 赵振邦 时间: 2015-7-18 20:41
如果找不到break 就会 case穿透。

作者: 加多宝 时间: 2015-7-18 21:35
先执行case,再执行default

作者: 编程小黑 时间: 2015-7-19 11:50
/*
switch的语句格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
...
default:
执行语句；
break；
}
/*
关于default的问题，一下几点需要注意一下：
一:default可以省略吗?可以。
但是，一般不省略，它相当于if的else语句，可以控制所有的非正常情况。
假如你非常明确可以省略，那就省略。
二:break可以省略吗?
放在最后面的default的break是可以省略的。
放在case语句中的break是可以省略的，但是可能结果有问题。
所以，一般不省略。
三:default可以不放在最后面吗?
可以，但是一般都放在最后面。
四:switch语句什么时候结束吗?
遇到break或者执行到switch语句的末尾。

懂了吗？不懂的可以再问~:lol

作者: 潜力良驹 时间: 2015-7-19 21:18
先执行case，找不到匹配的case就去执行default。如果default不是放在末尾，则执行default下面的case，遇到break或者}就退出了。

作者: Wqi 时间: 2015-7-19 22:59
default在第一行，也是先按循序找case执行，case全部不匹配才执行default，然后执行到break退出或者switch结束。

作者: 蓝蓝 时间: 2015-7-20 03:08
我也来学习学习

作者: jk7130866 时间: 2015-7-20 20:41
肯定是错的你在可以试试啊，毕老师的视频也将了，无论default在哪，先匹配case的值，匹配不到在执行Default

作者: a12366456 时间: 2015-7-21 11:56
上面的是错的。首先default可以写在switch结构中的任意位置；如果将default语句放在了第一行，如果case中的value有匹配的，则从这个case开始执行直至遇到break；如果case中没有匹配的，则认为default匹配，就从default开始执行直至遇到break。总结说就是从匹配的分支开始向下执行直至遇到break（其中default也看作和case一样的分支，没有case匹配时default匹配）。所以，如果default和所有的case都不缺少break，default放的位置不影响执行结果。

作者: 王文辉 时间: 2015-7-21 18:22

强强_U00ts 发表于 2015-7-11 17:06
恩恩,学习学习,就是先执行case,再执行default,default未必会执行么??

是先执行case，如果没有匹配的case，才会执行default。与default的位置无关

作者: 强强_U00ts 时间: 2015-7-21 21:42
哦哦,学习了

作者: 黄成祚 时间: 2015-7-23 10:27
学习学习

作者: tsldxszd 时间: 2015-7-24 10:00

扶摇丶发表于 2015-7-12 00:14
我们老师曾经举过一个例子,记得不太清了，大概就是：把switch语句看成仓库； break 看成仓库管理员；Case ...

例子不错

作者: 王庆艳 时间: 2015-7-24 22:23
后面说错了，即使default放在最前面，程序也是从第一个case值开始执行，最后都没有匹配值才在default上找

作者: guohuaxin 时间: 2015-7-24 23:21
不是的，与case的值不匹配后，才开始从default处执行，直到遇到break

作者: 1158865593 时间: 2015-7-25 07:13
这个没有错，因为如果第一个case中得值没有符合要求的话就会判断下一个case的值，如果所有case的值都不满足的话，就会执行default语句

作者: wayonEmes 时间: 2015-7-25 18:26
本帖最后由 wayonEmes 于 2015-7-25 18:32 编辑

是这样的,无论default在任何位置,switch语句都是从上往下的第一个case开始匹配,如果匹配到合适的case,那么就不再进行判断,直接运行下面的语句直到遇到break或执行到最后一行;如果没有匹配到合适的case,就执行default中的语句,然后一直执行到最后一行或遇到break
比如
int a =1;
switch(a){
case 1:
System.out.println("a=1"); break;
default:
System.out.println("haha");
}
那么输出结果是:

a=1

int a =1;
switch(a){
case 1:
System.out.println("a=1");//注意:没有break default:
System.out.println("haha");
}
那么输出结果是:

a=1
haha

int a =2;//a变成了2
switch(a){
default:
System.out.println("haha");
case 1:
System.out.println("a=1");}
那么输出结果是:

haha
a=1

作者: DreamStart 时间: 2015-7-28 10:52
先执行case语句再执行default

作者: 黄新宇 时间: 2015-7-28 14:31
学习学习

作者: kang13 时间: 2015-7-29 00:05
是错的首先应该是从第一case执行

作者: 任利康 时间: 2015-7-29 12:06
学习学习..

作者: hellojavacode 时间: 2015-7-29 12:47
这个应该是错的，default是当switch(a)中a没有对应选项时才会去进行default选项的。

作者: qq358556392 时间: 2015-7-31 22:36
同样有困惑

作者: 苍雪 时间: 2015-8-1 19:09
不管default放在前面，后面，还是中间，都应该先匹配其他的case取值，如果都找不到最后才匹配default（当然default就是为了其他case取值都不匹配express的情况而存在的，所以default要最后才匹配）。当匹配成功后，会开始执行语句，如果匹配成功的语句执行结束后，也没有遇到break或者大括号下部，这时候程序会继续按照从上到下的顺序，执行其他匹配不成功的语句，直到遇到第一个break或者大括号下部，跳出循环。
楼主啥时候给分啊，我看这提问时间，楼主是弃楼了么？

作者: CtrlChengAo 时间: 2015-8-1 21:20
先纠正你一点，如果执行语句中有break，那么就会停止执行。如果没有break才行在case执行完后执行default，default仍然没有break的话，才会继续向下执行，知道碰到第一个break，或者说是把代码执行完。

作者: HOTSUMMER 时间: 2015-8-1 22:48
default可以放在代码块任何位置，但是从case开始匹配，到break退出，如果没有合适的case 执行default，到break退出，如果没有break，执行到代码块结束退出

作者: zlsucceed 时间: 2015-8-3 23:49
这句话是正确的，default可以放在最上面，但是执行的话还是从case开始执行的，遇到break就停止了，希望我说的对你是有帮助的谢谢

作者: Marx_D 时间: 2015-8-4 21:44
先执行case，default 是最后在执行的。

作者: 徐鹏辰 时间: 2015-8-4 23:23
default可以写在switch结构中的任意位置；是对的，后半句错误
如果将default语句放在了第一行，程序仍会从catch开始执行，
若有匹配的，则直接执行，到break结束；
若无匹配的，则执行default执行到break或}结束（在此期间不进行判断）。

作者: shine1 时间: 2015-8-5 17:52
本来想解答，但看到楼上的回答都挺详细的，我就不多说了。关键：1，无论怎样的顺序，都是先执行case,当case的值都不符合时，擦会执行default。2，在所有的case中，一般都应该有break。如果break不全的话，就会从符合条件的值开始执行，直到遇到下一个break。

作者: Gaoyunhe 时间: 2015-8-6 21:39
switch语句是个选择语句
   switch语句格式：
            switch(表达式) {
                     case 值1：
                              语句体1;
                              break;
                  case 值2：
                              语句体2;
                              break;
                  …
                  default：
                              语句 n;
                              break;
            }

作者: 径直上漠北 时间: 2015-8-8 23:40
为什么问题屏蔽了，

作者: 放学后来我家 时间: 2015-8-12 17:09
好迷糊啊

作者: code_linux 时间: 2015-8-15 13:26
default不管放在哪里都是最后执行的

作者: dzb5461883 时间: 2015-8-16 20:01
顶一个{:2_30:}

作者: 会长大的小牛 时间: 2015-11-6 21:36
最后执行default 前面后面都一样

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2