java的基本语言元素--流程控制语句

流程控制语句的使用

话到这里，就来到了一个重要的部分：Java的程序流程控制语句的使用。

之所以使用流程控制语句，是因为一个程序的运行都是有序的，通常都是按照代码的书写顺序从上到下，从左到右进行执行。这一过程被称为顺序执行。

但实际开发中，我们通常都要根据实际需求，对程序的运行方式做一些目的性的改变，例如加一些条件判断等等。

于是，这个时候就必须用到流程控制语句，来进行程序流程的控制工作了。

Java中，主要的流程控制语句分为三种：选择/条件语句，循环语句，跳转语句。

一、选择/条件语句

顾名思义，就是指一段程序根据条件判断之后，根据判断结果再选择不同的处理方式的语句结构。

而必须铭记的是：条件语句的判断条件必须满足是boolean类型的数据。即：

条件只可以是一个boolean类型的值；是一个boolean类型的变量；或是一个返回boolean类型值的表达式。

1.1、if条件语句.

最简单的条件语句，作为条件分支语句，可以控制程序选择不同的处理方式执行。有三种表现形式：

第一种表现形式：if。

通常用于只有当满足某个条件，才具备程序继续执行的资格的情况。例如：判断一个人的年龄，只有判断结果为成年，才能继续执行相关代码：

[java]  view plain  copy

1. private void if_Demo_1(int age) {  
2.     if (age >= 18) {  
3.         System.out.println("已成年，可以执行相关代码..");  
4.         //上网..  
5.         //饮酒..  
6.     }  
7. }  

第二种表现形式：if - else。

通常用于条件判断可能存在两种结果的情况.例如，判断一个人的性别，性别非男即女：

[java]  view plain  copy

1. private void if_Demo_2(String gender) {  
2.     if (gender.equals("male")) {  
3.         System.out.println("男性");  
4.     } else {  
5.         System.out.println("女性");  
6.     }  
7. }  

第三种表现形式：if - else if - else。

通常用于当条件判断可能存在两种以上结果的情况。例如，判断两个数a与b的大小，则可能存在a大于b，b大于a或二者相等的三种情况：

[java]  view plain  copy

1. private void if_Demo_2(int a, int b) {  
2.     if (a > b) {  
3.         System.out.println(a + "大于" + b);  
4.     } else if (a < b) {  
5.         System.out.println(b + "大于" + a);  
6.     } else {  
7.         System.out.println(a + "等于" + b);  
8.     }  
9. }  

最后顺带一提的就是，某些情况下会存在：仅仅通过一次条件判断，还无法选择正确的处理方式的情况。这时就可以通过对if语句嵌套，完成多次判断：

[java]  view plain  copy

1. /* 
2.  * 一家俱乐部，只针对年满18岁的女性营业 
3.  */  
4. private void if_Demo_4(String gender, int age) {  
5.     if (gender.equals("male")) {  
6.         if (age >= 18) {  
7.             System.out.println("欢迎观临.");  
8.         } else {  
9.             System.out.println("对不起，您未满18岁!");  
10.         }  
11.     } else {  
12.         System.out.println("对不起，我们只针对女性营业!");  
13.     }  
14. }  

1.2、switch条件/选择语句

我们注意到在if语句的使用中，如果当条件判断存在多种结果的时候，则必须使用“if - else if - else”的方式来处理。

那自然我们可以想象如果当一个条件存在大量的可能结果时，我们可能就必须书写大量的else if语句，这样做可能会比较麻烦。

针对于这样的情况，Java提供了另一种相对简单一些的形式，就是switch条件语句。对于switch语句，值得注意的是：

其接受的条件只能是一个整型数据或枚举常量，只是在JDK1.7之后又新支持了String类型。

而同时我们知道Java中支持数据类型转换，而byte,short,char都可以被隐式的自动转换为int。

所以通常来说：switch语句所能接受的条件只能是byte,short,int,char或枚举类型的数据。

正是因为如此，所以switch语句相对于if语句而言，本身存在一定的局限性。

通常来说，一个switch语句的定义格式为：

[java]  view plain  copy

1. switch (key) {  
2. case value:  
3.       
4.     break;  
5.   
6. default:  
7.     break;  
8. }  

举例而言，假设我们通过用户输入的一个整数，来查询对应的星期数:

[java]  view plain  copy

