前言

Java 程序的執(zhí)行并非永遠(yuǎn)是從上到下逐行執(zhí)行，程序邏輯控制就是通過(guò)特定語(yǔ)法結(jié)構(gòu)改變代碼的執(zhí)行順序、選擇執(zhí)行指定代碼、重復(fù)執(zhí)行某段代碼的核心語(yǔ)法。是所有編程語(yǔ)言的基礎(chǔ)核心，所有復(fù)雜的程序功能，都基于以下 3 種基礎(chǔ)結(jié)構(gòu)，三者可以任意嵌套組合：

• 順序結(jié)構(gòu)：代碼從上到下，逐行執(zhí)行，沒(méi)有跳轉(zhuǎn)，判斷和重復(fù)，是最基礎(chǔ)的結(jié)構(gòu)

• 分支結(jié)構(gòu)：根據(jù)指定條件的成立或是不成立，選擇執(zhí)行不同的代碼塊，核心是選擇執(zhí)行

• 循環(huán)結(jié)構(gòu)：根據(jù)指定條件，重復(fù)執(zhí)行某一段代碼塊，核心是重復(fù)執(zhí)行

1. 順序結(jié)構(gòu)

順序結(jié)構(gòu)就是代碼按照書(shū)寫(xiě)的前后順序從上到下逐行執(zhí)行，沒(méi)有任何的判斷條件和跳轉(zhuǎn)語(yǔ)句，也無(wú)需任何關(guān)鍵字，是程序中最基礎(chǔ)的執(zhí)行結(jié)構(gòu)。

public class SequenceDemo {
    public static void main(String[] args) {
        System.out.println("aaa");
        System.out.println("bbb");
        System.out.println("ccc");
    }
}
// 運(yùn)行結(jié)果
// aaa
// bbb
// ccc

如果改變了代碼的書(shū)寫(xiě)順序，那么執(zhí)行順序也會(huì)隨之改變

public class SequenceDemo {
    public static void main(String[] args) {
        System.out.println("ccc");
        System.out.println("bbb");
        System.out.println("aaa");
    }
}
// 運(yùn)行結(jié)果
// ccc
// bbb
// aaa

2. 分支結(jié)構(gòu)

分支結(jié)構(gòu)也叫選擇結(jié)構(gòu)，核心是根據(jù)條件做選擇，Java中為此提供了兩種核心分支語(yǔ)法：

• if 分支：支持所有條件判斷，就比如關(guān)系判斷，邏輯判斷，復(fù)雜表達(dá)式等，靈活度比較高，使用率最高

• switch 分支：等值匹配分支，僅僅支持固定值的等值判斷，語(yǔ)法簡(jiǎn)介，執(zhí)行效率較高

2.1 if 分支結(jié)構(gòu)

2.1.1 基礎(chǔ)用法

if 分支結(jié)構(gòu)是 Java 中最核心最常用的分支結(jié)構(gòu)，支持單分支，雙分支，多分支三種寫(xiě)法，滿足所有條件判斷的場(chǎng)景

單分支

if (條件表達(dá)式) {
    // 條件為 true 時(shí)，執(zhí)行的代碼塊
}
// 條件為 false 時(shí)，跳過(guò)代碼塊，直接執(zhí)行后續(xù)代碼

條件表達(dá)式的結(jié)果必須是 boolean 類型，大括號(hào)內(nèi)是滿足條件的執(zhí)行體。就比如考試成績(jī)?cè)?0分以上就獎(jiǎng)勵(lì)一個(gè)大雞腿，代碼如下：

// 判斷成績(jī)是否大于90分
int score = 95;
if (score >= 90) {
    System.out.println("獎(jiǎng)勵(lì)一個(gè)大雞腿！");
}
System.out.println("程序結(jié)束");

雙分支if - else 結(jié)構(gòu)

if (條件表達(dá)式1) {
    // 條件1為true時(shí)執(zhí)行
} else if (條件表達(dá)式2) {
    // 條件1為false，條件2為true時(shí)執(zhí)行
} else if (條件表達(dá)式3) {
    // 條件1、2為false，條件3為true時(shí)執(zhí)行
} 
// ... 可以寫(xiě)多個(gè) else if
else {
    // 所有條件都為false時(shí)，執(zhí)行的默認(rèn)代碼塊
}

