Java基础学习（04Java程序控制）

    本章内容主要为Java程序控制，包括：循环控制、判断控制和跳转控制。

循环控制：

    循环从字面理解就是重复做某一件事，在程序中当某一条件成立时，程序重复执行一条或多条语句，直到循环条件不成立时结束。循环语句也称为迭代语句，在使用过程中需要小心，死循环不是我们期待的效果。

    while循环：

    while循环是一种最基本的循环语句，循环条件只接受布尔值（也就是真或假），当条件为真时程序反复执行循环体中的代码，每次循环验证一次条件，当条件为假时退出循环，执行循环题后面的语句。

1. while(true)
2. {
3.     /*
4.      * 循环体内的代码
5.      */
6. }

    例：while循环（4.1）

1. package net.miqiang;
3. /**
4.  * 例：while循环
5.  * 一个简单的循环，条件是 i < 5，每循环一次，i 的值增加 1 ，在控制台显示出每次循环 i 的值。
6.  * 一个稍微复杂点的循环，循环条件是 i < j ，每循环一次 i 的值增加 1 ，j 的值减少 1 ，在控制台显示出每次循环 i 和 j 的值。
7.  * 
8.  * @author 米强
9.  * @version 1.0
10.  */
11. public class TestMain {
13.     /**
14.      * 构造方法
15.      * 
16.      */
17.     public TestMain() {
18.         /*
19.          * 一个简单的循环，条件是 i < 5，每循环一次，i 的值增加 1 ，在控制台显示出每次循环 i 的值。
20.          */
21.         int i = 0;
22.         while (i < 5) {
23.             i++;
24.             System.out.println("number: " + i);
25.         }
27.         /*
28.          * 一个稍微复杂点的循环，循环条件是 i < j ，每循环一次 i 的值增加 1 ，j 的值减少 1 ，在控制台显示出每次循环 i 和 j
29.          * 的值。
30.          */
31.         i = 0;
32.         int j = 20;
33.         while(i < j){
34.             i++;
35.             j--;
36.             System.out.println("i = " + i + ";/tj = " + j);
37.         }
38.     }
40.     /**
41.      * 程序入口
42.      * 
43.      * @param args
44.      *            字符串数组参数
45.      */
46.     public static void main(String[] args) {
47.         new TestMain();
48.     }
50. }

    do-while循环：

    刚才我们讲到的while循环，从流程上来说是先判断条件，当条件成立再执行语句。而do-while循环则是先执行语句，再判断条件，可想而知，无论条件是否成立，循环体内的语句都将至少执行一次。

1. do{
2.     /*
3.      * 循环体内的语句至少会执行一次
4.      */
5. }while(true)

    例：do-while循环（4.2）

1. package net.miqiang;
3. /**
4.  * 例：do-while循环
5.  * 使用do-while实现一个简单的循环，条件是 i < 5，每循环一次，i 的值增加 1 ，在控制台显示出每次循环 i 的值。
6.  * 使用do-while实现一个稍微复杂点的循环，循环条件是 i < j ，每循环一次 i 的值增加 1 ，j 的值减少 1 ，在控制台显示出每次循环 i 和 j 的值。
7.  * 
8.  * @author 米强
9.  * @version 1.0
10.  */
11. public class TestMain {
13.     /**
14.      * 构造方法
15.      * 
16.      */
17.     public TestMain() {
18.         /*
19.          * 使用do-while实现一个简单的循环，条件是 i < 5，每循环一次，i 的值增加 1 ，在控制台显示出每次循环 i 的值。
20.          */
21.         int i = 0; // 如果把 i 的值改为 5 ，试试看结果如何
22.         do {
23.             i++;
24.             System.out.println("number: " + i);
25.         } while (i < 5);
27.         /*
28.          * 使用do-while实现一个稍微复杂点的循环，循环条件是 i < j ，每循环一次 i 的值增加 1 ，j 的值减少 1
29.          * ，在控制台显示出每次循环 i 和 j 的值。
30.          */
31.         i = 0;
32.         int j = 20;
33.         do {
34.             i++;
35.             j--;
36.             System.out.println("i = " + i + ";/tj = " + j);
37.         } while (i < j);
38.     }
40.     /**
41.      * 程序入口
42.      * 
43.      * @param args
44.      *            字符串数组参数
45.      */
46.     public static void main(String[] args) {
47.         new TestMain();
48.     }
50. }

    for循环：

    for循环是使用率较高的一种循环语法，基本格式如下：

1. for(initialization; condition; iteration) {
2.     /*
3.      * 循环体语句
4.      */
5. }

    initialization：初始化变量，变量为int类型；

    condition：控制条件，表达式值为boolean类型；

    iteration：迭代部分，最常见的是对变量的++操作或--操作。

    注：for循环语法中，只要括号内两个分号“;”存在就能运行，但是程序会陷入死循环。

1. for( ; ; )
2. {
3.     // 死循环
4. }

    for循环还可以写成这样：

1. for( ; true; )
2. {
3.     // 死循环
4. }

    例：for循环（4.3）

