前文

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

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

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

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

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

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

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

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

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

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

Java foreach語句的用法

foreach 循環(huán)語句是 Java 1.5 的新特征之一，在遍歷數(shù)組、集合方面，foreach 為開發(fā)者提供了極大的方便。

foreach 循環(huán)語句是 for 語句的特殊簡化版本，主要用于執(zhí)行遍歷功能的循環(huán)。

foreach 循環(huán)語句的語法格式如下：

for(類型 變量名:集合) {
    語句塊;
}

其中，“類型”為集合元素的類型，“變量名”表示集合中的每一個元素，“集合”是被遍歷的集合對象或數(shù)組。

每執(zhí)行一次循環(huán)語句，循環(huán)變量就讀取集合中的一個元素，其執(zhí)行流程如圖 1 所示。

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

例 1

假設(shè)有一個數(shù)組，采用 for 語句遍歷數(shù)組的方式如下：

// 聲明并初始化數(shù)組
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for----");
// for語句
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Count is:" + numbers[i]);
}

上述第 2 行語句聲明并初始化了 7 個元素數(shù)組集合，目前大家只需要知道當初始化數(shù)組時，要把相同類型的元素放到 {…} 中并且用逗號分隔（,）即可。

關(guān)于數(shù)組集合會在教程后面詳細介紹，這里我們只需要大概了解就可以。

numbers.length 是獲得數(shù)組的長度，length 是數(shù)組的屬性，numbers[i] 是通過數(shù)組下標訪問數(shù)組元素。

那么采用 for-each 循環(huán)語句遍歷數(shù)組的方式如下：

// 聲明并初始化int數(shù)組
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for each----");
// for-each語句
for (int item : numbers) {
    System.out.println("Count is:" + item);
}

從示例中可以發(fā)現(xiàn)，item 不是循環(huán)變量，它保存了集合中的元素，for-each 語句將集合中的元素一一取出來，并保存到 item 中，這個過程中不需要使用循環(huán)變量，通過數(shù)組下標訪問數(shù)組中的元素。

可見 for-each 語句在遍歷集合的時候要簡單方便得多。

例 2

String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循環(huán)來遍歷數(shù)組元素
// 其中book將會自動迭代每個數(shù)組元素
for (String url : urls) {
    System.out.println(url);
}

從上面程序可以看出，使用 foreach 循環(huán)遍歷數(shù)組元素時無須獲得數(shù)組長度，也無須根據(jù)索引來訪問數(shù)組元素。

foreach 循環(huán)和普通循環(huán)不同的是，它無須循環(huán)條件，無須循環(huán)迭代語句，這些部分都由系統(tǒng)來完成，foreach 循環(huán)自動迭代數(shù)組的每個元素，當每個元素都被迭代一次后，foreach 循環(huán)自動結(jié)束。

當使用 foreach 循環(huán)來迭代輸出數(shù)組元素或集合元素時，通常不要對循環(huán)變量進行賦值，雖然這種賦值在語法上是允許的，但沒有太大的實際意義，而且極容易引起錯誤。

例如下面程序。

String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循環(huán)來遍歷數(shù)組元素，其中 book 將會自動迭代每個數(shù)組元素
for (String url : urls) {
    url = "https://c.biancheng.net";
    System.out.println(url);
}
System.out.println(urls[0]);

運行上邊程序，將看到如下結(jié)果：

https://c.biancheng.net

https://c.biancheng.net

https://c.biancheng.net

https://c.biancheng.net/java

從上面運行結(jié)果來看，由于在 foreach 循環(huán)中對數(shù)組元素進行賦值，結(jié)果導致不能正確遍歷數(shù)組元素，不能正確地取出每個數(shù)組元素的值。

而且當再次訪問第一個數(shù)組元素時，發(fā)現(xiàn)數(shù)組元素的值依然沒有改變。

