源文件中的語句通常按照它們出現的順序從上到下執行，但是，控制流語句通過使用決策、循環和分支來分解執行流程，使你的程序能夠有條件地執行特定的代碼塊，本節描述Java編程語言支持的決策語句（if-then，if-then-else，switch），循環語句（for，while，do-while）以及分支語句（break，continue，return）。

if-then語句是所有控制流語句中最基本的語句，它告訴程序只有在特定測試評估為true時才執行某段代碼，例如，Bicycle類可以允許制動器僅在自行車已經運動時降低自行車的速度，applyBrakes方法的一種可能實現如下：

void applyBrakes() {
    // the "if" clause: bicycle must be moving
    if (isMoving){ 
        // the "then" clause: decrease current speed
        currentSpeed--;
    }
}

如果此測試評估為false（意味著自行車不運動），則控制跳轉到if-then語句的末尾。

此外，只要“then”子句只包含一個語句，開括號和結束括號是可選的：

void applyBrakes() {
    // same as above, but without braces 
    if (isMoving)
        currentSpeed--;
}

決定何時省略括號是個人品味的問題，省略它們會使代碼變得更脆弱，如果稍后將第二個語句添加到“then”子句中，則常見的錯誤是忘記添加新所需的花括號，編譯器無法捕獲這種錯誤，你會得到錯誤的結果。

if-then-else語句在“if”子句求值為false時提供輔助執行路徑，如果在自行車不運動時應用制動器，你可以在applyBrakes方法中使用if-then-else語句來執行某些操作，在這種情況下，操作是簡單地打印一條錯誤消息，指出自行車已經停止。

void applyBrakes() {
    if (isMoving) {
        currentSpeed--;
    } else {
        System.err.println("The bicycle has already stopped!");
    } 
}

以下程序IfElseDemo根據測試分數的值分配成績：A得分為90％或以上，B得分為80％或以上，依此類推。

class IfElseDemo {
    public static void main(String[] args) {

        int testscore = 76;
        char grade;

        if (testscore >= 90) {
            grade = "A";
        } else if (testscore >= 80) {
            grade = "B";
        } else if (testscore >= 70) {
            grade = "C";
        } else if (testscore >= 60) {
            grade = "D";
        } else {
            grade = "F";
        }
        System.out.println("Grade = " + grade);
    }
}

該程序的輸出是：

Grade = C

你可能已經注意到testscore的值可以滿足復合語句中的多個表達式：76 >= 70和76 >= 60，但是，一旦滿足條件，就會執行適當的語句（grade ="C";），并且不評估其余條件。

與if-then和if-then-else語句不同，switch語句可以有許多可能的執行路徑，switch使用byte、short、char和int原始數據類型，它還適用于枚舉類型（在枚舉類型中討論），String類，以及一些包含某些基本類型的特殊類：Character、Byte、Short和Integer（在Number和String中討論）。

以下代碼示例SwitchDemo聲明了一個名為month的int，其值表示月份，代碼使用switch語句根據month的值顯示月份的名稱。

public class SwitchDemo {
    public static void main(String[] args) {

        int month = 8;
        String monthString;
        switch (month) {
            case 1:  monthString = "January";
                     break;
            case 2:  monthString = "February";
                     break;
            case 3:  monthString = "March";
                     break;
            case 4:  monthString = "April";
                     break;
            case 5:  monthString = "May";
                     break;
            case 6:  monthString = "June";
                     break;
            case 7:  monthString = "July";
                     break;
            case 8:  monthString = "August";
                     break;
            case 9:  monthString = "September";
                     break;
            case 10: monthString = "October";
                     break;
            case 11: monthString = "November";
                     break;
            case 12: monthString = "December";
                     break;
            default: monthString = "Invalid month";
                     break;
        }
        System.out.println(monthString);
    }
}

在這種情況下，August打印到標準輸出。

switch語句的主體稱為switch塊，可以使用一個或多個case或默認標簽來標記switch塊中的語句，switch語句計算其表達式，然后執行匹配的case標簽后面的所有語句。

你還可以使用if-then-else語句顯示月份的名稱：

int month = 8;
if (month == 1) {
    System.out.println("January");
} else if (month == 2) {
    System.out.println("February");
}
...  // and so on

