前文

本章是關(guān)于Java流程控制語句的最全匯總，本篇為匯總中篇。

流程是人們生活中不可或缺的一部分，它表示人們每天都在按照一定的流程做事。

比如出門搭車、上班、下班、搭車回家。這其中的步驟是有順序的。

程序設(shè)計(jì)也需要有流程控制語句來完成用戶的要求，根據(jù)用戶的輸入決定程序要進(jìn)入什么流程，即“做什么”以及“怎么做”等。

從結(jié)構(gòu)化程序設(shè)計(jì)角度出發(fā)，程序有 3 種結(jié)構(gòu)：順序結(jié)構(gòu)、選擇結(jié)構(gòu)和循環(huán)結(jié)構(gòu)。

若是在程序中沒有給出特別的執(zhí)行目標(biāo)，系統(tǒng)則默認(rèn)自上而下一行一行地執(zhí)行該程序，這類程序的結(jié)構(gòu)就稱為順序結(jié)構(gòu)。

到目前為止，我們所編寫的程序都屬于順序結(jié)構(gòu)。

但是事物的發(fā)展往往不會(huì)遵循早就設(shè)想好的軌跡進(jìn)行，因此，所設(shè)計(jì)的程序還需要能夠具有在不同的條件下處理不同問題以及當(dāng)需要進(jìn)行一些相同的重復(fù)操作時(shí)，如何能省時(shí)省力地解決問題的能力。

在本章中，我們將對 Java 程序中的上述3種流程結(jié)構(gòu)進(jìn)行學(xué)習(xí)。

初學(xué)者應(yīng)該對本章的每個(gè)小節(jié)進(jìn)行仔細(xì)閱讀、思考，這樣才能達(dá)到事半功倍的效果。

Java switch case語句詳解

if…else 語句可以用來描述一個(gè)“二岔路口”，我們只能選擇其中一條路來繼續(xù)走，然而生活中經(jīng)常會(huì)碰到“多岔路口”的情況。

switch 語句提供了 if 語句的一個(gè)變通形式，可以從多個(gè)語句塊中選擇其中的一個(gè)執(zhí)行。

switch 語句格式

switch 語句是 Java 的多路分支語句。

它提供了一種基于一個(gè)表達(dá)式的值來使程序執(zhí)行不同部分的簡單方法。

因此，它提供了一個(gè)比一系列 if-else-if 語句更好的選擇。

switch 語句的基本語法形式如下所示：

switch(表達(dá)式) {
    case 值1:
        語句塊1;
        break;
    case 值2:
        語句塊2;
        break;
    …
    case 值n:
        語句塊n;
        break;
    default:
        語句塊n+1;
    break;
}

其中，switch、case、default、break 都是 Java 的關(guān)鍵字。

switch

表示“開關(guān)”，這個(gè)開關(guān)就是 switch 關(guān)鍵字后面小括號(hào)里的值，小括號(hào)里要放一個(gè)整型變量或字符型變量。

表達(dá)式必須為 byte，short，int，char類型。

Java7 增強(qiáng)了 switch 語句的功能，允許 switch 語句的控制表達(dá)式是 java.lang.String 類型的變量或表達(dá)式。

只能是 java.lang.String 類型，不能是 StringBuffer 或 StringBuilder 這兩種字符串的類型。

case

表示“情況，情形”，case 標(biāo)簽可以是：

• 類型為 char、byte、 short 或 int 的常量表達(dá)式。
• 枚舉常量。
• 從 Java SE 7 開始， case 標(biāo)簽還可以是字符串字面量。

例如：

String input = ...;
switch (input.toLowerCase()) {  // toLowerCase用于將大寫字符轉(zhuǎn)換為小寫
    case "yes":
        ...
        break;
}

當(dāng)在 switch 語句中使用枚舉常量時(shí)，不必在每個(gè)標(biāo)簽中指明枚舉名，可以由 switch 的表達(dá)式值確定。例如：

Size sz = ...;
switch (sz) {
    case SMALL: // no need to use Size.SMALL
        ...
        break;
    ...
}

