前言

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

• 順序結(jié)構(gòu)：代碼從上到下，逐行執(zhí)行，沒有跳轉(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)就是代碼按照書寫的前后順序從上到下逐行執(zhí)行，沒有任何的判斷條件和跳轉(zhuǎn)語句，也無需任何關(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");
    }
}
// 運行結(jié)果
// aaa
// bbb
// ccc

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

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

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

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

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

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

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

2.1.1 基礎(chǔ)用法

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

單分支

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

條件表達式的結(jié)果必須是 boolean 類型，大括號內(nèi)是滿足條件的執(zhí)行體。就比如考試成績在90分以上就獎勵一個大雞腿，代碼如下：

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

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

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

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

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

2.1.2 if 嵌套

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

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

2.1.3 注意事項

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

2. if 條件表達式寫判斷號 == 而非賦值號 =

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

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

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

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

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

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

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

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

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

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

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

// 根據(jù)星期數(shù)字，輸出對應(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;
}

注意事項

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

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

3. defalut可有可沒有，并且可以寫在任意位置，但是建議寫在最后面

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

   // 需求：判斷星期是否為工作日（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任意值，都會執(zhí)行上面的語句，然后跳出
       case 6:
       case 7:
           System.out.println("休息日，好好休息！");
           break;
       default:
           System.out.println("輸入錯誤！");
           break;
   }

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

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

   // 箭頭語法簡化switch
   int week = 3;
   switch (week) {
       case 1,2,3,4,5 -> System.out.println("工作日"); // 多個常量值用逗號分隔
       case 6,7 -> System.out.println("休息日");
       default -> System.out.println("輸入錯誤");
   }
   
   // 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)

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

3.1 for循環(huán)

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

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

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

執(zhí)行流程如下：

1. 執(zhí)行初始化條件，并且只會執(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. 計算1-5的和

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

3. 計算5的乘階

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

4. 計算 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)也是可以進行嵌套使用的，外層循環(huán)執(zhí)行一次，內(nèi)層循環(huán)執(zhí)行全部次數(shù)。常見的場景比如打印九九乘法表，二維數(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 注意事項

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

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

3.2 while 循環(huán)

3.2.1 基本語法

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

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

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

1. 先執(zhí)行外部初始化條件，并且只會執(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("請輸入密碼：");
       password = sc.next();
   }
   System.out.println("密碼正確，登錄成功！");

3.3 do-while 循環(huán)

3.3.1 基本語法

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

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

執(zhí)行順序為：

1. 執(zhí)行外部初始化條件，并且只會執(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 增強for循環(huán)

3.4.1 基礎(chǔ)語法

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

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

// 遍歷集合（如ArrayList）
for (元素數(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 注意事項

1. 增強 for 循環(huán)是只讀遍歷，遍歷基本類型數(shù)組時，修改遍歷變量不會改變原數(shù)組的值

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

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

4. 跳轉(zhuǎn)語句

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

4.1 break

break 用于跳出循環(huán)，在 switch 中匹配到 case 后會執(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)，也可以配合標簽，跳出指定的外層循環(huán)。示例如下：

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

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

4.2 continue

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

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

4.4.3 return

return 是方法級別的跳轉(zhuǎn)語句，作用是結(jié)束當(dāng)前方法的執(zhí)行，無論方法中是否有循環(huán)或是分支，直接退出方法。如果方法有返回值類型，return 必須攜帶對應(yīng)類型的返回值，如果是 void 方法，return 可以省略，或是直接寫 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é)束"); // 不會執(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. 實戰(zhàn)案例

1. 判斷一個數(shù)是否為素數(shù)

素數(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; // 個位
    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ù)字游戲之前我們需要了解控制臺輸入 Scanner 和隨機數(shù)的生成 Random。Scanner 是 Java 提供的控制臺輸入工具類，專門用于讀取用戶從控制臺輸入的各種數(shù)據(jù)，Random 是 Java 提供的偽隨機數(shù)生成工具類，用于生成指定類型的隨機數(shù)。后面的章節(jié)會詳細介紹，此處先用

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的隨機數(shù)
        int guessNum = 0;
        System.out.println("猜數(shù)字游戲開始！（1-100）");
        while (guessNum != randomNum) {
            System.out.print("請輸入你猜的數(shù)字：");
            guessNum = sc.nextInt();
            if (guessNum > randomNum) {
                System.out.println("猜大了，再試試！");
            } else if (guessNum < randomNum) {
                System.out.println("猜小了，再試試！");
            } else {
                System.out.println("恭喜你，猜對了！");
            }
        }
    }
}

總結(jié) 

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

最新評論