多選一，從上到下依次匹配條件，只要有一個(gè)條件成立，執(zhí)行對(duì)應(yīng)代碼塊后直接跳出分支，后續(xù)條件不在判斷，所有條件都不成立時(shí)，執(zhí)行最后的 else。就如下面這個(gè)例子，給成績(jī)?cè)u(píng)級(jí)

// 根據(jù)成績(jī)判斷等級(jí)（多條件匹配）
int score = 92;
if (score >= 90 && score <= 100) {
    System.out.println("成績(jī)等級(jí)：優(yōu)秀");
} else if (score >= 80 && score < 90) {
    System.out.println("成績(jī)等級(jí)：良好");
} else if (score >= 60 && score < 80) {
    System.out.println("成績(jī)等級(jí)：及格");
} else if (score >= 0 && score < 60) {
    System.out.println("成績(jī)等級(jí)：不及格");
} else {
    System.out.println("輸入的成績(jī)不合法！");
}

2.1.2 if 嵌套

所謂嵌套就是指在一個(gè)結(jié)構(gòu)中完整的包含另一個(gè)結(jié)構(gòu)，if 嵌套就是指在 if 結(jié)構(gòu)中還完整包含了另外一個(gè)if 結(jié)構(gòu)。如果需要進(jìn)行多重判斷的場(chǎng)景可以使用 if 嵌套，多層級(jí)的條件判斷，示例如下：

// 先判斷是否成年，成年后再判斷是否有駕照，有駕照則可以開(kāi)車
int age = 22;
boolean hasLicense = true;
if (age >= 18) {
    System.out.println("已成年");
    if (hasLicense) {
        System.out.println("有駕照，可以開(kāi)車");
    } else {
        System.out.println("無(wú)駕照，不能開(kāi)車");
    }
} else {
    System.out.println("未成年，禁止開(kāi)車");
}

2.1.3 注意事項(xiàng)

1. 條件表達(dá)式必須是 boolean 類型，不能寫(xiě)數(shù)值，這是 Java 和 C語(yǔ)言的核心區(qū)別

2. if 條件表達(dá)式寫(xiě)判斷號(hào) == 而非賦值號(hào) =

3. 浮點(diǎn)數(shù)不能直接用 == 判斷是否相等，需要考慮誤差

4. 如果代碼塊只有一行語(yǔ)句可以將大括號(hào)省略，但是不推薦，容易出現(xiàn)懸垂 else 問(wèn)題，就比如下面代碼：本意是讓 else 與第一個(gè) if 進(jìn)行匹配，但是由于省略了大括號(hào)，else 會(huì)與最近是 if 進(jìn)行匹配

   // 錯(cuò)誤示范：省略大括號(hào)，else 會(huì)和最近的 if 匹配，邏輯混亂
   int a = 5;
   if (a > 10)
       if (a < 20)
           System.out.println("a在10-20之間");
   else // 實(shí)際匹配的是 內(nèi)層if，而非外層if
       System.out.println("a<=10");

5. if 條件表達(dá)式后面沒(méi)有分號(hào)，如果筆誤加入分號(hào)會(huì)導(dǎo)致分號(hào)成為 if 語(yǔ)句的語(yǔ)句體，而大括號(hào)中的代碼塊成為了和 if 語(yǔ)句無(wú)關(guān)的代碼塊，不管是否成立都會(huì)執(zhí)行

   int x = 20; 
   if (x == 10); 
   { System.out.println("hehe"); 
   } // 運(yùn)行結(jié)果 hehe 

6. 由于多分支結(jié)構(gòu)中匹配到成立條件后就會(huì)跳出分支，所有建議把概率高的條件寫(xiě)在前面減少條件判斷次數(shù)，提升程序執(zhí)行效率

2.2 switch 分支結(jié)構(gòu)

讓我們先看看 switch 分支結(jié)構(gòu)的語(yǔ)法組成：

