java的基本語言元素--流程控制語句

流程控制語句的使用

話到這裏，就來到了一個重要的部分：Java的程序流程控制語句的使用。

之所以使用流程控制語句，是因爲一個程序的運行都是有序的，通常都是按照代碼的書寫順序從上到下，從左到右進行執行。這一過程被稱爲順序執行。

但實際開發中，我們通常都要根據實際需求，對程序的運行方式做一些目的性的改變，例如加一些條件判斷等等。

於是，這個時候就必須用到流程控制語句，來進行程序流程的控制工作了。

Java中，主要的流程控制語句分爲三種：選擇/條件語句，循環語句，跳轉語句。

一、選擇/條件語句

顧名思義，就是指一段程序根據條件判斷之後，根據判斷結果再選擇不同的處理方式的語句結構。

而必須銘記的是：條件語句的判斷條件必須滿足是boolean類型的數據。即：

條件只可以是一個boolean類型的值；是一個boolean類型的變量；或是一個返回boolean類型值的表達式。

1.1、if條件語句.

最簡單的條件語句，作爲條件分支語句，可以控制程序選擇不同的處理方式執行。有三種表現形式：

第一種表現形式：if。

通常用於只有當滿足某個條件，才具備程序繼續執行的資格的情況。例如：判斷一個人的年齡，只有判斷結果爲成年，才能繼續執行相關代碼：

private void if_Demo_1(int age) {
    if (age >= 18) {
        System.out.println("已成年，可以執行相關代碼..");
        //上網..
        //飲酒..
    }
}

第二種表現形式：if - else。

通常用於條件判斷可能存在兩種結果的情況.例如，判斷一個人的性別，性別非男即女：

private void if_Demo_2(String gender) {
    if (gender.equals("male")) {
        System.out.println("男性");
    } else {
        System.out.println("女性");
    }
}

第三種表現形式：if - else if - else。

通常用於當條件判斷可能存在兩種以上結果的情況。例如，判斷兩個數a與b的大小，則可能存在a大於b，b大於a或二者相等的三種情況：

private void if_Demo_2(int a, int b) {
    if (a > b) {
        System.out.println(a + "大於" + b);
    } else if (a < b) {
        System.out.println(b + "大於" + a);
    } else {
        System.out.println(a + "等於" + b);
    }
}

最後順帶一提的就是，某些情況下會存在：僅僅通過一次條件判斷，還無法選擇正確的處理方式的情況。這時就可以通過對if語句嵌套，完成多次判斷：

/*
 * 一傢俱樂部，只針對年滿18歲的女性營業
 */
private void if_Demo_4(String gender, int age) {
    if (gender.equals("male")) {
        if (age >= 18) {
            System.out.println("歡迎觀臨.");
        } else {
            System.out.println("對不起，您未滿18歲!");
        }
    } else {
        System.out.println("對不起，我們只針對女性營業!");
    }
}

1.2、switch條件/選擇語句

我們注意到在if語句的使用中，如果當條件判斷存在多種結果的時候，則必須使用“if - else if - else”的方式來處理。

那自然我們可以想象如果當一個條件存在大量的可能結果時，我們可能就必須書寫大量的else if語句，這樣做可能會比較麻煩。

針對於這樣的情況，Java提供了另一種相對簡單一些的形式，就是switch條件語句。對於switch語句，值得注意的是：

其接受的條件只能是一個整型數據或枚舉常量，只是在JDK1.7之後又新支持了String類型。

而同時我們知道Java中支持數據類型轉換，而byte,short,char都可以被隱式的自動轉換爲int。

所以通常來說：switch語句所能接受的條件只能是byte,short,int,char或枚舉類型的數據。

正是因爲如此，所以switch語句相對於if語句而言，本身存在一定的侷限性。

通常來說，一個switch語句的定義格式爲：

switch (key) {
case value:

    break;

default:
    break;
}

舉例而言，假設我們通過用戶輸入的一個整數，來查詢對應的星期數:

private void switch_demo(int num) {
    switch (num) {
    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("沒有對應的星期數");
        break;
    }
}

swtich語句的執行過程是這樣的，首先計算條件表達式的值，然後根據值分別對每個case進行匹配工作。

假如找到對應的匹配，則執行該case值下的程序語句；如果沒有匹配的case值，則執行default下的程序語句。

在執行完case的語句塊後，應當使用跳轉語句break語句跳出該switch語句。

因爲如果沒有添加break語句，程序在執行完匹配的case值下的程序語句後，

並不會停止，而是將會連續執行下一個case值下的代碼，直到碰到break語句爲止。

多重if和switch的區別

我們已經知道在某些情況下，多重if和switch是可以完成相同的目的的。而它們最大的區別就在於：

switch語句侷限性更大，這是因爲我們說過了：switch語句只能對類型爲byte,short,int,long或枚舉的數據的具體值進行判斷。

但if既可以對具體的值進行判斷；也可以進行區間判斷；同時還可以對返回值類型爲boolean類型的表達式進行判斷，如：