1. package net.miqiang;
3. /**
4.  * 例：for循环
5.  * 一个基本的 for 循环
6.  * 一个经过演化的 for 循环
7.  * 
8.  * @author 米强
9.  * @version 1.0
10.  */
11. public class TestMain {
13.     /**
14.      * 构造方法
15.      * 
16.      */
17.     public TestMain() {
18.         /*
19.          * 一个基本的 for 循环
20.          */
21.         for(int i = 0; i < 5; i++){
22.             System.out.println("* number: " + i);
23.         }
24.         
25.         /*
26.          * 一个经过演化的 for 循环
27.          */
28.         int i = 0;
29.         boolean b = true;
30.         for( ; b; ){
31.             System.out.println("> number: " + i);
32.             if(i >= 5){
33.                 b = false;
34.             }
35.             i++;
36.         }
37.     }
39.     /**
40.      * 程序入口
41.      * 
42.      * @param args
43.      *            字符串数组参数
44.      */
45.     public static void main(String[] args) {
46.         new TestMain();
47.     }
49. }

    例：运用for循环在控制台打印“九九乘法表”（4.4）（本章源码包中）

 

    for-each循环：

    自Java5.0后，出现了for-each形式循环，格式如下：

1. for ( type  itr-var : collection )
2. {
3.     // 循环体
4. }

    type：类型；

    itr-var：迭代变量名；

    collection：需要循环的集合。

 

    例：for-each循环（4.5）

1. package net.miqiang;
3. import java.util.Vector;
5. /**
6.  * 例：for-each循环
7.  * 使用 for-each 循环遍历数组中的每个元素。
8.  * 
9.  * @author 米强
10.  * @version 1.0
11.  */
12. public class TestMain {
14.     /**
15.      * 构造方法
16.      * 
17.      */
18.     public TestMain() {
19.         // int 型数组
20.         int [] intArr = {3, 80, 195, 14, 52, 625, 217, 410, 193};
21.         // String 型数组
22.         String [] strArr = {"a", "b", "c", "d", "e"};
23.         // 遍历 int 型数组的每个元素
24.         for(int i : intArr){
25.             System.out.println(i);
26.         }
27.         // 遍历 String 型数组的每个元素
28.         for(String str : strArr){
29.             System.out.println(str);
30.         }
31.         // 声明一个 Vector 向量
32.         Vector<String> v = new Vector<String>();
33.         // 通过循环给 Vector 向量添加 10 个元素
34.         for(int i = 0; i < 10; i++){
35.             v.add("Vector_" + i);
36.         }
37.         // 遍历这个 Vector 向量的所有元素值
38.         for(Object o : v){
39.             System.out.println(o);
40.         }
41.     }
43.     /**
44.      * 程序入口
45.      * 
46.      * @param args
47.      *            字符串数组参数
48.      */
49.     public static void main(String[] args) {
50.         new TestMain();
51.     }
53. }

判断语句：

    Java提供了两种判断语句，if语句和switch语句。

    if语句：

    if语句语法如下：

1. if ( condition ) {
2.     // 语句 1
3. } else {
4.     // 语句 2
5. }

    condition：代表条件表达式，值为boolean类型，当值为true时执行语句1的代码，当值为false时执行语句2中的代码。

    if语句可以省略else和其后的语句块。

1. if ( condition ) {
2.     // 语句
3. }

    if语句可以嵌套运算：

1. if ( condition1 ) {
2.     if ( condition2 ) {
3.         // 语句块1
4.     } else {
5.         // 语句块2
6.     }
7. }

    if语句还可以支持多条件来选择执行某一操作，由一个if，若干个else if和else构成：

1. if ( condition1 ) {
2.     // 如果条件1成立，执行这里
3. } else if ( condition2 ){
4.     // 否则，如果条件2成立，执行这里
5. } else if ( condition3 ){
6.     // 否则，如果条件3成立，执行这里
7. } else {
8.     // 否则执行这里（以上条件均不成立）
9. }

    例：if语句（4.6）

1. package net.miqiang;
3. /**
4.  * 例：if语句
5.  * 演示最基本的 if 语句
6.  * 演示嵌套 if 语句
7.  * 演示多条件 if 语句
8.  * 
9.  * @author 米强
10.  * @version 1.0
11.  */
12. public class TestMain {
14.     /**
15.      * 构造方法
16.      * 
17.      */
18.     public TestMain() {
19.         /*
20.          * 演示最基本的 if 语句。
21.          */
22.         int i = 10;
23.         int j = 5;
24.         if(i < j){
25.             i = 0;
26.         }else{
27.             j = 0;
28.         }
29.         System.out.println("i = " + i + ";/tj = " + j);
30.         
31.         /*
32.          * 演示嵌套 if 语句
33.          */
34.         if(j == 0){
35.             if(i == 0){
36.                 i++;
37.             }else{
38.                 j++;
39.             }
40.         }
41.         System.out.println("i = " + i + ";/tj = " + j);
42.         
43.         /*
44.          * 演示多条件 if 语句
45.          */
46.         if(i < 3){
47.             System.out.println("i < 3");
48.         }else if(i < 6){
49.             System.out.println("i < 6 AND i >= 3");
50.         }else if(i < 9){
51.             System.out.println("i < 9 AND i >= 6");
52.         }else{
53.             System.out.println("i >= 9");
54.         }
55.     }
57.     /**
58.      * 程序入口
59.      * 
60.      * @param args
61.      *            字符串数组参数
62.      */
63.     public static void main(String[] args) {
64.         new TestMain();
65.     }
67. }

    switch语句：

    switch语句是多分支选择语句，格式如下：