switch (匹配表達(dá)式) {
    case 常量值1:
        // 匹配表達(dá)式 == 常量值1 時(shí)執(zhí)行
        break; // 跳出switch分支，可選
    case 常量值2:
        // 匹配表達(dá)式 == 常量值2 時(shí)執(zhí)行
        break;
    // ... 可以寫(xiě)多個(gè) case
    default:
        // 所有case都匹配失敗時(shí)執(zhí)行，可選，位置任意
        break;
}

switch 是等值匹配分支，僅支持變量值 == 常量值的判斷，不支持諸如score >= 60的范圍判斷。語(yǔ)法較為簡(jiǎn)潔高效，底層是哈希表匹配，比多層 else if 更為高效。switch 會(huì)先計(jì)算出匹配表達(dá)式的值，然后與case依次匹配，一旦有匹配的值就執(zhí)行該項(xiàng)下面的語(yǔ)句，直到遇到break才會(huì)結(jié)束，當(dāng)表達(dá)式的值沒(méi)有與所列項(xiàng)匹配時(shí)，執(zhí)行default下的語(yǔ)句。需要注意的是如果沒(méi)有break的話會(huì)出現(xiàn)穿透現(xiàn)象。

讓我們寫(xiě)一個(gè)案例嘗試使用 switch 分支結(jié)構(gòu)：根據(jù)星期數(shù)字輸出對(duì)應(yīng)的星期名稱

// 根據(jù)星期數(shù)字，輸出對(duì)應(yīng)的星期名稱
int week = 3;
switch (week) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    case 4:
        System.out.println("星期四");
        break;
    case 5:
        System.out.println("星期五");
        break;
    case 6:
        System.out.println("星期六");
        break;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("輸入的星期數(shù)不合法！");
        break;
}

注意事項(xiàng)

1. 匹配表達(dá)式的數(shù)據(jù)類型只能是以下類型：byte，char，short，int，String，枚舉，不能是long

2. case后面必須跟常量值，不能是變量或者表達(dá)式，多個(gè)case不能有相同的常量值

3. defalut可有可沒(méi)有，并且可以寫(xiě)在任意位置，但是建議寫(xiě)在最后面

4. 關(guān)于穿透現(xiàn)象：什么是穿透現(xiàn)象呢？如果case代碼塊的末尾沒(méi)有寫(xiě)break語(yǔ)句，匹配成功后會(huì)執(zhí)行當(dāng)前case的代碼，并且會(huì)執(zhí)行后續(xù)所有case的代碼，直到遇到break或者switch語(yǔ)句結(jié)束，穿透不是bug，而是特性，適合應(yīng)用在多個(gè)常量值對(duì)應(yīng)同一個(gè)執(zhí)行邏輯的場(chǎng)景，如下

   // 需求：判斷星期是否為工作日（1-5）或休息日（6-7）
   int week = 2;
   switch (week) {
       case 1:
       case 2:
       case 3:
       case 4:
       case 5:
           System.out.println("工作日，努力搬磚！");
           break; // 匹配1-5任意值，都會(huì)執(zhí)行上面的語(yǔ)句，然后跳出
       case 6:
       case 7:
           System.out.println("休息日，好好休息！");
           break;
       default:
           System.out.println("輸入錯(cuò)誤！");
           break;
   }

5. 在JDK14中switch有新的寫(xiě)法，不需要寫(xiě)break，并且不會(huì)出現(xiàn)穿透現(xiàn)象，還能夠直接返回結(jié)果，語(yǔ)法如下：

   // 寫(xiě)法1：箭頭語(yǔ)法 -> ，無(wú)需break，自動(dòng)跳出
   switch (匹配表達(dá)式) {
       case 常量值1 -> 執(zhí)行語(yǔ)句1;
       case 常量值2 -> 執(zhí)行語(yǔ)句2;
       default -> 執(zhí)行語(yǔ)句3;
   }
   
   // 寫(xiě)法2：帶 yield 返回值，適合多語(yǔ)句執(zhí)行并返回結(jié)果
   變量類型 接收變量 = switch (匹配表達(dá)式) {
       case 常量值1 -> 結(jié)果值1;
       case 常量值2 -> {
           // 多行語(yǔ)句
           yield 結(jié)果值2; // yield 關(guān)鍵字返回結(jié)果
       }
       default -> 結(jié)果值3;
   };

   // 箭頭語(yǔ)法簡(jiǎn)化switch
   int week = 3;
   switch (week) {
       case 1,2,3,4,5 -> System.out.println("工作日"); // 多個(gè)常量值用逗號(hào)分隔
       case 6,7 -> System.out.println("休息日");
       default -> System.out.println("輸入錯(cuò)誤");
   }
   
   // yield返回值
   int num = 2;
   String result = switch (num) {
       case 1 -> "一";
       case 2 -> {
           System.out.println("匹配到了2");
           yield "二";
       }
       default -> "未知";
   };
   System.out.println(result); // 輸出：二