注意：重復(fù)的 case 值是不允許的。

default

表示“默認(rèn)”，即其他情況都不滿足。

default 后要緊跟冒號(hào)，default 塊和 case 塊的先后順序可以變動(dòng)，不會(huì)影響程序執(zhí)行結(jié)果。

通常，default 塊放在末尾，也可以省略不寫。

break

表示“停止”，即跳出當(dāng)前結(jié)構(gòu)。

如果在 case 分支語句的末尾沒有 break 語句，有可能觸發(fā)多個(gè) case 分支。

那么就會(huì)接著執(zhí)行下一個(gè) case 分支語句。這種情況相當(dāng)危險(xiǎn)，常常會(huì)引發(fā)錯(cuò)誤。

為此，我們在程序中從不使用 switch 語句。

如果你喜歡 switch 語句，編譯代碼時(shí)可以考慮加上 -Xlint:fallthrough 選項(xiàng)，如下所示：

javac -Xlint:fallthrough Test.java

這樣一來，如果某個(gè)分支最后缺少一個(gè) break 語句，編譯器就會(huì)給出一個(gè)警告消息。

switch 語句的執(zhí)行過程如下：表達(dá)式的值與每個(gè) case 語句中的常量作比較。

如果發(fā)現(xiàn)了一個(gè)與之相匹配的，則執(zhí)行該 case 語句后的代碼。

如果沒有一個(gè) case 常量與表達(dá)式的值相匹配，則執(zhí)行 default 語句。

當(dāng)然，default 語句是可選的。如果沒有相匹配的 case 語句，也沒有 default 語句，則什么也不執(zhí)行。

圖 1 switch語句執(zhí)行流程圖

例 1

在節(jié)目的抽獎(jiǎng)環(huán)節(jié)里，節(jié)目組會(huì)根據(jù)每位嘉賓的座位號(hào)來進(jìn)行抽獎(jiǎng)游戲，根據(jù)不同的號(hào)碼來決定獎(jiǎng)項(xiàng)的大小。

使用 switch 語句編寫 Java 程序來完成獎(jiǎng)項(xiàng)分配，其實(shí)現(xiàn)代碼如下。

public static void main(String[] args) {
    System.out.println("請輸入座位號(hào)碼：");
    Scanner sc = new Scanner(System.in);
    int num = sc.nextInt();
    switch (num) {
    case 8:
        System.out.println("恭喜你，獲得了三等獎(jiǎng)！");
        break;
    case 88:
        System.out.println("恭喜你，獲得了二等獎(jiǎng)！");
        break;
    case 888:
        System.out.println("恭喜你，獲得了一等獎(jiǎng)！");
        break;
    default:
        System.out.println("謝謝參與！");
        break;
    }
}

當(dāng)用戶輸入的號(hào)碼為 888 時(shí)，獲取的 num 值為 888，則與第三個(gè) case 后的值匹配，執(zhí)行它后面的語句，輸出“恭喜你，獲得了一等獎(jiǎng)！”，然后執(zhí)行 break 語句，跳出整個(gè) switch 結(jié)構(gòu)。如果輸入的號(hào)碼與 case 中的值都不匹配，則執(zhí)行 default 后的語句。

程序執(zhí)行結(jié)果如下所示：

請輸入座位號(hào)碼：
888
恭喜你，獲得了一等獎(jiǎng)！
請輸入座位號(hào)碼：
88
恭喜你，獲得了二等獎(jiǎng)！
請輸入座位號(hào)碼：
66
謝謝參與！

例 2

編寫一個(gè) Java 程序，根據(jù)當(dāng)前的星期數(shù)字輸出對應(yīng)的漢字。在這里使用包含 break 的 switch 語句來判斷當(dāng)前的星期，實(shí)現(xiàn)代碼如下：

