---
# System prepended metadata

title: 流程控制
tags: [java]

---

# 流程控制
###### tags: `java`
## 目錄

- [條件式](#條件式)
  - [if](#if)
  - [switch](#switch)
- [迴圈](#迴圈)
  - [for](#for)
  - [foreach](#foreach)
  - [while](#while)
  - [do...while](#do...while)
  - [break、continue](#break、continue)
  - [label](#label)
- [方法](#方法)



## 條件式

現實生活不會一成不變，程式也是一樣，會根據不同情況有不一樣的結果，例如：「如果」什麼什麼發生了，就怎麼做；「對於」某些情況，就一直執行；「如果」情況出現，就「中斷」執行。

為了告訴電腦在特定條件下該執行的動作，會使用各種條件式來決定程式執行的流程。

### if

為了根據不同情況執行不同程式碼，Java提供了if條件式 ，語法如下：

```
if(條件式)
    陳述句一;
else
    陳述句二;
```

解說：當「條件式」成立時（true），則執行「陳述句一」，要不然（else）就執行「陳述句二」；如果條件式不成立時並不想作任何事，則 else 可以省略。

在 if 後如果有兩個以上陳述句，稱之為「複合陳述句」（Compound statement），此時必須使用 { } 定義區塊（Block）將複合陳述句包括起來，例如：

```
if(條件式) {
    陳述句一;
    陳述句二;
 }
 else {
    陳述句三;
    陳述句四;
 }
```

使用if條件式來判斷使用者的輸入是奇數還是偶數：

```
import java.io.*;
 
public class App {
    public static void main(String[] args) throws Exception {
        BufferedReader br = 
            new BufferedReader(new InputStreamReader(System.in));
 
        System.out.print("請輸入數字: "); 
        int input = Integer.parseInt(br.readLine());
        int remain = input % 2; // 求除 2 的餘數
 
        if(remain == 1) // 如果餘數為1
            System.out.println(input + "為奇數"); 
        else 
            System.out.println(input + "為偶數"); 
    }
}
```

在 if 中您也可以再設定執行的條件，例如：

```
if(條件式一) { 
    陳述句一; 
    if(條件式二) 
        陳述句二; 
    陳述句三; 
 } 
```

這只個簡單的例子，其中陳述句二要執行，必須同時滿足「條件式一」與「條件式二」才行；再來看個例子：

```
if(條件式一) { 
    陳述句一; 
    // 其它陳述句 
 } 
 else 
    if(條件式二) 
        陳述句二; 
```

如果「條件式一」不滿足，就會執行 else 中的陳述，而您在這邊進行「條件式二」的測試，如果滿足就執行「陳述句二」，由於 Java 是個自由格式語言，您可以適當的排列這個程式，這會比較好懂一些：

```
if(條件式一) { 
    陳述句一; 
    // 其它陳述句 
} 
else if(條件式二) 
    陳述句二; 
```

基於這個方式，您可以如下設定多個條件，且易讀易懂：

```
 if(條件式一) 
    陳述一; 
 else if(條件式二) 
    陳述句二; 
 else if(條件式三） 
    陳述句三; 
 else 
        陳述句四; 
```

「陳述句四」會在條件式一、二、三都不成立時執行。

**範例：**處理學生的成績等級問題：

```
import java.io.*;
 
public class App {
    public static void main(String[] args) throws Exception {
        BufferedReader br = 
            new BufferedReader(new InputStreamReader(System.in));
 
        System.out.print("輸入分數："); 
        int score = Integer.parseInt(br.readLine());
 
        if(score >= 90) 
            System.out.println("得A"); 
        else if(score >= 80 && score < 90) 
            System.out.println("得B"); 
        else if(score >= 70 && score < 80) 
            System.out.println("得C"); 
        else if(score >= 60 && score < 70) 
            System.out.println("得D"); 
        else 
            System.out.println("得E(不及格)"); 
    }
}
```

執行結果如下：

```
輸入分數：88
得B
```

在這邊要注意的是 if 與 else 的配對問題，例如以下程式依縮排來看，您覺得有無問題存在？

```
if(條件式一) 
    if(條件式二) 
        陳述句一; 
    else 
        陳述句二; 
```

很多人都會以為「條件式二」的 if 會與 else 配對，但事實上是「條件式一」的 if 與 else 配對，加上括號的話就不會誤會了：

```
if(條件式一) { 
    if(條件式二) 
        陳述句一; 
    else 
        陳述句二; 
 } 
```

如果想避免這種錯誤，在程式中多使用括號是必要的，多寫一些總是比少寫一些來得保險一點。

注意到了嗎？在撰寫程式時適當的使用縮排（Indent），可以在定義程式區塊時讓區塊範圍看來容易分辨。

**練習**
1. 寫一個猜拳遊戲:
```
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class App {
    public static void main(String[] argc) throws Exception {
        final int scissors = 0;
        final int stone = 1;
        final int paper = 2;

        // 電腦出拳 0=剪刀, 1=石頭, 2=布
        int pc = (int)(Math.random() * 3);

        // 測試用
        if(pc == scissors)
            System.out.println("電腦出了剪刀");
        else if(pc == stone)
            System.out.println("電腦出了石頭");
        else if(pc == paper)
            System.out.println("電腦出了布");
        else 
            System.out.println("電腦出錯了");

        // 玩家出拳
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        System.out.print("請出拳(0=剪刀, 1=石頭, 2=布):");
        int player = Integer.parseInt(br.readLine());

        if(player == scissors)
            System.out.println("你出了剪刀");
        else if(player == stone)
            System.out.println("你了石頭");
        else if(player == paper)
            System.out.println("你出了布");
        else 
            System.out.println("你出錯了");

        if(player == pc)
            System.out.println("平手");
        else if(player == scissors && pc == stone)
            System.out.println("你輸了");
        else if(player == scissors && pc == paper)
            System.out.println("你贏了");
        else if(player == stone && pc == scissors)
            System.out.println("你贏了");
        else if(player == stone && pc == paper)
            System.out.println("你輸了");
        else if(player == paper && pc == scissors)
            System.out.println("你輸了");
        else if(player == paper && pc == stone)
            System.out.println("你贏了");
        else
            System.out.println("遊戲錯誤");
    }
}
```



### switch

switch 可以用來比較數值、字元、字串、列舉（Enum）和Wrapper Class，不過別以為這樣它就比 if 來得沒用，使用適當的話，它可比 if 判斷式來得有效率；switch 的語法架構如下：

```
switch(變數名稱或運算式) { 
    case 符合數字或字元: 
        陳述句一; 
        break; 
    case 符合數字或字元: 
        陳述句二; 
        break; 
    default: 
        陳述三; 
 } 
```

首先看看 switch 的括號，當中置放您要取出數值的變數，取出數值之後，程式會開始與 case 中所設定的數字或字元作比對，如果符合就執行當中的陳述句，直到遇到 break 後離開 switch 區塊，如果沒有符合的數值或字元，則會執行 default 後的陳述句，default 不一定需要，如果沒有預設要處理的動作，您可以省去這個部份。

**範例：**成績等級比對如何使用 switch 來改寫：

```
import java.io.*;
 
public class App {
    public static void main(String[] args) throws Exception {
        BufferedReader br = 
            new BufferedReader(new InputStreamReader(System.in));
 
        System.out.print("請輸入分數: "); 
        int score = Integer.parseInt(br.readLine());
        int level = (int) score/10; 
 
        switch(level) { 
            case 10: 
            case 9: 
                System.out.println("得A"); 
                break; 
            case 8: 
                System.out.println("得B"); 
                break; 
            case 7: 
                System.out.println("得C"); 
                break; 
            case 6: 
                System.out.println("得D"); 
                break; 
            default: 
                System.out.println("得E(不及格)"); 
        }
    }
}
```

在這個程式中，您使用除法並取得運算後的商數，如果大於 90 的話，除以 10 的商數一定是 9 或 10（100 分時），在 case 10 中沒有任何的陳述，也沒有使用 break，所以會繼續往下執行，直到遇到 break 離開 switch 為止，所以學生成績 100 分的話，也會顯示 A 的成績等級；如果比對的條件不在10到6這些值的話，會執行 default 下的陳述，這表示商數小於 6，所以學生的成績等級就顯示為 E 了。

注意在 case 後的等號是冒號而不是分號，這是個很常打錯的符號；如果您比對的是字元，則記得加上單引號（' '），例如：

```
case 'A':
```

這個程式與使用 if 來判斷成績等級的程式有何不同？如果純綷比對數字或字元的話，建議使用 switch，因為它只會在一開始的 switch 括號中取出變數值一次，然後將這個值與下面所設定的 case 比對，但如果您使用if的話，每次遇到條件式時，都要取出變數值，效率的差異就在這，例如：

```
if(a == 1) 
    // .... 
else if(a == 2) 
    // .... 
else if(a == 3) 
    // .... 
```

這個程式片段在最差的狀況下，也就是 a = 3 時，共需三次比對，而每次比對都必須取出變數 a 的值一次，如果換成 switch 的話：

```
switch(a) { 
    case 1: 
        // .. 
        break; 
    case 2: 
        // .. 
        break; 
    case 3: 
        // .. 
        break; 
} 
```

在這個程式片段中，您只在一開頭 switch 的括號中取出變數 a 的值，然後逐一比對下面的 case，效率的差別就在於這邊；當然並不是使用 if 就不好，遇到複合條件時，switch 就幫不上忙了，您無法在 switch 中組合複雜的條件陳述，這時就得使用 if 了，簡單的說，if 與 switch 兩者可以搭配著靈活使用。

```
public class App {
    public static void main(String[] argc) throws Exception {
        // 今日運勢(5種結果)
        int luck = (int)(Math.random() * 5); // 產生0~4隨機整數
        
        if(luck == 0) {
            System.out.println("今日會發財");
        } else if(luck == 1) {
            System.out.println("今日會升官");
        } else if(luck == 2) {
            System.out.println("今天有桃花");
        } else if(luck == 3) {
            System.out.println("今日很平安");
        } else if(luck == 4) {
            System.out.println("今日有飯吃");
        } else {
            System.out.println("系統錯誤");
        }

        switch(luck) {
        case 0:
            System.out.println("今日會發財");
            break;
        case 1:
            System.out.println("今日會升官");
            break;
        case 2:
            System.out.println("今天有桃花");
            break;
        case 3:
            System.out.println("今日很平安");
            break;
        case 4:
            System.out.println("今日有飯吃");
            break;
        default:
            System.out.println("系統錯誤");
            break;
        }

    }
}
```

```
import java.io.*;

public class App {
    public static void main(String[] argc) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "utf-8"));
        
        System.out.print("請輸入一個字來測字:");
        String word = br.readLine();
        
        switch(word) {
        case "work":
            System.out.println("今日工作會遭遇小人");
            break;
        case "love":
            System.out.println("今日愛情犯爛桃花");
            break;
        case "money":
            System.out.println("今日破財消災");
            break;
        default:
            System.out.println("測不出來");
            break;
        }
    }
}
```

> **補充：**
>
> - switch從JDK 7開始支援字串、列舉（Enum）和Wrapper Class，因此，如果使用的JDK版本是小於7的話，無法拿來比較字串、列舉和Wrapper Class。
>
> - Java共有把個基本型別的Wrapper Class：
>
>   | **原始型別** | 大小   | 最小值                                 | 最大值                               | **外包型別** |
>   | ------------ | ------ | -------------------------------------- | ------------------------------------ | ------------ |
>   | **char**     | 16-bit | Unicode 0                              | Unicode 216-1                        | Character    |
>   | **byte**     | 8-bit  | -128                                   | +127                                 | Byte         |
>   | **short**    | 16-bit | -215 *(-32,768)*                       | +215-1 *(32,767)*                    | Short        |
>   | **int**      | 32-bit | -231 *(-2,147,483,648)*                | +231-1 *(2,147,483,647)*             | Integer      |
>   | **long**     | 64-bit | -263 *(-9,223,372,036,854,775,808)*    | +263-1 *(9,223,372,036,854,775,807)* | Long         |
>   | **float**    | 32-bit | 32-bit IEEE 754 floating-point numbers |                                      | Float        |
>   | **double**   | 64-bit | 64-bit IEEE 754 floating-point numbers |                                      | Double       |
>   | **boolean**  | 1-bit  | `true` 或 `false`                      |                                      | Boolean      |



## 迴圈

### for

在 Java 中如果要進行重複性的指令執行，可以使用 for 迴圈式，它的基本語法如下：

```
for(初始式; 判斷式; 遞增式) {
    陳述句一; 
    陳述句二; 
 }
```

如果陳述句只有一個，也就是非複合陳述句，{ } 可以省略不寫；for 迴圈的「第一個初始陳述句只會執行一次」，之後每次重新進行迴圈時，都會「根據判斷式來判斷是否執行下一個迴圈」，而每次執行完迴圈之後，都會「執行遞增式」。

**範例：**

```
public class App { 
    public static void main(String[] args) { 
        for(int i = 0; i < 10; i++) 
            System.out.print(" " + i); 
    } 
} 
```

執行結果：

```
 0 1 2 3 4 5 6 7 8 9 
```

這是一個簡單的例子，但說明 for 的作用再適合不過，在 Java 中您可以直接在 for 中宣告變數與指定初始值，這個宣告的變數在 for 迴圈結束之後也會自動消失；初始變數的陳述句只被執行一次，接下來迴圈會根據 i 是否小於 10 來判斷是否執行迴圈，而每執行一次迴圈就將 i 加 1。

for 迴圈中也可以再使用 for 迴圈，初學者很喜歡用的例子就是顯示九九乘法表，這邊就用這個例子來說明：

```
public class App {
    public static void main(String[] args) {
        for(int j = 1; j < 10; j++) { 
           for(int i = 2; i < 10; i++) { 
               System.out.printf("%d*%d=%2d ",i, j,  i * j);
           } 
           System.out.println(); 
        }  
    }
} 
```

執行結果：

```
2*1= 2	3*1= 3	4*1= 4	5*1= 5	6*1= 6	7*1= 7	8*1= 8	9*1= 9
2*2= 4	3*2= 6	4*2= 8	5*2=10	6*2=12	7*2=14	8*2=16	9*2=18
2*3= 6	3*3= 9	4*3=12	5*3=15	6*3=18	7*3=21	8*3=24	9*3=27
2*4= 8	3*4=12	4*4=16	5*4=20	6*4=24	7*4=28	8*4=32	9*4=36
2*5=10	3*5=15	4*5=20	5*5=25	6*5=30	7*5=35	8*5=40	9*5=45
2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	7*6=42	8*6=48	9*6=54
2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	8*7=56	9*7=63
2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	9*8=72
2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
```

事實上，for 迴圈的語法其實只是將三個複合陳述區塊寫在一個括號中而已，所不同的是第一個陳述區塊只會執行一次，第二個陳述區塊專司判斷是否繼續下一個迴圈，而第三個陳述區塊只是一般的陳述句，而不一定只放遞增運算式。

for 括號中的每個陳述區塊是以分號 ';' 作區隔，而在一個陳述區塊中若想寫兩個以上的陳述句，可以使用逗號 ',' 作區隔，例如：

```
public class App { 
    public static void main(String[] args) {
        for (int i = 0, j = 0 ; i < 10 ; i++, j--) { 
            System.out.printf("i=%d, j=%d\n", i, j);
        }   
    }
} 
```

輸出：

```
i=0, j=0
i=1, j=-1
i=2, j=-2
i=3, j=-3
i=4, j=-4
i=5, j=-5
i=6, j=-6
i=7, j=-7
i=8, j=-8
i=9, j=-9
```
一個for無窮迴圈
```
for(;;) {
    System.out.println("Hi");
}
```
##### 練習
1. 將下面猜數字遊戲改成可以猜三次的版本。
```
import java.io.*;

public class App {
    public static void main(String[] argc) throws Exception {
        // 答案，隨機產生1~10之間整數
        int answer = (int)(Math.random() * 10) + 1;

        // 猜數字, 1~10之間, 如果猜3次沒猜出來, 遊戲結束, 玩家輸.
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("猜數字遊戲，從1~10，三次沒猜中就輸了。");
        System.out.print("請猜數字:");
        int num = Integer.parseInt(br.readLine());

        if(num == answer)
            System.out.println("恭喜，猜對了.");
        else
            System.out.println("猜錯.");
    }
}
```
答案:
```
import java.io.*;

public class App {
    public static void main(String[] argc) throws Exception {
        // 答案，隨機產生1~10之間整數
        int answer = (int) (Math.random() * 10) + 1;
        System.out.println("答案:" + answer);

        // 猜數字, 1~10之間, 如果猜3次沒猜出來, 遊戲結束, 玩家輸.
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("猜數字遊戲，從1~10，三次沒猜中就輸了。");

        for (int i = 1; i <= 3; i++) {
            System.out.print("請猜數字(第" + i + "次, 剩" + (3 - i + 1) + "次):");
            int num = Integer.parseInt(br.readLine());

            if (num == answer) {
                System.out.println("恭喜，猜對了.");
                break; // 猜對離開
            }
            else
                System.out.println("猜錯.");
        }

        System.out.println("遊戲結束.");
    }
}
```
2. 試著用雙層迴圈畫出下面圖案:
```
*
**
***
****
*****
```

3. 計算階層
```
import java.io.*;

public class App {
    public static void main(String[] argc) throws Exception {
        // 寫一程式，計算使用者輸入的階層
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.print("計算階層，請輸一個整數:");
        int level = Integer.parseInt(br.readLine()); // 使用者輸入階層

        int sum = 0;
        for(int i = 1 ; i <= level ; i++) {
            // System.out.print(i + " ");
            sum += i;
        }
        System.out.println(level + "的階層為:" + sum);
    }
}
```

### foreach

如果要走訪（也就是一筆一筆資料取出來處理）陣列或容器型態的資料，使用foreach迴圈會來的更方便。

例如：

```java
public class App {
    public static void main(String[] args) throws Exception {
        String[] data = {"a", "b", "c"};

        for(String elem : data) {
            System.out.println(elem);            
        }
    }
}
```

###### 輸出：

```
a
b
c
```

###### 說明：

foreach迴圈的執行次數與該陣列或容器內元素的個數一樣，每次都會取出陣列或容器內一個元素存放到for迴圈內的變數內（此範例為elem變數），因此，for迴圈本體內的程式碼每次看到的變數值都會不一樣。


### while

Java 提供 while 迴圈式，它根據您所指定的條件式來判斷是否執行迴圈本體，語法如下所示：

```
while(條件式) {
    陳述句一; 
    陳述句二; 
} 
```

如果迴圈本體只有一個陳述句，則 while 的 { } 可以省略不寫；while 像是沒有起始陳述與終止陳述的 for 迴圈，主要用於重複性的動作，而停止條件未知何時發生的情況，例如一個使用者輸入介面，使用者可能輸入 10 次，也可能輸入 20 次，這時迴圈停止的時機是未知的，您可以使用 while 迴圈來作這個事。

一個計算輸入成績平均的程式如範例：

```
import java.io.*;
 
public class App { 
    public static void main(String[] args) throws Exception {
        BufferedReader br = 
            new BufferedReader(new InputStreamReader(System.in));
 
        int score = 0; 
        int sum = 0; 
        int count = -1; 
 
        while(score != -1) { 
            count++; 
            sum += score; 
            System.out.print("輸入分數(-1結束)："); 
            score = Integer.parseInt(br.readLine());
        } 
 
        System.out.println("平均：" + (double) sum/count); 
    } 
} 
```

在這個程式中，使用者的輸入次數是未知的，所以您使用 while 迴圈來判斷使用者的輸入是否為 -1，以作為迴圈執行的條件，一個執行的例子如下：

```
輸入分數(-1結束)：99
輸入分數(-1結束)：88
輸入分數(-1結束)：77
輸入分數(-1結束)：-1
平均：88.0
```

while 可以用作無窮迴圈，很多地方都用到的到無窮迴圈，例如遊戲設計中對使用者輸入裝置的輪詢（poll），或是動畫程式的播放都會使用到無窮廻圈，一個無窮迴圈如下所示：

```
while(true) { 
    迴圈內容; 
    .... 
 }
```

無窮迴圈可以由自己迴圈中的某個條件式來結束，例如下面是一個迴圈內部終止的例子：

```
while(true) { 
    陳述句; 
    if(條件式) 
        break;  // 跳離迴圈 
     .... 
} 
```

當「條件式」成立時，會執行 break 離開 while 迴圈，這個 break 與 switch 中的作用是一樣的，都是要離開當時執行的程式區塊時使用。

### do...while

do...while與while迴圈差別是while迴圈會進行條件式判斷再決定是否執行迴圈本體，如果判斷不通過，則迴圈一次都不會執行，但do...while迴圈會先執行一次迴圈本體後才進行第一次的條件式判斷。

語法如下：

```
do { 
    陳述句一; 
    陳述句二;
    ...
    陳述句n;
 }while(條件式);
```

>  **注意**
>
> do...while迴圈的while判斷是後面需要加上分號「;」作為結束，這個很常被疏忽。



由於do...while會先執行迴圈，常用於進行一些初始化或介面溝通的動作，例如：

```
import java.io.*;
 
public class App { 
    public static void main(String[] args) throws Exception { 
        BufferedReader br = 
            new BufferedReader(new InputStreamReader(System.in));
            
        int input = 0;
        int replay = 0; 
 
        do { 
            System.out.print("輸入整數值："); 
            input = Integer.parseInt(br.readLine());
            System.out.println("輸入數為:" + ((input % 2 == 1) ? "奇數": "偶數")); 
            System.out.print("要繼續嗎？(-1:結束 1:繼續)"); 
            replay = Integer.parseInt(br.readLine());
        } while(replay != -1);   
    } 
} 
```

執行結果：

```
輸入整數值：77
輸入數為: 奇數
要繼續嗎？( -1:結束 1:繼續)？ -1
```



### break、continue

break可以用來離開目前 switch、for、while、do...while 的區塊，並跳到區塊後的下一個陳述句，在switch中主要用來結束目前的case陳述句，避免下一個case的比對；而在 for、while與do...while迴圈中，主要用於中斷目前的迴圈執行。

continue的作用與break類似，只能用在迴圈，差別break會直接結束區塊並跳離執行，而continue只會中斷本次的執行，也就是忽略continue下面的陳述句，並跳回迴圈區塊的開頭繼續下一次的迴圈，而不會離開迴圈，例如：

```
for(int i = 1; i < 10; i++) { 
    if(i == 5) 
        break; 

    System.out.println("i); 
 }
```

這段程式會顯示 1到 4，因為當 i 等於 5 時就會執行 break 而離開迴圈，再下面這個範例：

```
for(int i = 1; i < 10; i++) { 
    if(i == 5) 
        continue; 
 
    System.out.println("i = " + i); 
} 
```

這段程式會顯示 1 到 4，與 6 到 9，當 i 等於 5 時，會執行 continue 直接結束此次迴圈，由於這次迴圈中 System.out.println() 該行並沒有被執行，所以 5 並不會顯示。

### label

break 與 continue 還可以配合label使用，語法為：

```
label名稱 {
    陳述句1;
    陳述句2;
    ...
    break或continue;
    ...
    陳述句n;
}
```

- break + label = 跳離該label的範圍。
- break + continue = 跳到label處的迴圈進行下一輪，label名稱必須在該迴圈上面。

break原本只會離開 for 迴圈，但加上label則可以離開整個區塊，例如：

```
public class App { 
    public static void main(String[] args) { 
        exit : { 
            for(int i = 0; i < 10; i++) { 
                if(i == 5) { 
                    System.out.println("離開了"); 
                    break exit; 
                } 
            } 
            System.out.println("這串字不會出現"); 
        } 
    } 
} 
```

輸出為：

```
離開了
```

當 `break exit;` 時，返回至 exit 標籤處，之後整個 exit 區塊不執行而跳過，所以`System.out.println("這串字不會出現");` 不會被執行。

再看continue範例：

```
public class App { 
    public static void main(String[] args) { 
        exit1: 
        for(int i = 0; i < 10; i++){ 
            exit2: 
            for(int j = 0; j < 10; j++) { 
                if(j == 9) { 
                    continue exit1; 
                } 
            }
            System.out.println("test"); 
        } 
    } 
}
```

什麼都不會輸出，因為`continue exit1;`總是會回到第一層迴圈開頭重新跑迴圈，所以`System.out.println("test");`永遠沒有機會被執行到。

> **補充**
>
> 1. continue 配合label，可以自由的跳至任何一層 for 迴圈。
> 2. 跟判斷是一樣，label後面如果沒有大括號，則代表只有下一行為其內容。



## 方法

方法(method)為多個陳述句的集合，通常會將程式內重複的程式碼包裝成方法，好處如下：

1. 減少程式碼撰寫的次數。
2. 減少錯誤並且容易除錯：當錯誤時只需要修改同一個地方即可。
3. 重複使用，並利於發展大型程式。

#### 語法

##### 定義方法

```
修飾詞 回傳值 方法名稱(參數列表) {
    方法本體
}
```

> **注意**
>
> 參數列表後面沒有分號。

##### 呼叫方法

```
方法名稱(參數列表);
```

> **提示**
>
> 以分號做為結束。

#### 命名規則

1. 可使用英文字、數字和底線「_」，大小寫為不同名稱。
2. 第一個字不可以是數字。
3. 不可以使用Java保留字。

#### 命名慣例

1. 使用能代表該方法的有意義名稱。
2. 第一個英文字母小寫，隨後每個單字的第一個字母都大寫，其餘小寫。

一個簡單方法：

```
public class App { 
    public static void main(String[] args) {
        show(); // 呼叫方法
    }
    
    // 定義一個show方法
    static void show() {
        System.out.println("Hello");
        System.out.println("Java");
    }
}
```

解說：

在App類別內定義了一個show方法，並且在在main方法裡透過呼叫show方法來執行show方法內的陳述句。

有參數的方法：

```
public class App { 
    public static void main(String[] args) {
        showMe("Aaron"); // 呼叫方法
    }
    
    // 定義一個show方法
    static void showMe(String name) {
        System.out.printf("Hello %s\n", name);
    }
}
```

有回傳值的方法：

```
public class App { 
    public static void main(String[] args) {
        int total = add(1, 3); // 呼叫方法
        
        System.out.println(total);
    }
    
    // 定義一個add方法
    static int add(int a, int b) {
        int c = a + b;
        
        return c;
    }
}
```

> 補充：
>
> 1. 定義方法可以沒有參數，但是如果方法定義時有參數，鑿呼叫十一定要傳入參數。
>2. 如果有多個參數，可以透過逗點「,」來隔開。
> 3. static修飾詞為靜態方法，因為main方法本身為靜態方法，因此僅能呼叫靜態修飾過的方法。
> 4. 每個方法內自行宣告的變數都是區域性的，不會影響到其他方法同名的變數。

### 遞迴

遞迴（Recursion），是指在方法中呼叫自身方法，方法必須有終止條件，才能完成執行，否則會陷入無窮循環，直到耗盡系統記憶體而程式終止。

使用遞迴來計算階層：

```
public class App { 
    public static void main(String[] args) {
        int sum = factorial(5, 5);

        System.out.println(sum);
    }
    
    // 定義一個add方法
    static int factorial(int a, int sum) {
        if(a > 0)
            return factorial(a - 1, sum + --a);
        return sum;
    }
}
```

使用遞迴的猜數字遊戲，猜1~10之間數字，直到猜中才結束，並顯示次數：

```
import java.io.*;

public class App { 
    public static void main(String[] args) throws Exception {
        int answer = (int)(Math.random() * 10) + 1;

        int times = guessGame(answer, 0);

        System.out.println("總共猜了:" + times + "次");
    }
    
    // 定義一個add方法
    static int guessGame(int answer, int times) throws Exception {
        System.out.print("請猜一數字(1~10之間):");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int player = Integer.parseInt(br.readLine());

        if(answer != player)
            return guessGame(answer, ++times);
        return times + 1;
    }
}
```