3. 循環(huán)結(jié)構(gòu)

聽(tīng)名知意，循環(huán)結(jié)構(gòu)就是根據(jù)具體的循環(huán)條件，重復(fù)執(zhí)行某一段代碼塊，這段重復(fù)執(zhí)行的代碼塊我們稱之為循環(huán)體。循環(huán)結(jié)構(gòu)有四個(gè)要素：初始化條件，循環(huán)條件，循環(huán)體，更新條件，這四者缺一不可，否則會(huì)出現(xiàn)死循環(huán)。何為死循環(huán)呢？死循環(huán)就是指循環(huán)條件永遠(yuǎn)是 true，會(huì)無(wú)限執(zhí)行循環(huán)體。與 if 一樣，如果循環(huán)體只有一行語(yǔ)句大括號(hào)是可以省略的，但是建議加上。Java中提供了 4 種循環(huán)，分別是 for 循環(huán)， while 循環(huán)，do-while 循環(huán)，增強(qiáng)for循環(huán)。下面就讓我們具體看看這 4 種循環(huán)。

3.1 for循環(huán)

3.1.1 語(yǔ)法結(jié)構(gòu)

for 循環(huán)是 Java 中使用率最高的循環(huán)，語(yǔ)法格式整潔，把初始化條件，循環(huán)條件，更新條件三個(gè)要素集中寫(xiě)到了循環(huán)頭部，每個(gè)條件之間用分號(hào)隔開(kāi)，語(yǔ)法如下：

// 循環(huán)四要素集中體現(xiàn)
for (初始化條件; 循環(huán)條件; 更新條件) {
    // 循環(huán)體：滿足循環(huán)條件時(shí)，重復(fù)執(zhí)行的代碼塊
}

執(zhí)行流程如下：

1. 執(zhí)行初始化條件，并且只會(huì)執(zhí)行一次

2. 判斷循環(huán)條件，如果為 false 則循環(huán)結(jié)束跳出循環(huán)，如果為 true 則執(zhí)行循環(huán)體

3. 循環(huán)體執(zhí)行完畢后執(zhí)行更新條件

4. 回到步驟2，3重復(fù)判斷循環(huán)條件，執(zhí)行循環(huán)體，更新條件，直到循環(huán)條件為false

3.1.2 代碼示例

1. 打印1-5

for (int i = 1; i < 6; i++) {
    System.out.println(i);
}

2. 計(jì)算1-5的和

int sum = 0;
for (int i = 1; i++; i<=5) {
    sum += i;
}
System.out.println(sum);

3. 計(jì)算5的乘階

int sum = 1;
for (int i = 1; i++; i<=5) {
    sum *= i;
}
System.out.println(sum);

4. 計(jì)算 1！+2！+3！+4！+5！

int sum = 0;
for (int i = 1; i++; i<=5) {
    int tmp = 1;
    for (int j = 1; j++; j <=i) {
        tmp *= i;
    }
    sum += tmp;
}
System.out.println(sum);

3.1.3 for 嵌套

與 if 分支結(jié)構(gòu)一樣，for 循環(huán)結(jié)構(gòu)也是可以進(jìn)行嵌套使用的，外層循環(huán)執(zhí)行一次，內(nèi)層循環(huán)執(zhí)行全部次數(shù)。常見(jiàn)的場(chǎng)景比如打印九九乘法表，二維數(shù)組遍歷等。下面就以打印九九乘法表為例：