public static void main(String[] args) {
    String weekDate = "";
    Calendar calendar = Calendar.getInstance();  // 獲取當(dāng)前時(shí)間
    int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;  // 獲取星期的第幾日
    switch (week) {
        case 0:
            weekDate = "星期日";
            break;
        case 1:
            weekDate = "星期一";
            break;
        case 2:
            weekDate = "星期二";
            break;
        case 3:
            weekDate = "星期三";
            break;
        case 4:
            weekDate = "星期四";
            break;
        case 5:
            weekDate = "星期五";
            break;
        case 6:
            weekDate = "星期六";
            break;
    }
    System.out.println("今天是 " + weekDate);
}

本程序首先獲取當(dāng)前的星期值，然后使用 switch 語句判斷 week 的值：0 表示星期日，1 表示星期一，2 表示星期二……以此類推，6 表示星期六。只要 week 值與 case 值相符合，則程序?qū)?zhí)行該 case 中的語句，并跳出 switch 語句，輸出結(jié)果。

運(yùn)行程序，輸出的結(jié)果如下：

今天是星期五

嵌套 switch 語句

可以將一個(gè) switch 語句作為一個(gè)外部 switch 語句的語句序列的一部分，這稱為嵌套 switch 語句。

因?yàn)橐粋€(gè) switch 語句定義了自己的塊，外部 switch 語句和內(nèi)部 switch 語句的 case 常量不會(huì)產(chǎn)生沖突。

例如，下面的程序段是完全正確的：

public static void main(String[] args) {
    switch (count) {
        case 1:
            switch (target) {
            case 0:
                System.out.println("target is zero");
                break;
            case 1:
                System.out.println("target is one");
                break;
            }
            break;
        case 2: // ...
    }
}

本例中，內(nèi)部 switch 語句中的 case 1 ：語句與外部 switch 語句中的 case 1 ：語句不沖突。

變量 count 僅與外層的 case 語句相比較。

如果變量 count 為 1，則變量 target 與內(nèi)層的 case 語句相比較。

學(xué)到這里我們可以發(fā)現(xiàn)以下幾點(diǎn)：

• switch 語句不同于 if 語句的是 switch 語句僅能測試相等的情況，而 if 語句可計(jì)算任何類型的布爾表達(dá)式。也就是 switch 語句只能尋找 case 常量間某個(gè)值與表達(dá)式的值相匹配。
• 在同一個(gè) switch 語句中沒有兩個(gè)相同的 case 常量。當(dāng)然，外部 switch 語句中的 case 常量可以和內(nèi)部 switch 語句中的 case 常量相同。
• switch 語句通常比一系列嵌套 if 語句更有效。

最后一點(diǎn)尤其有趣，因?yàn)樗刮覀冎?Java 編譯器如何工作。

當(dāng)編譯一個(gè) switch 語句時(shí)，Java 編譯器將檢查每個(gè) case 常量并且創(chuàng)造一個(gè)“跳轉(zhuǎn)表”，這個(gè)表將用來在表達(dá)式值的基礎(chǔ)上選擇執(zhí)行路徑。

因此，如果你需要在一組值中做出選擇，switch 語句將比與之等效的 if-else 語句快得多。

編譯器可以這樣做是因?yàn)樗?case 常量都是同類型的，所要做的只是將它與 switch 表達(dá)式相比較看是否相等。

對于一系列的 if 表達(dá)式，編譯器就無此功能。

if 語句和 switch 語句的區(qū)別

if 和 switch 語句都表示條件語句，可以從使用效率和實(shí)用性兩方面加以區(qū)分。

1.從使用效率上區(qū)分

從使用效率上區(qū)分，在對同一個(gè)變量的不同值作條件判斷時(shí)，既可以使用 switch 語句，也可以使用 if 語句。

使用 switch 語句的效率更高一些，尤其是判斷的分支越多，越明顯。

2. 從實(shí)用性上區(qū)分

從語句的實(shí)用性角度區(qū)分，switch 語句不如 if 條件語句，if 語句是應(yīng)用最廣泛和最實(shí)用的語句。

3. 何時(shí)使用 if 語句和 switch 語句

在程序開發(fā)的過程中，何時(shí)使用 if 語句和 switch 語句，需要根據(jù)實(shí)際情況而定，應(yīng)盡量做到物盡其用。