不難看出，當使用 foreach 來迭代訪問數(shù)組元素時，foreach 中的循環(huán)變量相當于一個臨時變量，系統(tǒng)會把數(shù)組元素依次賦給這個臨時變量，而這個臨時變量并不是數(shù)組元素，它只是保存了數(shù)組元素的值。

因此，如果希望改變數(shù)組元素的值，則不能使用這種 foreach 循環(huán)。

使用 foreach 循環(huán)迭代數(shù)組元素時，并不能改變數(shù)組元素的值，因此不要對 foreach 的循環(huán)變量進行賦值。

例 3

在一個字符串數(shù)組中存儲了幾種編程語言，現(xiàn)在將這些編程語言遍歷輸出。

foreach 語句的實現(xiàn)代碼如下：

public static void main(String[] args) {
    String[] languages={"Java","ASP.NET","Python","C#","PHP"};
    System.out.println("現(xiàn)在流行的編程語言有：");
    // 使用 foreach 循環(huán)語句遍歷數(shù)組
    for(String lang:languages) {
        System.out.println(lang);
    }
}

在循環(huán)體執(zhí)行的過程中，每循環(huán)一次，會將 languages 數(shù)組中的一個元素賦值給 lang 變量，直到遍歷 languages 數(shù)組中所有元素，循環(huán)終止。

該程序運行后的結(jié)果如下所示。

現(xiàn)在流行的編程語言有：
Java
ASP.NET
Python
C#
PHP

Java return語句

return 關(guān)鍵字并不是專門用于結(jié)束循環(huán)的，return 語句用于終止函數(shù)的執(zhí)行或退出類的方法，并把控制權(quán)返回該方法的調(diào)用者。

如果這個方法帶有返回類型，return 語句就必須返回這個類型的值；如果這個方法沒有返回值，可以使用沒有表達式的 return 語句。

return 語句的一般語法格式如下：

return 與方法相同類型的變量;

如果一個方法使用了 return 語句并且后面跟有該方法返回類型的值，那么調(diào)用此方法后，所得到的結(jié)果為該方法返回的值。

例 1

當用戶輸入兩個 double 類型的數(shù)值后需要計算這兩個數(shù)值之和，而這兩個操作數(shù)是可以變動的，但是求和的功能是不變的，這時就需要定義一個方法，只要在需要求和時調(diào)用該方法即可，該方法將計算之后的結(jié)果返回。代碼如下：

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("請輸入操作數(shù)1：");
        double num1 = input.nextDouble(); // 獲取用戶輸入的操作數(shù)1
        System.out.println("請輸入操作數(shù)2：");
        double num2 = input.nextDouble(); // 獲取用戶輸入的操作數(shù)2
        double d = sum(num1, num2);
        System.out.println(num1 + "+" + num2 + "=" + d);
    }
    /**
     * 創(chuàng)建sum() 方法，返回double 類型的數(shù)值
     *
     * @param i 操作數(shù)1
     * @param j 操作數(shù)2
     * @return 兩個操作數(shù)之和
     */
    public static double sum(double i, double j) {
        double sum = i + j;
        return sum;
    }
}

當用戶輸入兩個 double 類型的數(shù)值后，程序調(diào)用 sum() 方法。

該方法有兩個參數(shù)，分別表示用戶輸入的操作數(shù) 1 和操作數(shù) 2。

在調(diào)用該方法時，只需要將用戶輸入的兩個數(shù)值傳遞過去即可，然后程序會執(zhí)行 sum() 方法，對這兩個數(shù)求和，并使用 return 語句將計算得出的結(jié)果返回。

在 main() 方法中，同樣需要使用 double 類型的變量來接收 sum() 方法返回的值，即變量 d 為計算后的結(jié)果。

運行后的結(jié)果如下所示：

請輸入操作數(shù)1：
500
請輸入操作數(shù)2：
203
500.0+203.0=703.0
請輸入操作數(shù)1：
5.66
請輸入操作數(shù)2：
3.0158
5.66+3.0158=8.6758

Java break語句：跳出循環(huán)