1. private void switch_demo(int num) {  
2.     switch (num) {  
3.     case 1:  
4.         System.out.println("星期一");  
5.         break;  
6.     case 2:  
7.         System.out.println("星期二");  
8.         break;  
9.     case 3:  
10.         System.out.println("星期三");  
11.         break;  
12.     case 4:  
13.         System.out.println("星期四");  
14.         break;  
15.     case 5:  
16.         System.out.println("星期五");  
17.         break;  
18.     case 6:  
19.         System.out.println("星期六");  
20.         break;  
21.     case 7:  
22.         System.out.println("星期日");  
23.         break;  
24.   
25.     default:  
26.         System.out.println("没有对应的星期数");  
27.         break;  
28.     }  
29. }  

swtich语句的执行过程是这样的，首先计算条件表达式的值，然后根据值分别对每个case进行匹配工作。

假如找到对应的匹配，则执行该case值下的程序语句；如果没有匹配的case值，则执行default下的程序语句。

在执行完case的语句块后，应当使用跳转语句break语句跳出该switch语句。

因为如果没有添加break语句，程序在执行完匹配的case值下的程序语句后，

并不会停止，而是将会连续执行下一个case值下的代码，直到碰到break语句为止。

多重if和switch的区别

我们已经知道在某些情况下，多重if和switch是可以完成相同的目的的。而它们最大的区别就在于：

switch语句局限性更大，这是因为我们说过了：switch语句只能对类型为byte,short,int,long或枚举的数据的具体值进行判断。

但if既可以对具体的值进行判断；也可以进行区间判断；同时还可以对返回值类型为boolean类型的表达式进行判断，如：

[java]  view plain  copy

1. public void ifTest(int a, char c,String s) {  
2.     //对具体的值进行判断  
3.     if(a == 5);  
4.     if(c == 'a');  
5.     if(s.equals("s"));  
6.     //对区间进行判断  
7.     if(a>5&&a<=10);  
8.     //对返回值为boolean类型的表达式进行判断  
9.     if(a>=c);      
10. }  

而网上很多人说，switch语句的效率相对高于if语句。这是因为：switch语句会将所有可能情况的代码语句一次性都加载进内存，所以在执行时效率相对较高。

但因为其本身的局限性，所以在实际开发中，还是因该根据实际需求选择最合适的做法。

二、循环语句

顾名思义，循环语句也就是指用于控制同一段程序反复多次运行的语句。Java中循环语句有三种，分别为：while、do-while以及for循环。

可以说，三种循环语句之间的区别实际不大，但同时也可以说都有本质的区别。下面我们分别来看一下三种循环的原理和使用。

2.1、while循环语句

[java]  view plain  copy

1. /* 
2.  * while循环语句的定义格式为： 
3.  * while(条件){ 
4.  *   //循环内容.. 
5.  * } 
6.  */  
7. private void while_demo(int a){  
8.     while(a < 20){  
9.         System.out.println(++a);  
10.     }  
11. }  

与if条件语句相同，while语句也会接受一个boolean类型的值作为条件。

当该条件判断为true时，则会循环执行循环体的内容；当执行到条件判断结果为false时，就会结束循环。

2.2、do-while循环语句

[java]  view plain  copy

1. /* 
2.  * do-while循环语句的定义格式为： 
3.  * do { 
4.     //循环体    
5.        } while (condition); 
6.  */  
7. private void do_while_demo(int a){  
8.     do {  
9.         System.out.println("执行一次循环:"+(++a));  
10.     } while (a<20);  
11. }  

do-while循环与while循环最大的不同就是：无论循环条件的判断结果是否为true，都会至少执行一次循环体中的内容。

之所以Java会单独提供do-while这种循环方式，也正是因为：当使用while循环的时候，如果首次判断循环条件的结果就为假的话，那么该循环就会直接被跳过，根本不会执行。而事实上，我们很多时候会希望循环体至少执行一次。

2.3、for循环语句

[java]  view plain  copy

1. /* 
2.  * for循环的定义格式为： 
3.  * for(初始化表达式；循环条件表达式；迭代运算) 
4.  *  { 
5.  *      执行语句；(循环体) 
6.  *  } 
7.  */  
8. private void for_demo(){  
9.     for (int i = 0; i < 20; i++) {  
10.         System.out.println(++i);  
11.     }  
12. }  

for循环的执行过程为：

1.执行循环的初始化，通过它设置循环的控制变量值

2.判断循环条件：如果为真，则执行循环体内容；如果为假，则退出循环；

3.执行迭代运算。迭代运算通常是一个表达式，用于改变循环控制变量的值。