不能因?yàn)?switch 語句的效率高就一直使用，也不能因?yàn)?if 語句常用就不用 switch 語句。

需要根據(jù)實(shí)際情況，具體問題具體分析，使用最適合的條件語句。

一般情況下，對于判斷條件較少的，可以使用 if 條件語句，但是在實(shí)現(xiàn)一些多條件的判斷中，最好使用 switch 語句。

Java while和do while循環(huán)詳解

循環(huán)是程序中的重要流程結(jié)構(gòu)之一。

循環(huán)語句能夠使程序代碼重復(fù)執(zhí)行，適用于需要重復(fù)一段代碼直到滿足特定條件為止的情況。

所有流行的編程語言中都有循環(huán)語句。

Java 中采用的循環(huán)語句與C語言中的循環(huán)語句相似，主要有 while、do-while 和 for。

另外 Java 5 之后推出了 for-each 循環(huán)語句，for-each 循環(huán)是 for 循環(huán)的變形，它是專門為集合遍歷而設(shè)計(jì)的。for-each 并不是一個(gè)關(guān)鍵字。

循環(huán)語句可以在滿足循環(huán)條件的情況下，反復(fù)執(zhí)行某一段代碼，這段被重復(fù)執(zhí)行的代碼被稱為循環(huán)體。

當(dāng)反復(fù)執(zhí)行這個(gè)循環(huán)體時(shí)，需要在合適的時(shí)候把循環(huán)條件改為假，從而結(jié)束循環(huán)，否則循環(huán)將一直執(zhí)行下去，形成死循環(huán)。

循環(huán)語句可能包含如下 4 個(gè)部分。

• 初始化語句（init statement）： 一條或多條語句，這些語句用于完成一些初始化工作，初始化語句在循環(huán)開始之前執(zhí)行。
• 循環(huán)條件（test_expression）：這是一個(gè) boolean 表達(dá)式，這個(gè)表達(dá)式能決定是否執(zhí)行循環(huán)體。
• 循環(huán)體（body_statement）：這個(gè)部分是循環(huán)的主體，如果循環(huán)條件允許，這個(gè)代碼塊將被重復(fù)執(zhí)行。如果這個(gè)代碼塊只有一行語句，則這個(gè)代碼塊的花括號(hào)是可以省略的。
• 迭代語句（iteration_statement）：這個(gè)部分在一次循環(huán)體執(zhí)行結(jié)束后，對循環(huán)條件求值之前執(zhí)行，通常用于控制循環(huán)條件中的變量，使得循環(huán)在合適的時(shí)候結(jié)束。

上面 4 個(gè)部分只是一般性的分類，并不是每個(gè)循環(huán)中都非常清晰地分出了這 4 個(gè)部分。

由于篇幅有限，本文主要介紹 while 和 do-while。

while 語句

while 語句是 Java 最基本的循環(huán)語句，是一種先判斷的循環(huán)結(jié)構(gòu)，可以在一定條件下重復(fù)執(zhí)行一段代碼。

該語句需要判斷一個(gè)測試條件，如果該條件為真，則執(zhí)行循環(huán)語句（循環(huán)語句可以是一條或多條），否則跳出循環(huán)。

while 循環(huán)語句的語法結(jié)構(gòu)如下：

while(條件表達(dá)式) {
    語句塊;
}

其中語句塊中的代碼可以是一條或者多條語句，而條件表達(dá)式是一個(gè)有效的 boolean 表達(dá)式，它決定了是否執(zhí)行循環(huán)體。當(dāng)條件表達(dá)式的值為 true 時(shí)，就執(zhí)行大括號(hào)中的語句塊。

執(zhí)行完畢，再次檢查表達(dá)式是否為 true，如果還為 true，則再次執(zhí)行大括號(hào)中的代碼，否則就跳出循環(huán)，執(zhí)行 while 循環(huán)之后的代碼。圖 1 表示了 while 循環(huán)語句的執(zhí)行流程。