某些時候需要在某種條件出現(xiàn)時強行終止循環(huán)，而不是等到循環(huán)條件為 false 時才退出循環(huán)。

此時，可以使用 break 來完成這個功能。

break 用于完全結(jié)束一個循環(huán)，跳出循環(huán)體。不管是哪種循環(huán)，一旦在循環(huán)體中遇到 break，系統(tǒng)將完全結(jié)束該循環(huán)，開始執(zhí)行循環(huán)之后的代碼。

在 Java 中，break 語句有 3 種作用，分別是：在 switch 語句中終止一個語句序列、使用 break 語句直接強行退出循環(huán)和使用 break 語句實現(xiàn) goto 的功能。

使用 break 語句直接強行退出循環(huán)（break 不帶標簽）

可以使用 break 語句強行退出循環(huán)，忽略循環(huán)體中的任何其他語句和循環(huán)的條件判斷。

在循環(huán)中遇到 break 語句時，循環(huán)被終止，在循環(huán)后面的語句重新開始。

例 1

小明參加了一個 1000 米的長跑比賽，在 100 米的跑道上，他循環(huán)地跑著，每跑一圈，剩余路程就會減少 100 米，要跑的圈數(shù)就是循環(huán)的次數(shù)。

但是，在每跑完一圈時，教練會問他是否要堅持下去，如果回答 y，則繼續(xù)跑，否則表示放棄。

使用 break 語句直接強行退出循環(huán)的示例如下：

public static void main(String[] args) {
    Scanner input = new Scanner(System.in); // 定義變量存儲小明的回答
    String answer = ""; // 一圈100米，1000米為10圈，即為循環(huán)的次數(shù)
    for (int i = 0; i < 10; i++) {
        System.out.println("跑的是第" + (i + 1) + "圈");
        System.out.println("還能堅持嗎？"); // 獲取小明的回答
        answer = input.next(); // 判斷小明的回答是否為y？如果不是，則放棄，跳出循環(huán)
        if (!answer.equals("y")) {
            System.out.println("放棄");
            break;
        }
        // 循環(huán)之后的代碼
        System.out.println("加油！繼續(xù)！");
    }
}

該程序運行后的效果如下所示：

跑的是第1圈
還能堅持嗎？
y
加油！繼續(xù)！
跑的是第2圈
還能堅持嗎？
y
加油！繼續(xù)！
跑的是第3圈
還能堅持嗎？
n
放棄

盡管 for 循環(huán)被設(shè)計為從 0 執(zhí)行到 10，但是當小明的回答不是 y 時，break 語句終止了程序的循環(huán)，繼續(xù)執(zhí)行循環(huán)體外的代碼，輸出“加油！繼續(xù)！”。

break 語句能用于任何 Java 循環(huán)中，包括人們有意設(shè)置的無限循環(huán)。

在一系列嵌套循環(huán)中使用 break 語句時，它將僅僅終止最里面的循環(huán)。例如：

public static void main(String[] args) {
    // 外循環(huán)，循環(huán)5次
    for (int i = 0; i < 5; i++) {
        System.out.print("第" + (i + 1) + "次循環(huán)：");
        // 內(nèi)循環(huán)，設(shè)計為循環(huán)10次
        for (int j = 0; j < 10; j++) {
            // 判斷j是否等于3，如果是，則終止循環(huán)
            if (j == 3) {
                break;
            }
            System.out.print("內(nèi)循環(huán)的第" + (j + 1) + "次循環(huán)\t");
        }
        System.out.println();
    }
}

該程序運行結(jié)果如下所示：