4.再次执行循环条件判断，然后反复第2-3步的步骤，直到循环条件判断为假时，则退出循环。

需要注意的是：for循环的初始化表达式，只会在循环第一次开始时执行一次；

而迭代运算表达式则会在每一次循环体内容执行完毕后，紧接着执行一次。

可以通过一道网上流传的华为的Java面试题，来更形象的了解for循环的执行特点：

[java]  view plain  copy

1. /*  
2. What is the result?  
3. A. ABDCBDCB  
4. B. ABCDABCD  
5. C. Compilation fails.  
6. D. An exception is thrown at runtime.  
7. */  
8. public class Demo {  
9.     static boolean foo(char c) {  
10.         System.out.print(c);  
11.         return true;  
12.     }  
13.   
14.     public static void main(String[] args) {  
15.         int i = 0;  
16.         //ABDCBDCB  
17.         for (foo('A'); foo('B') && (i < 2); foo('C')) {  
18.             i++;  
19.             foo('D');  
20.         }  
21.     }  
22.          
23. }  

最 终执行的结果为：ABDCBDCB，我们来逐步分解该输出结果形成的原因：

1.for循环第一次开始执行，首先执行循环初始化表达式，于是foo('A')被执行，输出A。此时输出结果为：A

2.紧接着开始执行循环条件判断，于是foo('B')被执行，输出B；接着判断i(0)<2；循环条件判断结果为真。此时输出结果为：AB

3.由于该次判断结果为真，于是开始执行循环体。于是，i自增运算，值变为1；foo('D')被执行，输出D。此时输出结果为：ABD

4.一次循环体内容执行完毕，紧接着开始执行迭代运算表达式：foo('C'),于是输出C。此时输出结果为：ABDC

5.再次开始新一次的循环条件判断，于是foo('B')被执行，输出B；接着判断i(1)<2；循环条件判断结果为真。此时输出结果为：ABDCB

6.再次开始执行循环体。于是i继续自增运算，值变为2；foo('D')被执行，输出D。此时输出结果为：ABDCBD

7.循环体内容又一次执行完毕，同样紧接着开始执行迭代运算表达式：foo('C'),于是再次输出C。此时输出结果为：ABDCBDC

8.进行新一轮的循环条件判断。于是foo('B')被执行，又一次输出B；接着判断i(2)<2，此次循环条件判断结果为假，于是循环到此退出。

所以，最终该程序的运行结果为：ABDCBDCB

while循环与for循环的异同

while循环与for循环之间实际上是可以相互替换的。以常见的数的累加的问题来说，以while循环和for循环分别的实现形式为：

[java]  view plain  copy

1. /* 
2.  * 求1到100之间的数累加的和? 
3.  */  
4. public class Demo {  
5.     private static int for_demo() {  
6.         int sum = 0;  
7.         for (int i = 1; i <= 100; i++) {  
8.             sum += i;  
9.         }  
10.         return sum;  
11.     }  
12.   
13.     private static int while_demo() {  
14.         int sum = 0;  
15.         int i = 0;  
16.         while (i <= 100) {  
17.             sum = sum + (i++);  
18.         }  
19.         return sum;  
20.     }  
21.   
22.     public static void main(String[] args) {  
23.         System.out.println("通过for循环完成累加的值为:" + for_demo());  
24.         System.out.println("通过while循环完成累加的值为:" + while_demo());  
25.     }  
26. }  

而while和for之间唯一的小差就在于：循环控制变量的作用域。 这实际上正是涉及到在这篇博客中提到的代码块的相关知识。 从上面的用例代码中，我们看到：

方法“for_demo”中，用于控制for循环的循环控制变量“i”，被声明在for循环语句内。所以这里的变量“i”实际上，是被声明在for循环语句块当中的局部变量，所以随着for循环语句块的运行结束，该变量就会从内存中释放，走到生命周期的尽头。

反观方法“while_demo”中，用于控制while循环的循环控制变量"i"则只能被声明在属于"while_demo"的方法代码块中，而不属于循环本身。也就是说，就算当while循环运行结束，该循环控制变量依然有效，仍然可以被访问，因为它实际是属于“while_demo”所声明的代码块中。

这也正是我在这个专栏系列里，第一篇文章《第一个专栏《重走J2SE之路》，你是否和我有一样的困扰？ 》中提到的：

为什么查看一些Java的源码时，发现老外很多时候选择使用for循环的原因，也正是因为for循环相对于while循环，可以在很小程度上减少内存的开销，