圖 1 while 循環(huán)語句執(zhí)行流程圖

例 1

使用 while 語句計(jì)算 10 的階乘，其具體代碼如下所示。

public static void main(String[] args) {
    int i = 1;
    int n = 1;
    while(i <= 10) {
        n=n*i;
        i++;
    }
    System.out.println("10的階乘結(jié)果為："+n);
}

在上述代碼中，定義了兩個(gè)變量 i 和 n，循環(huán)每執(zhí)行一次 i 值就加 1，判斷 i 的值是否小于等于 10，并利用 n=n*i 語句來實(shí)現(xiàn)階乘。當(dāng) i 的值大于 10 之后，循環(huán)便不再執(zhí)行并退出循環(huán)。

運(yùn)行程序，執(zhí)行的結(jié)果如下所示：

10 的階乘結(jié)果為：3628800

do-while 語句

如你剛才所見，如果 while 循環(huán)一開始條件表達(dá)式就是假的，那么循環(huán)體就根本不被執(zhí)行

。然而，有時(shí)需要在開始時(shí)條件表達(dá)式即使是假的情況下，while 循環(huán)至少也要執(zhí)行一次。

換句話說，有時(shí)你需要在一次循環(huán)結(jié)束后再測試中止表達(dá)式，而不是在循環(huán)開始時(shí)。

幸運(yùn)的是，Java就提供了這樣的循環(huán)：do-while循環(huán)。

do-while 循環(huán)語句也是 Java 中運(yùn)用廣泛的循環(huán)語句，它由循環(huán)條件和循環(huán)體組成，但它與 while 語句略有不同。

do-while 循環(huán)語句的特點(diǎn)是先執(zhí)行循環(huán)體，然后判斷循環(huán)條件是否成立。

do-while 語句的語法格式如下：

do {
    語句塊;
}while(條件表達(dá)式);

以上語句的執(zhí)行過程是，首先執(zhí)行一次循環(huán)操作，然后再判斷 while 后面的條件表達(dá)式是否為 true，如果循環(huán)條件滿足，循環(huán)繼續(xù)執(zhí)行，否則退出循環(huán)。

while 語句后必須以分號(hào)表示循環(huán)結(jié)束，其運(yùn)行流程如圖 2 所示。

圖 2 do-while 循環(huán)語句的執(zhí)行流程

例 2

編寫一個(gè)程序，計(jì)算 10 的階乘。使用 do-while 循環(huán)的實(shí)現(xiàn)代碼如下所示。

public static void main(String[] args) {
    int number = 1,result = 1;
    do {
        result*=number;
        number++;
    }while(number <= 10);
    System.out.print("10階乘結(jié)果是："+result);
}

程序運(yùn)行后輸出結(jié)果如下：

10 階乘結(jié)果是：3628800

例 3

在一個(gè)圖書系統(tǒng)的推薦圖書列表中保存了 50 條信息，現(xiàn)在需要讓它每行顯示 10 條，分 5 行進(jìn)行顯示。下面使用 do-while 循環(huán)語句來實(shí)現(xiàn)這個(gè)效果，其具體代碼如下所示。

public static void main(String[] args) {
    int bookIndex = 1;
    do {
        System.out.print(bookIndex+"\t");
        if(bookIndex%10 == 0) {
            System.out.println();
        }
        bookIndex++;
    }while(bookIndex<51);
}

在上述代碼中， 聲明一個(gè)變量 bookIndex 用來保存圖書的索引，該變量賦值為 1 表示從第一本開始。

在 do-while 循環(huán)體內(nèi)，首先輸出了 bookIndex 的值，然后判斷 bookIndex 是否能被 10 整除，如果可以則說明當(dāng)前行已經(jīng)輸出 10 條，用 System.out.println() 語句輸出了一個(gè)換行符。

之后使 bookIndex 加 1，相當(dāng)于更新當(dāng)前的索引。最后在 while 表達(dá)式中判斷是否超出循環(huán)的范圍，即 50 條以內(nèi)。