// 九九乘法表
for (int i = 1; i <= 9; i++) { // 外層：行數(shù)
    for (int j = 1; j <= i; j++) { // 內(nèi)層：列數(shù)，列數(shù)<=行數(shù)
        System.out.print(j + "*" + i + "=" + (i*j) + "\t");
    }
    System.out.println(); // 換行
}

3.1.4 注意事項(xiàng)

1. 初始化條件的作用域：初始化的變量?jī)H在 for 循環(huán)內(nèi)部生效，循環(huán)結(jié)束后變量失效，外部無(wú)法訪問(wèn)

2. for 后面不要多些分號(hào)，否則可能導(dǎo)致循環(huán)不能正確執(zhí)行，建議{與for寫(xiě)在同一行

3.2 while 循環(huán)

3.2.1 基本語(yǔ)法

while 循環(huán)語(yǔ)法簡(jiǎn)潔，適合用于循環(huán)次數(shù)不明確的場(chǎng)景，比如用戶輸入密碼，直到輸入正確為止。語(yǔ)法格式如下：

// 1. 初始化條件（寫(xiě)在循環(huán)外部）
初始化條件;
while (循環(huán)條件) {
    // 2. 循環(huán)體
    循環(huán)體代碼;
    // 3. 更新條件（寫(xiě)在循環(huán)體內(nèi)部，必須寫(xiě)，否則死循環(huán)）
    更新條件;
}

需要注意初始化條件一定要寫(xiě)在循環(huán)外部，不然每次循環(huán)都會(huì)重新初始化，也會(huì)導(dǎo)致死循環(huán)。執(zhí)行流程為：

1. 先執(zhí)行外部初始化條件，并且只會(huì)執(zhí)行一次

2. 判斷循環(huán)條件，如果為false則結(jié)束循環(huán)，true則執(zhí)行循環(huán)體

3. 執(zhí)行循環(huán)體后執(zhí)行更新條件

4. 回到步驟2，3重復(fù)判斷是否符合循環(huán)條件并執(zhí)行循環(huán)體，直到條件為false

3.2.2 代碼示例

1. 打印數(shù)字1-5

   int i = 1; // 初始化
   while (i <=5) { // 循環(huán)條件
       System.out.println(i); // 循環(huán)體     
       i++; // 更新條件
   }

2. 用戶輸入密碼判斷密碼是否正確

   // 循環(huán)次數(shù)不確定（直到用戶輸入正確密碼）
   Scanner sc = new Scanner(System.in);
   String password = "";
   while (!"123456".equals(password)) { // 密碼不正確則繼續(xù)循環(huán)
       System.out.print("請(qǐng)輸入密碼：");
       password = sc.next();
   }
   System.out.println("密碼正確，登錄成功！");

3.3 do-while 循環(huán)

3.3.1 基本語(yǔ)法

do-while 循環(huán)的語(yǔ)法格式和 while 循環(huán)類似，只是把循環(huán)條件寫(xiě)在了循環(huán)體的后面，這也就使得其先執(zhí)行后判斷的語(yǔ)法特性，無(wú)論循環(huán)條件是否成立循環(huán)體至少會(huì)執(zhí)行一次。適用于必須執(zhí)行一次的場(chǎng)景，比如菜單選擇，用戶注冊(cè)的信息驗(yàn)證等。

// 1. 初始化條件
初始化條件;
do {
    // 2. 循環(huán)體（至少執(zhí)行一次）
    循環(huán)體代碼;
    // 3. 更新條件
    更新條件;
} while (循環(huán)條件); // 注意：末尾必須加分號(hào)！??！

執(zhí)行順序?yàn)椋?/p>

1. 執(zhí)行外部初始化條件，并且只會(huì)執(zhí)行一次

2. 先執(zhí)行一次循環(huán)體

3. 執(zhí)行更新條件

4. 判斷循環(huán)條件，為false則結(jié)束循環(huán)，true則回到步驟2繼續(xù)執(zhí)行

3.3.2 代碼示例

1. 打印數(shù)字1-5

   int i = 1;
   do {
       System.out.println(i);
       i++;
   } while (i <=5);

