前文

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

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

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

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

從結構化程序設計角度出發(fā)，程序有 3 種結構：順序結構、選擇結構和循環(huán)結構。

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

到目前為止，我們所編寫的程序都屬于順序結構。

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

在本章中，我們將對 Java 程序中的上述3種流程結構進行學習。

初學者應該對本章的每個小節(jié)進行仔細閱讀、思考，這樣才能達到事半功倍的效果。

Java switch case語句詳解

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

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

switch 語句格式

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

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

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

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

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

其中，switch、case、default、break 都是 Java 的關鍵字。

switch

表示“開關”，這個開關就是 switch 關鍵字后面小括號里的值，小括號里要放一個整型變量或字符型變量。

表達式必須為 byte，short，int，char類型。

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

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

case

表示“情況，情形”，case 標簽可以是：

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

例如：

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

當在 switch 語句中使用枚舉常量時，不必在每個標簽中指明枚舉名，可以由 switch 的表達式值確定。例如：

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

注意：重復的 case 值是不允許的。

default

表示“默認”，即其他情況都不滿足。

default 后要緊跟冒號，default 塊和 case 塊的先后順序可以變動，不會影響程序執(zhí)行結果。

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

break

表示“停止”，即跳出當前結構。

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

那么就會接著執(zhí)行下一個 case 分支語句。這種情況相當危險，常常會引發(fā)錯誤。

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

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

javac -Xlint:fallthrough Test.java

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

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

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

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

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

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

例 1

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

使用 switch 語句編寫 Java 程序來完成獎項分配，其實現代碼如下。

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

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

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

請輸入座位號碼：
888
恭喜你，獲得了一等獎！
請輸入座位號碼：
88
恭喜你，獲得了二等獎！
請輸入座位號碼：
66
謝謝參與！

例 2

編寫一個 Java 程序，根據當前的星期數字輸出對應的漢字。在這里使用包含 break 的 switch 語句來判斷當前的星期，實現代碼如下：

public static void main(String[] args) {
    String weekDate = "";
    Calendar calendar = Calendar.getInstance();  // 獲取當前時間
    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);
}

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

運行程序，輸出的結果如下：

今天是星期五

嵌套 switch 語句

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

因為一個 switch 語句定義了自己的塊，外部 switch 語句和內部 switch 語句的 case 常量不會產生沖突。

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

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: // ...
    }
}

本例中，內部 switch 語句中的 case 1 ：語句與外部 switch 語句中的 case 1 ：語句不沖突。

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

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

學到這里我們可以發(fā)現以下幾點：

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

最后一點尤其有趣，因為它使我們知道 Java 編譯器如何工作。

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

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

編譯器可以這樣做是因為它知道 case 常量都是同類型的，所要做的只是將它與 switch 表達式相比較看是否相等。

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

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

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

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

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

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

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

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

3. 何時使用 if 語句和 switch 語句

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

不能因為 switch 語句的效率高就一直使用，也不能因為 if 語句常用就不用 switch 語句。

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

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

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

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

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

所有流行的編程語言中都有循環(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)的變形，它是專門為集合遍歷而設計的。for-each 并不是一個關鍵字。

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

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

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

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

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

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

while 語句

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

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

while 循環(huán)語句的語法結構如下：

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

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

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

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

例 1

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

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

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

運行程序，執(zhí)行的結果如下所示：

10 的階乘結果為：3628800

do-while 語句

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

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

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

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

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

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

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

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

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

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

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

例 2

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

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

程序運行后輸出結果如下：

10 階乘結果是：3628800

例 3

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

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);
}

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

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

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

運行程序，執(zhí)行的結果如下所示。

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)結構，使用 while(循環(huán)條件) 表示循環(huán)條件，使用大括號將循環(huán)操作括起來。

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

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

Java for循環(huán)詳解

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

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

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

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

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

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

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

for 關鍵字后面括號中的 3 個條件表達式必須用“;”隔開。

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

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

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

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

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

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

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

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

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

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

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

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

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

條件表達式 1 為空

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

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

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

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

100 以內所有奇數和為：2500

條件表達式 2 為空

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

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

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

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

條件表達式 3 為空

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

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

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

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

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

3 個條件表達式都為空

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

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

對于這種情況，讀者在使用時應該盡量避免。

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

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

例 1

編寫一個 Java 程序，統(tǒng)計某超市上半年的總銷售量，要求由用戶輸入每月的銷量。使用 for 循環(huá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 + " 個月的銷售數量：");
        num = sc.nextInt();
        sum += num;
    }
    System.out.println("上半年的銷售總量為：" + sum);
}

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

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

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

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

運行程序，執(zhí)行結果如下所示。

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

一般選擇循環(huán)變量時，習慣選擇 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);
}

運行結果為 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);
}

運行結果為 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);
}

運行結果為 55。

從上邊代碼可以看出 for 語句明顯更加簡練，因為知道循環(huán)次數。

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

最新評論