運(yùn)行程序，執(zhí)行的結(jié)果如下所示。

1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50

while和do-while的比較

while 循環(huán)和 do-while 循環(huán)的相同處是：都是循環(huán)結(jié)構(gòu)，使用 while(循環(huán)條件) 表示循環(huán)條件，使用大括號(hào)將循環(huán)操作括起來。

while 循環(huán)和 do-while 循環(huán)的不同處如下：

• 語法不同：與 while 循環(huán)相比，do-while 循環(huán)將 while 關(guān)鍵字和循環(huán)條件放在后面，而且前面多了 do 關(guān)鍵字，后面多了一個(gè)分號(hào)。
• 執(zhí)行次序不同：while 循環(huán)先判斷，再執(zhí)行。do-while 循環(huán)先執(zhí)行，再判斷。
• 一開始循環(huán)條件就不滿足的情況下，while 循環(huán)一次都不會(huì)執(zhí)行，do-while 循環(huán)則不管什么情況下都至少執(zhí)行一次。

Java for循環(huán)詳解

for 語句是應(yīng)用最廣泛、功能最強(qiáng)的一種循環(huán)語句。

大部分情況下，for 循環(huán)可以代替 while 循環(huán)、do while 循環(huán)。

for 語句是一種在程序執(zhí)行前就要先判斷條件表達(dá)式是否為真的循環(huán)語句。

假如條件表達(dá)式的結(jié)果為假，那么它的循環(huán)語句根本不會(huì)執(zhí)行。

for 語句通常使用在知道循環(huán)次數(shù)的循環(huán)中。

for 語句語法格式如下所示。

for(條件表達(dá)式1;條件表達(dá)式2;條件表達(dá)式3) {
    語句塊;
}

for 關(guān)鍵字后面括號(hào)中的 3 個(gè)條件表達(dá)式必須用“;”隔開。

for 循環(huán)中的這 3 部分以及大括號(hào)中使循環(huán)體必需的 4 個(gè)組成部分完美地結(jié)合在一起，簡單明了。

for 循環(huán)語句執(zhí)行的過程為：首先執(zhí)行條件表達(dá)式 1 進(jìn)行初始化，然后判斷條件表達(dá)式 2 的值是否為 true，如果為 true，則執(zhí)行循環(huán)體語句塊；否則直接退出循環(huán)。最后執(zhí)行表達(dá)式 3，改變循環(huán)變量的值，至此完成一次循環(huán)。

接下來進(jìn)行下一次循環(huán)，直到條件表達(dá)式 2 的值為 false，才結(jié)束循環(huán)，其運(yùn)行流程如圖 1 所示。

圖 1 for循環(huán)執(zhí)行流程圖

值得指出的是，for 循環(huán)的循環(huán)迭代語句并沒有與循環(huán)體放在一起，因此即使在執(zhí)行循環(huán)體時(shí)遇到 continue 語句結(jié)束本次循環(huán)，循環(huán)迭代語句也一樣會(huì)得到執(zhí)行。

for 循環(huán)和 while、do while 循環(huán)不一樣：

由于 while、do while 循環(huán)的循環(huán)迭代語句緊跟著循環(huán)體，因此如果循環(huán)體不能完全執(zhí)行，如使用 continue 語句來結(jié)束本次循環(huán)，則循環(huán)迭代語句不會(huì)被執(zhí)行。

但 for 循環(huán)的循環(huán)迭代語句并沒有與循環(huán)體放在一起，因此不管是否使用 continue 語句來結(jié)束本次循環(huán)，循環(huán)迭代語句一樣會(huì)獲得執(zhí)行。

與前面循環(huán)類似的是，如果循環(huán)體只有一行語句，那么循環(huán)體的大括號(hào)可以省略。

例如，同樣是計(jì)算 5 的階乘，使用 for 循環(huán)的實(shí)現(xiàn)代碼如下：

public static void main(String[] args) {
    int result = 1;
    for (int number = 1; number <= 5; number++) {
        result *= number;
    }
    System.out.print("5 的階乘結(jié)果是：" + result);   // 輸出"5的階乘結(jié)果是：120"
}