決定是否使用if-then-else語句或switch語句是基于可讀性和語句正在測試的表達式，if-then-else語句可以基于值或條件的范圍來測試表達式，而switch語句僅基于單個整數、枚舉值或String對象來測試表達式。

另一個興趣點是break語句，每個break語句都會終止封閉的switch語句。控制流繼續switch塊后面的第一個語句，break語句是必要的，因為沒有它們，switch塊中的語句就會失敗：匹配的case標簽之后的所有語句都按順序執行，而不管后續case標簽的表達式，直到遇到break語句。程序SwitchDemoFallThrough顯示落入所有switch塊中的語句，該程序顯示與整數月相對應的月份以及該年份中的月份：

public class SwitchDemoFallThrough {

    public static void main(String[] args) {
        java.util.ArrayList futureMonths =
            new java.util.ArrayList();

        int month = 8;

        switch (month) {
            case 1:  futureMonths.add("January");
            case 2:  futureMonths.add("February");
            case 3:  futureMonths.add("March");
            case 4:  futureMonths.add("April");
            case 5:  futureMonths.add("May");
            case 6:  futureMonths.add("June");
            case 7:  futureMonths.add("July");
            case 8:  futureMonths.add("August");
            case 9:  futureMonths.add("September");
            case 10: futureMonths.add("October");
            case 11: futureMonths.add("November");
            case 12: futureMonths.add("December");
                     break;
            default: break;
        }

        if (futureMonths.isEmpty()) {
            System.out.println("Invalid month number");
        } else {
            for (String monthName : futureMonths) {
               System.out.println(monthName);
            }
        }
    }
}

這是代碼的輸出：

August
September
October
November
December

從技術上講，不需要最后的break，因為流從switch語句中退出，建議使用break，以便更容易修改代碼并減少錯誤，默認部分處理其中一個case部分未明確處理的所有值。

以下代碼示例SwitchDemo2顯示了語句如何具有多個case標簽，代碼示例計算特定月份的天數：

class SwitchDemo2 {
    public static void main(String[] args) {

        int month = 2;
        int year = 2000;
        int numDays = 0;

        switch (month) {
            case 1: case 3: case 5:
            case 7: case 8: case 10:
            case 12:
                numDays = 31;
                break;
            case 4: case 6:
            case 9: case 11:
                numDays = 30;
                break;
            case 2:
                if (((year % 4 == 0) && 
                     !(year % 100 == 0))
                     || (year % 400 == 0))
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        System.out.println("Number of Days = "
                           + numDays);
    }
}

這是代碼的輸出：

Number of Days = 29

在Java SE 7及更高版本中，你可以在switch語句的表達式中使用String對象，以下代碼示例StringSwitchDemo根據名為month的String的值顯示月份的編號：

public class StringSwitchDemo {

    public static int getMonthNumber(String month) {

        int monthNumber = 0;

        if (month == null) {
            return monthNumber;
        }

        switch (month.toLowerCase()) {
            case "january":
                monthNumber = 1;
                break;
            case "february":
                monthNumber = 2;
                break;
            case "march":
                monthNumber = 3;
                break;
            case "april":
                monthNumber = 4;
                break;
            case "may":
                monthNumber = 5;
                break;
            case "june":
                monthNumber = 6;
                break;
            case "july":
                monthNumber = 7;
                break;
            case "august":
                monthNumber = 8;
                break;
            case "september":
                monthNumber = 9;
                break;
            case "october":
                monthNumber = 10;
                break;
            case "november":
                monthNumber = 11;
                break;
            case "december":
                monthNumber = 12;
                break;
            default: 
                monthNumber = 0;
                break;
        }

        return monthNumber;
    }