1. switch ( expression ) {
2.     case  value1:
3.         // 语句1
4.         break;
5.     ……
6.     case  valueN:
7.         // 语句N
8.         break;
9.     default:
10.         // 语句default
11. }

    switch语句后面括号中的表达式值一定为一个整型或字符型变量，value1～valueN也必须对应为整型或字符型。switch语句执行时使用expression值从value1开始对比，遇到相同值则执行case value后面的语句，碰到break语句停止。如果测试完所有value值都不相等，则执行default后面的语句。

    例：某校考试，需要对所有学生成绩进行分组，0～59分为“差组”，60～79分为“良组”，80～100分为“优组”（4.7）（实例在本章源码包中）

 

跳转控制：

    Java提供了三种跳转控制语句，break语句、continue语句和return语句。

    break语句：

    break语句为跳出语句，除了和switch语句结合使用外，还可以用来跳出循环。

    

    例：break语句（4.8）

1. package net.miqiang;
3. /**
4.  * 例：break语句
5.  * 示范 break 语句强制跳出循环
6.  * 
7.  * @author 米强
8.  * @version 1.0
9.  */
10. public class TestMain {
12.     /**
13.      * 构造方法
14.      * 
15.      */
16.     public TestMain() {
17.         // 记录循环次数的变量 i
18.         int i = 0;
19.         // 开始循环
20.         while(true){
21.             System.out.println("i = " + i + ";");
22.             i++;
23.             // 如果 i 的值大于 10 ，则使用 break 语句强制跳出循环体
24.             if(i > 10){
25.                 break;
26.             }
27.         }
28.         // 将完成信息显示到控制台中
29.         System.out.println("循环已完成！");
30.     }
32.     /**
33.      * 程序入口
34.      * 
35.      * @param args
36.      *            字符串数组参数
37.      */
38.     public static void main(String[] args) {
39.         new TestMain();
40.     }
42. }

    continue语句：

    在循环中碰到了continue语句后，程序将不再执行continue语句之后的语句，改而重新判断循环条件。

    例：continue语句（4.9）

1. package net.miqiang;
3. /**
4.  * 例：continue语句
5.  * 示范 continue 语句，使程序不再执行 continue 之后的语句，转而重新判断循环条件。
6.  * 
7.  * @author 米强
8.  * @version 1.0
9.  */
10. public class TestMain {
12.     /**
13.      * 构造方法
14.      * 
15.      */
16.     public TestMain() {
17.         // 使用 for 循环显示由 0～9 行字符串
18.         for(int i = 0; i < 10; i++){
19.             // 显示 start 字符
20.             System.out.print("start/t");
21.             // 显示行号
22.             System.out.print("i = " + i + ";");
23.             // 如果行号为双数
24.             if(i % 2 == 0){
25.                 // 换行
26.                 System.out.print("/n");
27.                 // 不再执行 continue 之后的语句，转而重新判断循环条件
28.                 continue;
29.             }
30.             // 显示该行结束字符
31.             System.out.print("/tend/n");
32.         }
33.         // 将完成信息显示到控制台中
34.         System.out.println("循环已完成！");
35.     }
37.     /**
38.      * 程序入口
39.      * 
40.      * @param args
41.      *            字符串数组参数
42.      */
43.     public static void main(String[] args) {
44.         new TestMain();
45.     }
47. }

    return语句：

    程序中碰到了return语句，程序将不再执行return语句之后的任何语句。

    例：return语句（4.10）

1. package net.miqiang;
3. /**
4.  * 例：return语句
5.  * 示范使用 return 语句中断程序执行流程。
6.  * 
7.  * @author 米强
8.  * @version 1.0
9.  */
10. public class TestMain {
12.     /**
13.      * 构造方法
14.      * 
15.      */
16.     public TestMain() {
17.         // 使用 for 循环显示由 0～9 行字符串
18.         for(int i = 0; i < 10; i++){
19.             // 显示行号
20.             System.out.println("i = " + i + ";");
21.             // 如果行号大于 5
22.             if(i > 5){
23.                 // 使用 return 语句中断程序执行流程
24.                 return;
25.             }
26.         }
27.         // 将完成信息显示到控制台中
28.         System.out.println("循环已完成！");
29.     }
31.     /**
32.      * 程序入口
33.      * 
34.      * @param args
35.      *            字符串数组参数
36.      */
37.     public static void main(String[] args) {
38.         new TestMain();
39.     }
41. }

 

本章实例：

    编程计算某日期是该年度的第几天，要求判断月与日是否符合日期规范，并需要考虑闰年的二月问题。（4.11）（本章源码包中）

 

本章源码包下载：

http://download.csdn.net/source/631920