上述語句的含義可以理解為，將 number 變量的值從 1 開始，每次遞增 1，直到大于 5 時(shí)終止循環(huán)。在循環(huán)過程中，將 number 的值與當(dāng)前 result 的值進(jìn)行相乘。

for 語句中初始化、循環(huán)條件以及迭代部分都可以為空語句（但分號(hào)不能省略），三者均為空的時(shí)候，相當(dāng)于一個(gè)無限循環(huán)。下面對這些情況依次進(jìn)行介紹。

條件表達(dá)式 1 為空

for 語句中條件表達(dá)式 1 的作用可以在程序的其他位置給出，所以當(dāng)條件表達(dá)式 1 為空時(shí)，for 語句后面括號(hào)內(nèi)其他條件表達(dá)式執(zhí)行的順序不變。

例如，使用 for 語句的這種形式計(jì)算 1~100 所有奇數(shù)的和。

public static void main(String[] args) {
    int result = 0;
    int number = 1; // 相當(dāng)于for語句的第1個(gè)表達(dá)式
    for (; number < 101; number++) {
        if (number % 2 != 0) // 如果不能整除2，說明是奇數(shù)，則進(jìn)行累加
            result += number;
    }
    System.out.print("100 以內(nèi)所有奇數(shù)和為：" + result);
}

執(zhí)行后的輸出結(jié)果如下：

100 以內(nèi)所有奇數(shù)和為：2500

條件表達(dá)式 2 為空

當(dāng) for 語句中條件表達(dá)式 2 為空時(shí)，將沒有循環(huán)的終止條件。

此時(shí) for 語句會(huì)認(rèn)為條件表達(dá)式 2 的值總是為真，循環(huán)無限制執(zhí)行下去。因此，為了使循環(huán)達(dá)到某種條件時(shí)退出，需要在語句塊中進(jìn)行邏輯判斷，并使用 break 語句來跳出循環(huán)，否則將產(chǎn)生死循環(huán)。

同樣是計(jì)算 1~100 所有奇數(shù)的和，使用這種方式的代碼如下。

public static void main(String[] args) {
    int result = 0;
    for (int number = 1;; number++) {
        if (number > 100)
            break; // 相當(dāng)于for語句的表達(dá)式2，滿足時(shí)就退出for循環(huán)
        if (number % 2 != 0) // 如果不能整除2，說明是奇數(shù)，則進(jìn)行累加
            result += number;
    }
    System.out.print("100 以內(nèi)所有奇數(shù)和為：" + result);
}

條件表達(dá)式 3 為空

當(dāng) for 語言中條件表達(dá)式 3 為空時(shí)，也就沒有設(shè)置控制變量的表達(dá)式，即每次循環(huán)之后無法改變變量的值，此時(shí)也無法保證循環(huán)正常結(jié)束。

同樣是計(jì)算1~100 所有奇數(shù)的和，使用這種方式的代碼如下：

public static void main(String[] args) {
    int result = 0;
    for (int number = 1; number < 101;) {
        if (number % 2 != 0) // 如果不能整除2，說明是奇數(shù)，則進(jìn)行累加
            result += number;
        number++; // 相當(dāng)于for語句的條件表達(dá)式3，每次遞增1
    }
    System.out.print("100 以內(nèi)所有奇數(shù)和為：" + result);
}

如果沒有循環(huán)體語句，number 變量的值為 1，永遠(yuǎn)小于 101，因此將無法結(jié)束循環(huán)，形成無限循環(huán)。

在上面代碼中將 number 的遞增語句放在 for 循環(huán)體內(nèi)，效果與完整 for 語句功能相同。

3 個(gè)條件表達(dá)式都為空

在 for 循環(huán)語句中，無論缺少哪部分條件表達(dá)式，都可以在程序的其他位置補(bǔ)充，從而保持 for 循環(huán)語句的完整性，使循環(huán)正常進(jìn)行。