public void ifTest(int a, char c,String s) {
    //對具體的值進行判斷
    if(a == 5);
    if(c == 'a');
    if(s.equals("s"));
    //對區間進行判斷
    if(a>5&&a<=10);
    //對返回值爲boolean類型的表達式進行判斷
    if(a>=c);
}

而網上很多人說，switch語句的效率相對高於if語句。這是因爲：switch語句會將所有可能情況的代碼語句一次性都加載進內存，所以在執行時效率相對較高。

但因爲其本身的侷限性，所以在實際開發中，還是因該根據實際需求選擇最合適的做法。

二、循環語句

顧名思義，循環語句也就是指用於控制同一段程序反覆多次運行的語句。Java中循環語句有三種，分別爲：while、do-while以及for循環。

可以說，三種循環語句之間的區別實際不大，但同時也可以說都有本質的區別。下面我們分別來看一下三種循環的原理和使用。

2.1、while循環語句

/*
 * while循環語句的定義格式爲：
 * while(條件){
 *   //循環內容..
 * }
 */
private void while_demo(int a){
    while(a < 20){
        System.out.println(++a);
    }
}

與if條件語句相同，while語句也會接受一個boolean類型的值作爲條件。

當該條件判斷爲true時，則會循環執行循環體的內容；當執行到條件判斷結果爲false時，就會結束循環。

2.2、do-while循環語句

/*
 * do-while循環語句的定義格式爲：
 * do {
    //循環體
       } while (condition);
 */
private void do_while_demo(int a){
    do {
        System.out.println("執行一次循環:"+(++a));
    } while (a<20);
}

do-while循環與while循環最大的不同就是：無論循環條件的判斷結果是否爲true，都會至少執行一次循環體中的內容。

之所以Java會單獨提供do-while這種循環方式，也正是因爲：當使用while循環的時候，如果首次判斷循環條件的結果就爲假的話，那麼該循環就會直接被跳過，根本不會執行。而事實上，我們很多時候會希望循環體至少執行一次。

2.3、for循環語句

/*
 * for循環的定義格式爲：
 * for(初始化表達式；循環條件表達式；迭代運算)
 *  {
 *      執行語句；(循環體)
 *  }
 */
private void for_demo(){
    for (int i = 0; i < 20; i++) {
        System.out.println(++i);
    }
}

for循環的執行過程爲：

1.執行循環的初始化，通過它設置循環的控制變量值

2.判斷循環條件：如果爲真，則執行循環體內容；如果爲假，則退出循環；

3.執行迭代運算。迭代運算通常是一個表達式，用於改變循環控制變量的值。

4.再次執行循環條件判斷，然後反覆第2-3步的步驟，直到循環條件判斷爲假時，則退出循環。

需要注意的是：for循環的初始化表達式，只會在循環第一次開始時執行一次；

而迭代運算表達式則會在每一次循環體內容執行完畢後，緊接着執行一次。

可以通過一道網上流傳的華爲的Java面試題，來更形象的瞭解for循環的執行特點：

/*
What is the result?
A. ABDCBDCB
B. ABCDABCD
C. Compilation fails.
D. An exception is thrown at runtime.
*/
public class Demo {
    static boolean foo(char c) {
        System.out.print(c);
        return true;
    }

    public static void main(String[] args) {
        int i = 0;
        //ABDCBDCB
        for (foo('A'); foo('B') && (i < 2); foo('C')) {
            i++;
            foo('D');
        }
    }

}

最終執行的結果爲：ABDCBDCB，我們來逐步分解該輸出結果形成的原因：

1.for循環第一次開始執行，首先執行循環初始化表達式，於是foo('A')被執行，輸出A。此時輸出結果爲：A

2.緊接着開始執行循環條件判斷，於是foo('B')被執行，輸出B；接着判斷i(0)<2；循環條件判斷結果爲真。此時輸出結果爲：AB

3.由於該次判斷結果爲真，於是開始執行循環體。於是，i自增運算，值變爲1；foo('D')被執行，輸出D。此時輸出結果爲：ABD

4.一次循環體內容執行完畢，緊接着開始執行迭代運算表達式：foo('C'),於是輸出C。此時輸出結果爲：ABDC

5.再次開始新一次的循環條件判斷，於是foo('B')被執行，輸出B；接着判斷i(1)<2；循環條件判斷結果爲真。此時輸出結果爲：ABDCB

6.再次開始執行循環體。於是i繼續自增運算，值變爲2；foo('D')被執行，輸出D。此時輸出結果爲：ABDCBD

7.循環體內容又一次執行完畢，同樣緊接着開始執行迭代運算表達式：foo('C'),於是再次輸出C。此時輸出結果爲：ABDCBDC

8.進行新一輪的循環條件判斷。於是foo('B')被執行，又一次輸出B；接着判斷i(2)<2，此次循環條件判斷結果爲假，於是循環到此退出。

所以，最終該程序的運行結果爲：ABDCBDCB

while循環與for循環的異同

while循環與for循環之間實際上是可以相互替換的。以常見的數的累加的問題來說，以while循環和for循環分別的實現形式爲：

/*
 * 求1到100之間的數累加的和?
 */