第1次循環(huán)：內(nèi)循環(huán)的第1次循環(huán) 內(nèi)循環(huán)的第2次循環(huán) 內(nèi)循環(huán)的第3次循環(huán)
第2次循環(huán)：內(nèi)循環(huán)的第1次循環(huán) 內(nèi)循環(huán)的第2次循環(huán) 內(nèi)循環(huán)的第3次循環(huán)
第3次循環(huán)：內(nèi)循環(huán)的第1次循環(huán) 內(nèi)循環(huán)的第2次循環(huán) 內(nèi)循環(huán)的第3次循環(huán)
第4次循環(huán)：內(nèi)循環(huán)的第1次循環(huán) 內(nèi)循環(huán)的第2次循環(huán) 內(nèi)循環(huán)的第3次循環(huán)
第5次循環(huán)：內(nèi)循環(huán)的第1次循環(huán) 內(nèi)循環(huán)的第2次循環(huán) 內(nèi)循環(huán)的第3次循環(huán)

從程序運行結(jié)果來看，在內(nèi)部循環(huán)中的 break 語句僅僅終止了所在的內(nèi)部循環(huán)，外部循環(huán)沒有受到任何的影響。

注意：一個循環(huán)中可以有一個以上的 break 語句，但是過多的 break 語句會破壞代碼結(jié)構(gòu)。

switch 循環(huán)語句中的 break 僅影響 switch 語句，不會影響循環(huán)。

例 2

編寫一個 Java 程序，允許用戶輸入 6 門課程成績，如果錄入的成績?yōu)樨搫t跳出循環(huán)；如果錄入 6 門合法成績，則計算已有成績之和。

使用 break 語句的實現(xiàn)代碼如下：

public static void main(String[] args) {
    int score; // 每門課的成績
    int sum = 0; // 成績之和
    boolean con = true; // 記錄錄入的成績是否合法
    Scanner input = new Scanner(System.in);
    System.out.println("請輸入學生的姓名：");
    String name = input.next(); // 獲取用戶輸入的姓名
    for (int i = 1; i <= 6; i++) {
        System.out.println("請輸入第" + i + "門課程的成績：");
        score = input.nextInt();// 獲取用戶輸入的成績
        if (score < 0) { // 判斷用戶輸入的成績是否為負數(shù)，如果為負數(shù)，終止循環(huán)
            con = false;
            break;
        }
        sum = sum + score; // 累加求和
    }
    if (con) {
        System.out.println(name + "的總成績?yōu)椋? + sum);
    } else {
        System.out.println("抱歉，分數(shù)錄入錯誤，請重新錄入！");
    }
}

運行程序，當用戶錄入的分數(shù)低于 0 時，則輸出“抱歉，分數(shù)錄入錯誤，請重新錄入！”信息，否則打印學生的總成績。輸出結(jié)果如下所示。

請輸入學生的姓名：
zhangpu
請輸入第1門課程的成績：
100
請輸入第2門課程的成績：
75
請輸入第3門課程的成績：
-8
抱歉，分數(shù)錄入錯誤，請重新錄入！
請輸入學生的姓名：
zhangpu
請輸入第1門課程的成績：
100
請輸入第2門課程的成績：
68
請輸入第3門課程的成績：
73
請輸入第4門課程的成績：
47
請輸入第5門課程的成績：
99
請輸入第6門課程的成績：
84
zhangpu的總成績?yōu)椋?71

在該程序中，當錄入第 3 門課的成績時，錄入的成績?yōu)樨摂?shù)，判斷條件“score<0”為 true，執(zhí)行“con=false”，用 con 來標記錄入是否有誤。

接著執(zhí)行 break 語句，執(zhí)行完之后程序并沒有繼續(xù)執(zhí)行條件語句后面的語句，而是直接退出 for 循環(huán)。之后執(zhí)行下面的條件判斷語句，判斷 boolean 變量的 con 是否為 true，如果為 true，則打印總成績；否則打印“抱歉，分數(shù)錄入錯誤，請重新錄入！”。

使用 break 語句實現(xiàn) goto 的功能（break 帶標簽）

有時候，在嵌套很深的循環(huán)語句中會發(fā)生一些不可預料的事情。

此時可能更加希望跳到嵌套的所有循環(huán)語句之外。

通過添加一些額外的條件判斷實現(xiàn)各層循環(huán)的檢測很不方便。

幸運的是，Java 與 C++ 不同，Java 提供了一種帶標簽的 break 語句，用于跳出多重嵌套的循環(huán)語句。