當(dāng) for 語句中循環(huán)體全為空時(shí)，即沒有循環(huán)初值，不判斷循環(huán)條件，循環(huán)變量不增值，此時(shí)無條件執(zhí)行循環(huán)體，形成無限循環(huán)或者死循環(huán)。

對于這種情況，讀者在使用時(shí)應(yīng)該盡量避免。

例如，計(jì)算 1~100 所有奇數(shù)的和，使用這種方式的代碼如下：

public static void main(String[] args) {
    int result = 0;
    int number = 1; // 相當(dāng)于for語句的條件表達(dá)式1
    for (;;) {
        if (number > 100)
            break; // 相當(dāng)于for語句的條件表達(dá)式2
        if (number % 2 != 0) // 如果不能整除2，說明是奇數(shù)，則進(jìn)行累加
            result += number;
        number++; // 相當(dāng)于for語句的條件表達(dá)式3
    }
    System.out.print("100 以內(nèi)所有奇數(shù)和為： " + result);
}

例 1

編寫一個(gè) Java 程序，統(tǒng)計(jì)某超市上半年的總銷售量，要求由用戶輸入每月的銷量。使用 for 循環(huán)的實(shí)現(xiàn)代碼如下。

public static void main(String[] args) {
    int sum = 0;
    int num = 0;
    Scanner sc = new Scanner(System.in);
    for (int i = 1; i <= 6; i++) {
        System.out.println("請輸入第" + i + " 個(gè)月的銷售數(shù)量：");
        num = sc.nextInt();
        sum += num;
    }
    System.out.println("上半年的銷售總量為：" + sum);
}

在該程序中, 聲明循環(huán)變量 i，控制循環(huán)的次數(shù)，它被初始化為 1。

每執(zhí)行一次循環(huán)，都要對 i 進(jìn)行判斷，看其值是否小于等于 6，條件成立則繼續(xù)累加成績，否則退出循環(huán)。

每執(zhí)行完一次循環(huán)體，都會(huì)對 i 累加 1。

如此循環(huán)重復(fù)，直到 i 的值大于 6 時(shí)停止循環(huán)。此時(shí)退出 for 循環(huán)體，執(zhí)行最下方的語句輸出累加的銷售總量。

運(yùn)行程序，執(zhí)行結(jié)果如下所示。

請輸入第1 個(gè)月的銷售數(shù)量：
6840
請輸入第2 個(gè)月的銷售數(shù)量：
5449
請輸入第3 個(gè)月的銷售數(shù)量：
6546
請輸入第4 個(gè)月的銷售數(shù)量：
2400
請輸入第5 個(gè)月的銷售數(shù)量：
908
請輸入第6 個(gè)月的銷售數(shù)量：
8048
上半年的銷售總量為：30191

一般選擇循環(huán)變量時(shí)，習(xí)慣選擇 i、j、k 來作為循環(huán)變量。

for、do-while 和 while 的區(qū)別

例2

分別用 for、do-while 和 while 求出 1-10 的和。

使用for循環(huán)

代碼如下：

public static void main(String[] args) {
    int sum = 0;
    for (int i = 1; i < 11; i++) {
        sum = sum + i;
    }
    System.out.println(sum);
}

運(yùn)行結(jié)果為 55。

使用 do-while 循環(huán)

代碼如下：

public static void main(String[] args) {
    int sum = 0;
    int i = 1;
    do {
        sum = sum + i;
        i++;
    } while (i < 11);
    System.out.println(sum);
}

運(yùn)行結(jié)果為 55。

使用 while 循環(huán)

代碼如下：

public static void main(String[] args) {
    int sum = 0;
    int i = 1;
    while (i < 11) {
        sum = sum + i;
        i++;
    }
    System.out.println(sum);
}

運(yùn)行結(jié)果為 55。

從上邊代碼可以看出 for 語句明顯更加簡練，因?yàn)橹姥h(huán)次數(shù)。

到此這篇關(guān)于Java流程控制語句最全匯總(中篇)的文章就介紹到這了,其他兩個(gè)部分的內(nèi)容(上、下篇)請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

最新評論