2. 即使條件不成立也要執(zhí)行一次

   int j = 10;
   do {
       System.out.println("執(zhí)行了一次循環(huán)體");
       j++;
   } while (j <=5); // 條件為false，但循環(huán)體已經(jīng)執(zhí)行了一次

3.4 增強(qiáng)for循環(huán)

3.4.1 基礎(chǔ)語(yǔ)法

增強(qiáng)for循環(huán)也叫foreach循環(huán)，專門用于遍歷數(shù)組和集合，不需要寫(xiě)下標(biāo)，也不需要判斷長(zhǎng)度，自動(dòng)遍歷容器內(nèi)的所有元素，這一特性讓其語(yǔ)法極度簡(jiǎn)潔，但也因無(wú)法獲取元素下標(biāo)，也就無(wú)法修改數(shù)組的基本類型元素，常用于需要遍歷容器，讀取元素，不需要操作下表的場(chǎng)景，語(yǔ)法格式如下：

// 遍歷數(shù)組
for (元素?cái)?shù)據(jù)類型 變量名 : 數(shù)組名) {
    // 變量名 就是當(dāng)前遍歷到的元素
}

// 遍歷集合（如ArrayList）
for (元素?cái)?shù)據(jù)類型 變量名 : 集合名) {
    // 變量名 就是當(dāng)前遍歷到的元素
}

3.4.2 代碼示例

1. 遍歷數(shù)組

   // 遍歷基本類型數(shù)組
   int[] arr = {10,20,30,40};
   for (int num : arr) {
       System.out.println(num); // 依次輸出：10,20,30,40
   }
   
   // 遍歷字符串?dāng)?shù)組
   String[] strArr = {"Java", "Python", "C++"};
   for (String str : strArr) {
       System.out.println(str);
   }

2. 遍歷集合

   import java.util.ArrayList;
   ArrayList<String> list = new ArrayList<>();
   list.add("張三");
   list.add("李四");
   for (String name : list) {
       System.out.println(name);
   }

3.4.3 注意事項(xiàng)

1. 增強(qiáng) for 循環(huán)是只讀遍歷，遍歷基本類型數(shù)組時(shí)，修改遍歷變量不會(huì)改變?cè)瓟?shù)組的值

2. 遍歷引用類型數(shù)組或集合時(shí)，可以修改元素的屬性值，如對(duì)象的 name、age

3. 增強(qiáng) for 循環(huán)的底層，本質(zhì)還是普通 for 循環(huán)，只是語(yǔ)法糖

4. 跳轉(zhuǎn)語(yǔ)句

跳轉(zhuǎn)語(yǔ)句可以改變程序的正常執(zhí)行流程，實(shí)現(xiàn)跳出循環(huán)、跳過(guò)本次循環(huán)、結(jié)束方法等功能。Java 中提供 3 個(gè)核心跳轉(zhuǎn)語(yǔ)句：break、continue、return，都是配合分支和循環(huán)使用，是邏輯控制的重要補(bǔ)充。

4.1 break

break 用于跳出循環(huán)，在 switch 中匹配到 case 后會(huì)執(zhí)行 break，直接跳出 switch，避免出現(xiàn)穿透現(xiàn)象，在循環(huán)結(jié)構(gòu)中，可以終止當(dāng)前循環(huán)，執(zhí)行循環(huán)后的代碼。當(dāng)然，如果遇到多層循環(huán)，可以跳出 break 所在層數(shù)的循環(huán)，也可以配合標(biāo)簽，跳出指定的外層循環(huán)。示例如下：

outer: for (int i = 1; i <= 3; i++) { // 外層循環(huán)標(biāo)號(hào)outer
    inner: for (int j = 1; j <= 3; j++) { // 內(nèi)層循環(huán)標(biāo)號(hào)inner
        if (i == 2 && j == 2) {
            break outer; // 跳出外層循環(huán)，所有循環(huán)都結(jié)束
        }
        System.out.println(i + "," + j);
    }
}

outer 和 inner 只是一個(gè)標(biāo)簽名，用于標(biāo)志當(dāng)前循環(huán)的層數(shù)，也可以改為 one， two等。

4.2 continue