break 語句可以實現(xiàn) goto 的功能，并且 Java 定義了 break 語句的一種擴展形式來處理退出嵌套很深的循環(huán)這個問題。

通過使用擴展的 break 語句，可以終止執(zhí)行一個或者幾個任意代碼塊，這些代碼塊不必是一個循環(huán)或一個 switch 語句的一部分

。同時這種擴展的 break 語句帶有標簽，可以明確指定從何處重新開始執(zhí)行。

break 除了具有 goto 退出深層循環(huán)嵌套作用外，還保留了一些程序結(jié)構(gòu)化的特性。

標簽 break 語句的通用格式如下：

break label;

label 是標識代碼塊的標簽。

當執(zhí)行這種形式的 break 語句時，控制權(quán)被傳遞出指定的代碼塊。

被加標簽的代碼塊必須包圍 break 語句，但是它不需要直接包圍 break 的塊。

也就是說，可以使用一個加標簽的 break 語句來退出一系列的嵌套塊，但是不能使用 break 語句將控制權(quán)傳遞到不包含 break 語句的代碼塊。

用標簽（label）可以指定一個代碼塊，標簽可以是任何合法有效的 Java 標識符，后跟一個冒號。

加上標簽的代碼塊可以作為 break 語句的對象，使程序在加標簽的塊的結(jié)尾繼續(xù)執(zhí)行。

下面是使用帶標簽的break 語句的示例。

public class GotoDemo {
    public static void main(String[] args) {
        label: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.println(j);
                if (j % 2 != 0) {
                    break label;
                }
            }
        }
    }
}

以上程序的執(zhí)行結(jié)果為：

0
1

這里的 label 是標簽的名稱，可以為 Java 語言中任意合法的標識符。

標簽語句必須和循環(huán)匹配使用，使用時書寫在對應(yīng)的循環(huán)語句的上面，標簽語句以冒號結(jié)束。

如果需要中斷標簽語句對應(yīng)的循環(huán)，可以采用 break 后面跟標簽名的方式。

如在上面代碼中，當 j 為 1 時，“j%2!=0”條件表達式成立，則 label 標簽所代表的最外層循環(huán)終止。

注意：通常緊跟 break 之后的標簽，必須在 break 所在循環(huán)的外層循環(huán)之前定義才有意義。

在 switch 語句中終止一個語句序列

在 switch 語句中終止一個語句序列，就是在每個 case 子句塊的最后添加語句“break;”，這個功能在《Java switch case》已經(jīng)講過，這里不在講述。

Java continue語句詳解

有時強迫一個循環(huán)提早反復是有用的，也就是，你可能想要繼續(xù)運行循環(huán)，但是要忽略這次重復剩余的循環(huán)體的語句，所以 Java 提供了 continue 語句。

continue 語句是 break 語句的補充。

本節(jié)主要講解 continue 語句。

與 break 語句一樣， 它將中斷正常的控制流程。

continue 語句將控制轉(zhuǎn)移到最內(nèi)層循環(huán)的首部。

continue 語句是跳過循環(huán)體中剩余的語句而強制執(zhí)行下一次循環(huán)，其作用為結(jié)束本次循環(huán)，即跳過循環(huán)體中下面尚未執(zhí)行的語句，接著進行下一次是否執(zhí)行循環(huán)的判定。

continue 語句類似于 break 語句，但它只能出現(xiàn)在循環(huán)體中。

它與 break 語句的區(qū)別在于：continue 并不是中斷循環(huán)語句，而是中止當前迭代的循環(huán)，進入下一次的迭代。

簡單來講，continue 是忽略循環(huán)語句的當次循環(huán)。

注意：continue 語句只能用在 while 語句、for 語句或者 foreach 語句的循環(huán)體之中，在這之外的任何地方使用它都會引起語法錯誤。

在循環(huán)體中使用 continue 語句有兩種方式可以帶有標簽，也可以不帶標簽。語法格式如下：