    public static void main(String[] args) {

        String month = "August";

        int returnedMonthNumber =
            StringSwitchDemo.getMonthNumber(month);

        if (returnedMonthNumber == 0) {
            System.out.println("Invalid month");
        } else {
            System.out.println(returnedMonthNumber);
        }
    }
}

此代碼的輸出為8。

將switch表達式中的String與每個case標簽關聯的表達式進行比較，就好像正在使用String.equals方法一樣。為了使StringSwitchDemo示例無論何種情況都接受任何month，month將轉換為小寫（使用toLowerCase方法），并且與case標簽關聯的所有字符串均為小寫。

此示例檢查switch語句中的表達式是否為null，確保任何switch語句中的表達式不為null，以防止拋出NullPointerException。

while語句在特定條件為true時繼續執行語句塊，其語法可表示為：

while (expression) {
     statement(s)
}

while語句計算表達式，該表達式必須返回一個布爾值，如果表達式的計算結果為true，則while語句將執行while塊中的語句，while語句繼續測試表達式并執行其塊，直到表達式求值為false，使用while語句打印1到10之間的值可以在以下WhileDemo程序中完成：

class WhileDemo {
    public static void main(String[] args){
        int count = 1;
        while (count < 11) {
            System.out.println("Count is: " + count);
            count++;
        }
    }
}

你可以使用while語句實現無限循環，如下所示：

while (true){
    // your code goes here
}

Java編程語言還提供了do-while語句，可以表示如下：

do {
     statement(s)
} while (expression);

do-while和while之間的區別在于do-while在循環的底部而不是頂部計算它的表達式，因此，do塊中的語句總是至少執行一次，如下面的DoWhileDemo程序所示：

class DoWhileDemo {
    public static void main(String[] args){
        int count = 1;
        do {
            System.out.println("Count is: " + count);
            count++;
        } while (count < 11);
    }
}

for語句提供了一種迭代一系列值的簡潔方法，程序員經常將其稱為“for循環”，因為它反復循環直到滿足特定條件，for語句的一般形式可表示如下：

for (initialization; termination; increment) {
    statement(s)
}

使用此版本的for語句時，請記住：

initialization表達式初始化循環，循環開始時，它執行一次。

當termination表達式的計算結果為false時，循環終止。

每次迭代循環后都會調用increment表達式，這個表達式增加或減少一個值是完全可以接受的。

以下程序ForDemo使用for語句的一般形式將數字1到10打印到標準輸出：

class ForDemo {
    public static void main(String[] args){
         for(int i=1; i<11; i++){
              System.out.println("Count is: " + i);
         }
    }
}

該程序的輸出是：

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10

注意代碼如何在初始化表達式中聲明變量，此變量的范圍從其聲明擴展到由for語句控制的塊的末尾，因此它也可以用在終止和增量表達式中。如果在循環外部不需要控制for語句的變量，則最好在初始化表達式中聲明該變量。名稱i，j和k通常用于控制循環，在初始化表達式中聲明它們會限制它們的生命周期并減少錯誤。

for循環的三個表達式是可選的，可以創建一個無限循環，如下所示：

// infinite loop
for ( ; ; ) {
    
    // your code goes here
}

for語句還有另一種用于迭代集合和數組的形式，此形式有時也稱為增強的for語句，可用于使循環更緊湊，更易于閱讀，要演示，請考慮以下數組，其中包含數字1到10：：

int[] numbers = {1,2,3,4,5,6,7,8,9,10};

以下程序EnhancedForDemo使用增強型for循環遍歷數組：

class EnhancedForDemo {
    public static void main(String[] args){
         int[] numbers = 
             {1,2,3,4,5,6,7,8,9,10};
         for (int item : numbers) {
             System.out.println("Count is: " + item);
         }
    }
}

在此示例中，變量item保存數字數組中的當前值，該程序的輸出與之前相同：

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10

我們建議盡可能使用for語句的這種形式而不是一般形式。

break語句有兩種形式：標記和未標記，你在前面的switch語句討論中看到了未標記的形式，你還可以使用未標記的break來終止for、while或do-while循環，如以下BreakDemo程序所示：

class BreakDemo {
    public static void main(String[] args) {

        int[] arrayOfInts = 
            { 32, 87, 3, 589,
              12, 1076, 2000,
              8, 622, 127 };
        int searchfor = 12;

        int i;
        boolean foundIt = false;

        for (i = 0; i < arrayOfInts.length; i++) {
            if (arrayOfInts[i] == searchfor) {
                foundIt = true;
                break;
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at index " + i);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}

該程序在數組中搜索數字12，break語句在找到該值時終止for循環，然后，控制流轉移到for循環后的語句，該程序的輸出是：

Found 12 at index 4

未標記的break語句終止最內層的switch、for、while或do-while語句，但帶標簽的break終止外部語句。以下程序BreakWithLabelDemo與前一個程序類似，但使用嵌套for循環來搜索二維數組中的值，找到該值后，帶標簽的break將終止外部for循環（標記為“search”）：

class BreakWithLabelDemo {
    public static void main(String[] args) {

        int[][] arrayOfInts = { 
            { 32, 87, 3, 589 },
            { 12, 1076, 2000, 8 },
            { 622, 127, 77, 955 }
        };
        int searchfor = 12;

        int i;
        int j = 0;
        boolean foundIt = false;

    search:
        for (i = 0; i < arrayOfInts.length; i++) {
            for (j = 0; j < arrayOfInts[i].length;
                 j++) {
                if (arrayOfInts[i][j] == searchfor) {
                    foundIt = true;
                    break search;
                }
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at " + i + ", " + j);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}

這是該程序的輸出。

Found 12 at 1, 0

break語句終止帶標簽的語句，它不會將控制流轉移到標簽上，控制流在標記（終止）語句之后立即轉移到語句。

continue語句跳過for、while或do-while循環的當前迭代，未標記的形式跳到最內層循環體的末尾，并計算控制循環的布爾表達式。以下程序ContinueDemo逐步執行字符串，計算字母“p”的出現次數，如果當前字符不是p，則continue語句將跳過循環的其余部分并繼續執行下一個字符，如果是“p”，程序會增加字母數。

class ContinueDemo {
    public static void main(String[] args) {

        String searchMe = "peter piper picked a " + "peck of pickled peppers";
        int max = searchMe.length();
        int numPs = 0;

        for (int i = 0; i < max; i++) {
            // interested only in p"s
            if (searchMe.charAt(i) != "p")
                continue;

            // process p"s
            numPs++;
        }
        System.out.println("Found " + numPs + " p"s in the string.");
    }
}

這是該程序的輸出：

Found 9 p"s in the string.

要更清楚地看到此效果，請嘗試刪除continue語句并重新編譯，當你再次運行程序時，計數將是錯誤的，說它找到35個p而不是9個。

標記的continue語句跳過標記有給定標簽的外循環的當前迭代，以下示例程序ContinueWithLabelDemo使用嵌套循環來搜索另一個字符串中的子字符串，需要兩個嵌套循環：一個遍歷子字符串，一個迭代搜索的字符串，以下程序ContinueWithLabelDemo使用標記形式的continue來跳過外部循環中的迭代。

class ContinueWithLabelDemo {
    public static void main(String[] args) {

        String searchMe = "Look for a substring in me";
        String substring = "sub";
        boolean foundIt = false;

        int max = searchMe.length() - 
                  substring.length();

    test:
        for (int i = 0; i <= max; i++) {
            int n = substring.length();
            int j = i;
            int k = 0;
            while (n-- != 0) {
                if (searchMe.charAt(j++) != substring.charAt(k++)) {
                    continue test;
                }
            }
            foundIt = true;
                break test;
        }
        System.out.println(foundIt ? "Found it" : "Didn"t find it");
    }
}

這是該程序的輸出。

Found it

最后一個分支語句是return語句，return語句從當前方法退出，控制流返回到調用方法的位置，return語句有兩種形式：一種是返回值，另一種是不返回值，要返回值，只需將值（或計算值的表達式）放在return關鍵字之后。

return ++count;

返回值的數據類型必須與方法聲明的返回值的類型匹配，當方法聲明為void時，請使用不返回值的return形式。

return;

類和對象課程將涵蓋你需要了解的有關編寫方法的所有內容。

if-then語句是所有控制流語句中最基本的語句，它告訴程序只有在特定測試評估為true時才執行某段代碼。if-then-else語句在“if”子句求值為false時提供輔助執行路徑，與if-then和if-then-else不同，switch語句允許任意數量的可能執行路徑。while和do-while語句在特定條件為true時不斷執行語句塊，do-while和while之間的區別在于do-while在循環的底部而不是頂部計算它的表達式，因此，do塊中的語句總是至少執行一次。for語句提供了一種迭代一系列值的簡潔方法，它有兩種形式，其中一種用于循環集合和數組。