continue 用于跳出本次循環(huán)，在循環(huán)體中如果遇到 continue 會(huì)立即跳出本次循環(huán)的剩余代碼，執(zhí)行更新條件，然后進(jìn)入下一次循環(huán)的條件判斷。與 break 的區(qū)別在于 break 會(huì)終止整個(gè)循環(huán)，而 continue 只是跳過(guò)本次循環(huán)。就比如下面這個(gè)案例：打印1-10的所有偶數(shù)：

for (int i = 1; i <= 10; i++) {
    if (i % 2 != 0) {
        continue; // 跳過(guò)奇數(shù)，直接執(zhí)行i++，進(jìn)入下一次循環(huán)
    }
    System.out.println(i); // 只打印偶數(shù)
}

4.4.3 return

return 是方法級(jí)別的跳轉(zhuǎn)語(yǔ)句，作用是結(jié)束當(dāng)前方法的執(zhí)行，無(wú)論方法中是否有循環(huán)或是分支，直接退出方法。如果方法有返回值類型，return 必須攜帶對(duì)應(yīng)類型的返回值，如果是 void 方法，return 可以省略，或是直接寫(xiě) return。就如下面示例：

// 示例1：void方法中使用return，結(jié)束方法
public static void testReturn() {
    for (int i = 1; i <= 5; i++) {
        if (i == 3) {
            return; // 結(jié)束方法，后續(xù)代碼都不執(zhí)行
        }
        System.out.println(i); // 只打印1,2
    }
    System.out.println("方法結(jié)束"); // 不會(huì)執(zhí)行
}

// 示例2：有返回值方法中使用return，返回結(jié)果
public static int getSum() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    return sum; // 返回結(jié)果，結(jié)束方法
}

5. 實(shí)戰(zhàn)案例

1. 判斷一個(gè)數(shù)是否為素?cái)?shù)

素?cái)?shù)就是指大于1且除了1和本身不能被其他自然數(shù)整除的自然數(shù)

int num = 29;
boolean isPrime = true;
if (num <= 1) {
    isPrime = false;
} else {
    for (int i = 2; i <= Math.sqrt(num); i++) { // 優(yōu)化：只需遍歷到平方根
        if (num % i == 0) {
            isPrime = false;
            break;
        }
    }
}
System.out.println(num + (isPrime ? "是質(zhì)數(shù)" : "不是質(zhì)數(shù)"));

2. 打印水仙花數(shù)

水仙花數(shù)是指其各位數(shù)字的立方和等于該數(shù)本身的三位數(shù)（如：153 = 1³+5³+3³）

for (int i = 100; i <= 999; i++) {
    int ge = i % 10; // 個(gè)位
    int shi = i / 10 % 10; // 十位
    int bai = i / 100; // 百位
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        System.out.println(i); // 輸出：153,370,371,407
    }
}

3. 猜數(shù)字游戲

在完成猜數(shù)字游戲之前我們需要了解控制臺(tái)輸入 Scanner 和隨機(jī)數(shù)的生成 Random。Scanner 是 Java 提供的控制臺(tái)輸入工具類，專門用于讀取用戶從控制臺(tái)輸入的各種數(shù)據(jù)，Random 是 Java 提供的偽隨機(jī)數(shù)生成工具類，用于生成指定類型的隨機(jī)數(shù)。后面的章節(jié)會(huì)詳細(xì)介紹，此處先用

import java.util.Scanner;
import java.util.Random;
public class GuessNumber {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        int randomNum = rd.nextInt(100) + 1; // 生成1-100的隨機(jī)數(shù)
        int guessNum = 0;
        System.out.println("猜數(shù)字游戲開(kāi)始?。?-100）");
        while (guessNum != randomNum) {
            System.out.print("請(qǐng)輸入你猜的數(shù)字：");
            guessNum = sc.nextInt();
            if (guessNum > randomNum) {
                System.out.println("猜大了，再試試！");
            } else if (guessNum < randomNum) {
                System.out.println("猜小了，再試試！");
            } else {
                System.out.println("恭喜你，猜對(duì)了！");
            }
        }
    }
}

總結(jié) 

到此這篇關(guān)于Java程序邏輯控制的文章就介紹到這了,更多相關(guān)Java程序邏輯控制內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論