continue //不帶標簽

continue label //帶標簽，label是標簽名

下面看一個示例，代碼如下：

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < numbers.length; i++) {
    if (i == 3) {
        continue;
    }
    System.out.println("Count is: " + i);
}

在上述程序代碼中，當條件 i==3 的時候執(zhí)行 continue 語句，continue 語句會終止本次循環(huán)，循環(huán)體中 continue 之后的語句將不再執(zhí)行，接著進行下次循環(huán)，所以輸出結(jié)果中沒有 3。程序運行結(jié)果如下：

Count is: 0
Count is: 1
Count is: 2
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9

帶標簽的 continue 語句示例代碼如下：

public static void main(String[] args) {
    label1: for (int x = 0; x < 5; x++) {
        for (int y = 5; y > 0; y--) {
            if (y == x) {
                continue label1;
            }
            System.out.println(x+","+y);
        }
    }
    System.out.println("Game Over!");
}

默認情況下，continue 只會跳出最近的內(nèi)循環(huán)（代碼第 3 行的 for 循環(huán)），如果要跳出代碼第 2 行的外循環(huán)，可以為外循環(huán)添加一個標簽 label1，然后在第 5 行的 continue 語句后面指定這個標簽 label1，這樣當條件滿足執(zhí)行 continue 語句時，程序就會跳轉(zhuǎn)出外循環(huán)。

程序運行結(jié)果如下：

0,5
0,4
0,3
0,2
0,1
1,5
1,4
1,3
1,2
2,5
2,4
2,3
3,5
3,4
4,5
Game Over!

由于跳過了 x == y，因此下面的內(nèi)容沒有輸出。

1,1
2,2
3,3
4,4

Java選擇結(jié)構(gòu)和循環(huán)結(jié)構(gòu)的總結(jié)

任何編程語言中最常見的程序結(jié)構(gòu)就是順序結(jié)構(gòu)。

順序結(jié)構(gòu)就是程序從上到下逐行的執(zhí)行，中間沒有任何判斷和跳轉(zhuǎn)。

如果 main 方法的多行代碼之間沒有任何流程控制，則程序總是從上向下依次執(zhí)行，排在前面的代碼先執(zhí)行，排在后面的代碼后執(zhí)行

。這意味著：如果沒有流程控制，Java 方法里的語句是一個順序執(zhí)行流，從上向下依次執(zhí)行每條語句。

不論哪一種編程語言，都會提供兩種基本的流程控制結(jié)構(gòu)：分支結(jié)構(gòu)和循環(huán)結(jié)構(gòu)。

分支結(jié)構(gòu)用于實現(xiàn)根據(jù)條件來選擇性地執(zhí)行某段代碼，循環(huán)結(jié)構(gòu)則用于實現(xiàn)根據(jù)循環(huán)條件重復執(zhí)行某段代碼。

Java 同樣提供了這兩種流程控制結(jié)構(gòu)的語法，Java 提供了 if 和 switch 兩種分支語句，并提供了 while、do while 和 for 三種循環(huán)語句。

一般寫循環(huán)語句時，分以下三步走：

1. 定義初始值
2. 設(shè)置判斷條件
3. 初始值變化

除此之外，JDK5 還提供了一種新的循環(huán)：foreach 循環(huán)，能以更簡單的方式來遍歷集合、數(shù)組的元素。

Java 還提供了 break、continue 和 return 來控制程序的循環(huán)結(jié)構(gòu)，作用如下：

• break：表示跳出當前層循環(huán)
• continue：表示跳出本次循環(huán)，進入下一次循環(huán)
• return：跳出當前方法的循環(huán)

當在實現(xiàn)某個功能語句時，如果需要通過某一個條件去判斷，則用選擇結(jié)構(gòu)。

當實現(xiàn)某個功能需要通過循環(huán)去實現(xiàn)，則用循環(huán)結(jié)構(gòu)。

當然循環(huán)和選擇是可以相互嵌套的。

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

最新評論