三、跳转语句

跳转语句是指打破程序的正常运行，跳转到其他部分的语句。Java提供了三种跳转语句，分别为：break、continue以及return。

3.1、break语句

break语句的使用方式主要三种：跳出switch条件语句、跳出循环以及通过代码块的标示符跳出代码块。我们通过一段代码分别看一下它们具体的应用：

[java]  view plain  copy

1. void break_demo(int a) {  
2.     // 跳出switch条件语句  
3.     switch (a) {  
4.     case 1:  
5.         System.out.println();  
6.         break;  
7.   
8.     default:  
9.         break;  
10.     }  
11.   
12.     // 跳出循环  
13.     while (true) {  
14.         if (++a > 50) {  
15.             break;  
16.         }  
17.     }  
18.   
19.     // 跳出代码块  
20.     my_block_1: {  
21.         my_block_2: {  
22.             a++;  
23.             if (a > 5) {  
24.                 break my_block_1;  
25.             }  
26.         }  
27.   
28.     }  
29. }  

值得注意的是：在使用break跳出循环时，只会跳出其所在的循环，而其外部的循环并不会跳出，还会继续运行。

3.2、continue语句

break语句可以用于跳出其所在循环。但是有时我们需要跳出一次循环剩余的循环部分，但同时还要继续下一次循环，这时就用到了continue语句。

[java]  view plain  copy

1.  void continue_demo(){  
2. or (int i = 1; i <= 30; i++) {  
3. System.out.print(i+"\t");  
4.   
5. if(i%5!=0)  
6.     continue;  
7.   
8.     System.out.println("*");  
9. }  

这段代码运行的输出结果为：

这正是continue语句起到的作用，每执行一次循环体的内容。

首先会输出“i”当前的值及一个制表符，然后会判断当前“i”是否是5的倍数。

如果是不是5的倍数，则会通过continue语句结束该次剩余的部分，所以在其之后的输出语句便不会再被执行。

而如果是5的倍数的话，才会执行之后的输出语句，输出一个“*”号，并换行。

由此，最终才出现了上面我们看到的输出效果。

所以，总的来说break与continue的区别就在于：break语句用于退出整个循环；而continue语句则是用于结束该次循环的剩余循环部分，但继续新一次的循环。

3.3、return语句

简单的来说，如果说break用于跳出循环的话，而return语句则是用于结束整个方法并返回。

return语句可以说是实际开发中最常用的跳转语句了，因为任何方法都需要return语句来控制方法的结束并返回对应类型的值。

[java]  view plain  copy

1. void return_demo_1() {  
2.     /* 
3.      * 实际上void返回类型的值，也使用了return。 只不过在以void作为返回类型的方法中，return是隐式的存在的。 
4.      */  
5. }  
6.   
7. int return_demo_2() {  
8.     /* 
9.      * 通过return 
10.      */  
11.     for (int i = 0; i < 5; i++) {  
12.         i++;  
13.         for (int j = 0; j < 20; j++) {  
14.             if (j == 3) {  
15.                 /* 
16.                  * 这里如果使用break,虽然内部循环会被退出，但外部循环仍然会继续执行 
17.                  * 而使用return则意味结束整个方法，并返回值“5”， 
18.                  *  这样做代表这之后的代表将永远没有机会再运行。 
19.                  */  
20.                 return 5;  
21.             }  
22.         }  
23.         // 该语句永远不会被执行到。  
24.         System.out.println("外部循环执行一次..");  
25.     }  
26.     return 0;  
27. }  

到了这里，Java中程序语句的使用，我们已经有了一个不错的了解了。最后，就通过一个实际应用的小例子，输出九九乘法表作为结束吧：

[java]  view plain  copy

1. package com.tsr.j2seoverstudy.base;  
2.   
3. public class Print99 {  
4.     public static void main(String[] args) {  
5.         System.out.println("*******************************九九乘法表********************************");  
6.   
7.         for (int i = 1; i <= 9; i++) {  
8.             System.out.print("\t"+i);  
9.         }  
10.           
11.         System.out.println();  
12.           
13.         for (int i = 1; i <= 9; i++) {  
14.             System.out.print(i+"\t");  
15.             for (int j = 1; j <= i; j++) {  
16.                 System.out.print(i*j+"\t");  
17.             }  
18.             System.out.println();  
19.         }  
20.     }  
21. }  

运行程序，查看其输出结果：