public class Demo {
    private static int for_demo() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }

    private static int while_demo() {
        int sum = 0;
        int i = 0;
        while (i <= 100) {
            sum = sum + (i++);
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println("通過for循環完成累加的值爲:" + for_demo());
        System.out.println("通過while循環完成累加的值爲:" + while_demo());
    }
}

而while和for之間唯一的小差就在於：循環控制變量的作用域。這實際上正是涉及到在這篇博客中提到的代碼塊的相關知識。從上面的用例代碼中，我們看到：

方法“for_demo”中，用於控制for循環的循環控制變量“i”，被聲明在for循環語句內。所以這裏的變量“i”實際上，是被聲明在for循環語句塊當中的局部變量，所以隨着for循環語句塊的運行結束，該變量就會從內存中釋放，走到生命週期的盡頭。

反觀方法“while_demo”中，用於控制while循環的循環控制變量"i"則只能被聲明在屬於"while_demo"的方法代碼塊中，而不屬於循環本身。也就是說，就算當while循環運行結束，該循環控制變量依然有效，仍然可以被訪問，因爲它實際是屬於“while_demo”所聲明的代碼塊中。

這也正是我在這個專欄系列裏，第一篇文章《第一個專欄《重走J2SE之路》，你是否和我有一樣的困擾？ 》中提到的：

爲什麼查看一些Java的源碼時，發現老外很多時候選擇使用for循環的原因，也正是因爲for循環相對於while循環，可以在很小程度上減少內存的開銷，

三、跳轉語句

跳轉語句是指打破程序的正常運行，跳轉到其他部分的語句。Java提供了三種跳轉語句，分別爲：break、continue以及return。

3.1、break語句

break語句的使用方式主要三種：跳出switch條件語句、跳出循環以及通過代碼塊的標示符跳出代碼塊。我們通過一段代碼分別看一下它們具體的應用：

void break_demo(int a) {
    // 跳出switch條件語句
    switch (a) {
    case 1:
        System.out.println();
        break;

    default:
        break;
    }

    // 跳出循環
    while (true) {
        if (++a > 50) {
            break;
        }
    }

    // 跳出代碼塊
    my_block_1: {
        my_block_2: {
            a++;
            if (a > 5) {
                break my_block_1;
            }
        }

    }
}

值得注意的是：在使用break跳出循環時，只會跳出其所在的循環，而其外部的循環並不會跳出，還會繼續運行。

3.2、continue語句

break語句可以用於跳出其所在循環。但是有時我們需要跳出一次循環剩餘的循環部分，但同時還要繼續下一次循環，這時就用到了continue語句。

 void continue_demo(){
or (int i = 1; i <= 30; i++) {
System.out.print(i+"\t");

if(i%5!=0)
    continue;

    System.out.println("*");
}

這段代碼運行的輸出結果爲：

這正是continue語句起到的作用，每執行一次循環體的內容。

首先會輸出“i”當前的值及一個製表符，然後會判斷當前“i”是否是5的倍數。

如果是不是5的倍數，則會通過continue語句結束該次剩餘的部分，所以在其之後的輸出語句便不會再被執行。

而如果是5的倍數的話，纔會執行之後的輸出語句，輸出一個“*”號，並換行。

由此，最終纔出現了上面我們看到的輸出效果。

所以，總的來說break與continue的區別就在於：break語句用於退出整個循環；而continue語句則是用於結束該次循環的剩餘循環部分，但繼續新一次的循環。

3.3、return語句

簡單的來說，如果說break用於跳出循環的話，而return語句則是用於結束整個方法並返回。

return語句可以說是實際開發中最常用的跳轉語句了，因爲任何方法都需要return語句來控制方法的結束並返回對應類型的值。

void return_demo_1() {
    /*
     * 實際上void返回類型的值，也使用了return。 只不過在以void作爲返回類型的方法中，return是隱式的存在的。
     */
}

int return_demo_2() {
    /*
     * 通過return
     */
    for (int i = 0; i < 5; i++) {
        i++;
        for (int j = 0; j < 20; j++) {
            if (j == 3) {
                /*
                 * 這裏如果使用break,雖然內部循環會被退出，但外部循環仍然會繼續執行
                 * 而使用return則意味結束整個方法，並返回值“5”，
                 *  這樣做代表這之後的代表將永遠沒有機會再運行。
                 */
                return 5;
            }
        }
        // 該語句永遠不會被執行到。
        System.out.println("外部循環執行一次..");
    }
    return 0;
}

到了這裏，Java中程序語句的使用，我們已經有了一個不錯的瞭解了。最後，就通過一個實際應用的小例子，輸出九九乘法表作爲結束吧：

package com.tsr.j2seoverstudy.base;

public class Print99 {
    public static void main(String[] args) {
        System.out.println("*******************************九九乘法表********************************");

        for (int i = 1; i <= 9; i++) {
            System.out.print("\t"+i);
        }

        System.out.println();

        for (int i = 1; i <= 9; i++) {
            System.out.print(i+"\t");
            for (int j = 1; j <= i; j++) {
                System.out.print(i*j+"\t");
            }
            System.out.println();
        }
    }
}

運行程序，查看其輸出結果：