package test;

public class Test {
        public static void main(String[] args) {
                int a=1,b=0;
                switch(a){
                        case 1:
                                switch(b){
                                case 0:
                                        System.out.println(3);
                                        break;
                                }
                                case 2:
                                        System.out.println(5);
                }
        }
}
结果是：
3
5

第一个switch(a)比较a当a与下面case中的某一个相等时，该case后面的语句被执行，因为a等于1 case 1后面的语句被执行，因b=0case 0后面的代码被执行，因为楼主switc(a)中的case1 后面没有加break语句，所以case1执行完后接着又执行了case2，才会出现这样的结果，如果楼主不想case2运行，可以在case1后加break语句，

1. //一旦case匹配,就会顺序执行后面的程序代码,而不管后面的case是否匹配,直到遇见break,
   
2. public class test {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int a=1,b=0;
   
6.                 switch(a)
   
7.                 {
   
8.                         case 1://这里匹配  但是结束这个语句没有break
   
9.                                 switch(b)
   
10.                                 {
    
11.                                         case 0:
    
12.                                                 System.out.println(3);
    
13.                                                 break;//这个不是case得break
    
14.                                 }
    
15.                         case 2://所以case 2也执行
    
16.                             System.out.println(5);
    
17.                 }
    
18.         }
    
19. }

复制代码

yanzhendong 发表于 2014-3-23 19:32
第一个switch(a)比较a当a与下面case中的某一个相等时，该case后面的语句被执行，因为a等于1 case 1后面的语 ...

恩恩，明白了谢谢

赵彦丰 发表于 2014-3-23 19:44

恩恩，非常感谢

原因在注释里：

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 int a = 1, b = 0;
   
4.                 switch (a) {
   
5.                 case 1:
   
6.                         switch (b) {
   
7.                         case 0:
   
8.                                 System.out.println(3);
   
9.                                 break[color=Red];//此处跳出的是switch(b)[/color]
   
10.                         }
    
11.                         [color=Red]//跳到这里，因为这里并没有break，继续执行case 2:[/color]
    
12.                 case 2:
    
13.                         System.out.println(5);
    
14.                 }
    
15.         }
    
16. }

复制代码

请跟下边程序比较

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 int a = 1, b = 0;
   
4.                 switch (a) {
   
5.                 case 1:
   
6.                         switch (b) {
   
7.                         case 0:
   
8.                                 System.out.println(3);
   
9.                                 break;//此处跳出的是switch(b)
   
10.                         }
    
11.                         [color=Red]break[/color];//跳到这里，遇到swtich(a) case 1的break
    
12.                 case 2:
    
13.                         System.out.println(5);
    
14.                 }
    
15.         }
    
16. }

复制代码

switch里的参数只与当前括号里的case后面的值作比较

   

package test;

public class Test {
        public static void main(String[] args) {
                int a=1,b=0;
                switch(a){
                        case 1://a的值为1  进入这个选择
                                switch(b){//b的值为0，进入这个选择
                                case 0:
                                        System.out.println(3);//输出3
                                        break;//跳出   switch(b){}语句
                                }
                                case 2://由于 switch(a){}语句中的 case1 没有break；，switch语句的穿透性，执行//case2
                                        System.out.println(5);//输出5
                }
        }
}
结果写在了注释中~

1. 
   
2. package test;
   
3. 
   
4. public class Test {
   
5.         public static void main(String[] args) {
   
6.                 int a=1,b=0;
   
7.                 switch(a){
   
8.                         case 1:
   
9.                                 switch(b){
   
10.                                 case 0:
    
11.                                         System.out.println(3);
    
12.                                         break;
    
13.                                 }
    
14.                                 break;        //要在这里加一个break,才能跳出外层switch；否则就依次执行下面的语句，直到执行break；
    
15.                                 case 2:
    
16.                                         System.out.println(5);
    
17.                                 case 1000:
    
18.                                         System.out.println(1000);        //如果加上这一条也会执行。
    
19.                 }
    
20.         }
    
21. }

复制代码

打印3，楼主肯定没有疑问，主要就是5这里。
switch语句，每一个case都要有一个break。否则，如果case的条件成立，就会依次执行下面的语句，直到碰到break，或switch语句结束。

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 int a=1,b=0;
   
4.                 switch(a){ //这个是判断如果a是几就打印case几对用的输出语句
   
5.                         case 1:
   
6.                                 switch(b){
   
7.                                 case 0:
   
8.                                         System.out.println(3);
   
9.                                                                                 //这个break只是把switch(b)给结束了但是switch(a)这个循环缺没有结束。
   
10.                                                                                 //而switch(a)中的case 1却没有结束语句。所以在打印3之后。跳出switch(b)这个循环
    
11.                                                                                 //进入switch(a)的case 1这个循环。而case 1这个循环因为没有碰到break停止。接着就
    
12.                                                                                 //打印了5，打印完5之后没有要打印的语句了。所以就退出循环。
    
13.                                                                                 //所以打印的结果为3 5.
    
14.                                                                                 //记住，在switch循环中没个case后面都要加上break；如果不加break的话，就会
    
15.                                                                                 //一直循环到这个循环中没有要打印的语句才会跳出循环。
    
16.                                         break;
    
17.                                 }
    
18.                                 case 2:
    
19.                                         System.out.println(5);
    
20.                 }
    
21.         }
    
22. }

复制代码