第4章 程序設計中的流程控制

任何一門語言都需要基本的流程控制語句，其思想也符合人類判斷問題或做事的邏輯過程。什么是流程控制呢？流程就是做一件事情的順序，或者說是次序。在程序設計中，流程就是要完成一個功能，而流程控制則是指如何在程序設計中控制完成某種功能的次序。本章將通過大量的實例，為讀者講解如何在程序中設計好流程控制。

本章重點：

□ Java語言的編程風格。

□ 條件語句、分支語句和循環語句。

□ 中斷、繼續、返回語句。

4.1 編程風格

本章開始接觸到編寫Java程序代碼，有一點必須強調，那就是編程風格的問題，雖然其不影響程序代碼段的運行，但對于程序的可讀性起著重要的作用。自己編出的程序要讓別人看懂，首先在排版方面要非常注意，下面將探討編程風格的問題。

其實每個人、每個軟件開發公司的編程風格都不一樣。一個人編寫的程序代碼就應該能讓別人看懂，甚至是過了很長時間，自己也要看得懂，否則這個程序就成了一個沒法擴展的程序。編程風格是指編程時的格式，讓程序看上去就很有層次感。下面通過一些例子說明編程風格的重要性。

【實例4-1】先來看第一個例子。

01  public class math
02  {
03      public static void main(String[] args)
04      {
05          int  x=12;
06          double y=12.3d;                              //定義double類型
07          void print()                                //關于打印方法
08          {
09              char a='a';
10              System.out.println(a);
11          }
12          System.out.println(x+y);                    //關于輸出方法
13      }
14  }

【代碼說明】上面程序段的整個排版看起來是否很舒服，并且層次感很強？是否一眼看上去就知道整個程序架構？這里的關鍵在于縮排，縮排也稱為跳格。

上面程序段采用的是跳格形式：“public class math”是頂格的，接著主運行程序前跳4個空格，在主運行程序內的運行代碼段一律跳8個空格，而在主運行程序方法內的代碼前，再跳4個空格。這樣整個程序的所屬關系就很明顯了。主運行程序從屬于math類，其余的都屬于主運行程序，而在主運行程序方法內的代碼段又屬于此方法。規律就是空格多的代碼從屬于空格少的代碼。

【實例4-2】除了空格外，空行也是必要的。為什么要空行呢？先看下面的程序代碼，再來仔細分析。

01  public class math {
02       public static void main(String[] args)
03       {
04          int x=12;
05          int y=23;
06          void print()                              //打印方法
07          {
08              …
09          }
10
11          void view()                               //顯示方法
12          {
13              …
14          }
15      }
16  }

【代碼說明】在print方法與view方法之間有個空行（第10行），使用空行區分不同功能的模塊。print方法所完成的功能與view所完成的功能不一樣，所以使用空行將它們分開，這樣更增加了程序的可讀性。

另外，需要注意的是方法或屬性的命名。這些名字應該有含義，最好有規律。不要只使用“a”、“b”這種通用變量，可以適當根據變量或函數的功能為其命名。上面的“print”，其他程序員一看就知道這個方法是有關打印或輸出的函數。再如變量名“name”，一看就知道是有關名字的變量。所以命名要有意義，否則程序的可讀性不強。

還有一點是有關注釋的。在每個方法的方法名旁邊，應該添加一些注釋，同時在一段程序完成之后，也要對程序的功能及如何操作做簡單的描述。

只要做到以上幾點，這個程序就是易讀的。即使經過很長時間后再來讀程序也會一目了然。

4.2 條件語句

在現實生活中，經常聽人說：如果某人發財了，某人就會做什么。其實這就是程序設計中所說的條件語句。例如“如果……就……”、“否則……”，當然這只是很簡單的條件語句，在真正的程序設計中，使用的條件語句要比這復雜得多。

4.2.1 簡單條件語句

在程序設計中，條件語句的標準格式如下：

if(條件)
{
   目的一;
}
else
{
  目的二;
}

【實例4-3】掌握格式后，先看一個簡單的程序段。

01  public class control {
02       public static void main(String[] args) {
03            int a = 20;
04            int b = 30;
05            if (a > b) {     //將整型變量a,b的大小比較得出的布爾型變量作為條件語句的條件
06                 System.out.println("很幸運！");
07            } else {
08                 System.out.println("很開心");
09            }
10       }
11  }

【代碼說明】因為“a=20”而“b=30”，所以“a<b”。在條件語句中，程序代碼的意思是，如果“a>b”，就輸出“很幸運！”，如果“a<b”，就輸出“很開心”，所以程序的輸出結果就是“很開心！”。

【運行效果】

很開心！

4.2.2 最簡單的條件語句

在條件語句的程序設計中，有一種最簡單的條件語句，如下所示：

if(條件)
 目的;

如果有很多的目的，也可以采取下面的形式：

if(條件)
{
    目的一;
    目的二;
    目的三;
    目的四;
}

【實例4-4】下面看一個有關這種類型條件語句的例子。

01  public class control1
02  {
03      public static void main(String[] args)
04      {
05          int salary=10000;                             //變量初始化
06          if (salary>500)                               //條件判斷
07          {
08              System.out.println("想請吃飯！");
09              System.out.println("想請唱歌！");
10              System.out.println("想請喝酒！");
11          }
12
13      }
14  }

【代碼說明】條件語句中判斷“salary>500”是否為真，如果是真就輸出“想請吃飯！想請唱歌！想請喝酒！”，如果是假，就什么都不做。在程序中“salary=10000”，滿足“salary>500”，條件為真，所以輸出以上三句話。

【運行效果】

想請吃飯！
想請唱歌！
想請喝酒！

4.2.3 適應多條件的條件語句

如果出現多種不同的條件，應該如何處理呢？可以使用條件語句中的復雜型，其結構如下：

if (條件1)
{
    目的1;
}
else if (條件2)
{
    目的2;
}
else if (條件3)
{
    目的4;
}
else
{
    不滿足以上所有條件，如何辦;
}

【實例4-5】根據以上結構，學習有關這種復雜條件語句的實例，代碼如下所示：

01  public class control2 {
02       public static void main(String[] args) {
03            int achievement = 85;
04            //當achievement等于100，就獎勵一臺筆記本電腦
05             if (achievement == 100) {
06                 System.out.println("獎勵一臺筆記本電腦");
07            } else if ((achievement >= 90) && (achievement < 100)) {
08                 //當achievement大于90小于100，就獎勵一個MP4
09                 System.out.println("獎勵一個MP4");
10            } else if ((achievement >= 80) && (achievement < 90)) {
11                 //當achievement大于80小于90，就獎勵一塊網卡
12                 System.out.println("獎勵一塊網卡");
13            } else if ((achievement >= 60) && (achievement < 80)) {
14                 //當achievement大于60小于80，不給予獎勵
15                 System.out.println("不給予任何獎勵");
16            } else {
17                 //當achievement小于60，放假回學校補習
18                 System.out.println("放假回學校補習");
19            }
20       }
21  }

【代碼說明】從上述代碼可以看出，當有多個不同的條件存在時，處理的結果就不一樣。成績在大于80分小于90分之內，就可以獎勵一塊網卡；而成績大于90分小于100分，則獎勵一個MP4。在此程序中，初始成績是85分，所以處理的結果就是獎勵一塊網卡。

【運行效果】

獎勵一塊網卡

條件語句已經基本介紹完畢，很重要的一點就是，在程序設計的時候，思路一定要清晰，如何才能有很清晰的思路呢？那就是繪制流程圖。流程圖就是：在程序開發前，為了能夠使思路更加清晰，而將整個程序執行的順序流程繪制出來。圖4-1為一個有關條件語句的通用流程圖。

將上面的程序段作為一個實例，繪制其基本的流程圖，如圖4-2所示。鑒于頁面的版面，這里只給出了4種條件，并沒有完全體現出上面案例的5種條件，讀者可自己畫一個完整的流程圖。

針對最復雜的條件語句，在程序設計中，有一種分支語句可以代替復雜條件語句。在實際程序開發過程中，使用條件語句類型比較多的是標準型，而復雜型的一般用分支語句來代替。當然也可以使用復雜型的條件語句。為了與實戰結合，下面以一個稍微復雜的程序段為例。

【實例4-6】條件：設計一個程序，用于計算語文（90）、英語（75）、數學（90）、藝術（85）四門功課的平均分，并對此學生進行評價。

在編寫程序之前要先繪制流程圖，這樣編程的思路就會非常清晰，本例流程圖如圖4-3所示。

根據以上的流程圖編寫程序，程序代碼段如下：

01  public class control3 {
02       public static void main(String[] args) {
03            //創建成員變量
04            int Chinese = 90;
05            int English = 75;
06            int Math = 90;
07            int Art = 85;
08            //獲取平均值
09             double Avg = (Chinese + English + Math + Art) / 4;
10             if ((Avg > 90) && (Avg <= 100)) {
11                 //如果是大于90小于等于100則是優秀
12                 System.out.println("這個學生的所有功課的平均分是：" + Avg);
13                 System.out.println("這個學生的成績應得A，是優秀");
14            } else if ((Avg > 80) && (Avg <= 90)) {
15                 //如果是大于80小于等于90則是良好
16                 System.out.println("這個學生的所有功課的平均分是：" + Avg);
17                 System.out.println("這個學生的成績應得B，是良好");
18            } else if ((Avg > 70) && (Avg <= 80)) {
19                 //如果是大于70小于等于80則是良
20                 System.out.println("這個學生的所有功課的平均分是：" + Avg);
21                 System.out.println("這個學生的成績應得C，是良");
22            } else if ((Avg > 60) && (Avg <= 70)) {
23                 //如果是大于60小于等于70則是合格
24                 System.out.println("這個學生的所有功課的平均分是：" + Avg);
25                 System.out.println("這個學生的成績應得D，是合格");
26            } else {
27                 //如果小于60則是不合格
28                 System.out.println("這個學生的所有功課的平均分是：" + Avg);
29                 System.out.println("這個學生的成績應得E，是不合格");
30            }
31       }
32  }

【代碼說明】第10～32行是復雜型的條件語句，判斷了5種情況下不同的輸出結果。第9行定義的是double變量，表示計算后的平均值。

【運行效果】

這個學生的所有功課的平均分是：85.0
這個學生的成績應得B,是良好

4.2.4 嵌套條件語句

if嵌套語句也是經常使用的多分支判斷語句，在一次判斷之后又有新一層的判斷，接著又有一層判斷，逐漸深入，達到實現復雜判斷的目的，這種多層次判斷相當于多條件判斷，在滿足幾個條件后再執行適當的語句。if嵌套語句的格式是：

if(條件1)
 if(條件2)
    if(條件3)
          執行語句1;

在if(條件1)成立的情況下繼續判斷直到if(條件3)也成立，再執行語句1。如果其中有一個條件不滿足，則跳出該if嵌套語句，繼續執行嵌套語句之外的代碼。

4.2.5 如何使用條件語句

使用條件語句需要注意以下幾點。

1）應該繪制流程圖，使編程時的思路更加清晰。

2）編程時，在最簡單形式的條件語句中，可以不使用大括號，因為它不會產生混淆。但建議無論是哪種形式的條件語句，都應該使用大括號。

4.3 循環語句

循環語句在程序設計中有什么作用呢？本節將通過一個具體功能（計算數字1連加10次1后的結果）來演示。

【實例4-7】下面先看一段簡單的程序段，再來看看使用循環語句編寫程序的好處在哪里。

01  ///將x連續加1加10次
02  public class control4
03  {
04      public static void main(String[] args)
05      {  //連續自加10次
06         int x=1;                             //x初始化為1
07         x=x+1; 
08         x=x+1; 
09         x=x+1; 
10         x=x+1; 
11         x=x+1; 
12         x=x+1; 
13         x=x+1; 
14         x=x+1; 
15         x=x+1; 
16         x=x+1; 
17         System.out.println(x);               //l輸出x最終的結果
18      }
19  }

【代碼說明】代碼的含義是讓變量“x”連續加1共加10次。如果想要實現加1加100次，那要讓“x=x+1”這個表達式重復100次。

【運行效果】

11

這樣龐大的程序段所要完成的功能，不過是一個很簡單的相加功能。為了解決這類問題，程序設計中引入了循環語句。循環語句共有3種常見的形式：for語句、while語句和do…while語句。下面將逐個詳細介紹。

4.3.1 for循環語句

讓初始值為1的變量“x”連續加1共加10次，可以直接編寫10次“x=x+1;”語句，但是如果要加100呢？這時肯定不能編寫100次“x=x+1;”語句。為了解決該問題，可以使用for循環語句。

for循環語句的基本結構如下：

for(初始化表達式；判斷表達式；遞增（遞減）表達式)
{
    執行語句
}

下面詳細解釋for循環語句中各個子項的意義。

1）初始化表達式：初始化表達式的意義在于定義循環之前變量的值是多少，如果沒有這一項，就不知道應該從哪個值開始循環。

2）判斷表達式：判斷表達式的作用在于規定循環的終點。如果沒有判斷表達式，那么此循環就成了死循環。

3）遞增（遞減）表達式：這一項規定每執行一次程序，變量以多少增量或減量進行變化。

【實例4-8】使用for語句，來修改上一小節的程序段。

01  public class control5
02  {
03      public static void main(String[] args)
04      {
05          int x;
06          int n=10;                                 //定義了循環的次數
07          for( x=1;n>0;n--,x++)                     //通過循環實現連續加1共10次
08          {System.out.println(x);}
09      }
10  }

【代碼說明】上述代碼中，第5～8行共4句代碼完成了前面程序段里12句代碼所實現的事情。

【運行效果】

1
2
3
4
5
6
7
8
9
10

【實例4-9】如果前面的程序段需要連續加1加100次，則參考下面的程序段。

01  public class control6
02  {
03      public static void main(String[] args)
04      {
05          int x;
06          int n=100;                                    //定義了循環的次數
07          for(x=1;n>0;n--,x++)                         //實現循環
08          System.out.println(x);
09      }
10  }

【代碼說明】在這個程序段里，使用第5～8行共4句代碼可以解決程序段中102句代碼所實現的問題，這就是循環語句的優勢。

【運行效果】

1
2
3
…
100

其實也可以利用在條件判斷語句中提到的流程圖來編寫程序，在流程圖中可以看出程序執行的順序，如圖4-4所示。

【實例4-10】下面再看一個九九乘法表的程序段。先來繪制流程圖，如圖4-5所示。

根據流程圖，使用循環語句實現乘法口訣表。

01  ///這是一個二重for循環語句
02  public class control7
03  {
04      public static void main(String[] args)
05      {
06          for(int x=2;x<10;x++)                        //輸出8行
07          {
08              for(int y=1;y<10;y++)                    //輸出9列
09              {
10                  System.out.print(x+"＊"+y+"="+(x＊y));
11                  System.out.print("");
12              }
13             System.out.println("");
14          }
15       }
16  }

【代碼說明】第6～14行是外圍的for循環，第8～12行是一個嵌入在外圍循環中的循環，這樣的形式我們稱之為嵌套循環。為什么要使用二重循環呢？因為它涉及兩個變化的量。在一個程序里，有多少個不同的變量，就要使用多少個for循環，當然也不是非常絕對的。

【運行效果】

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

在上面的程序段中，使用了2層嵌套的for語句。其實真正復雜的程序段中，可能會出現4層嵌套的for語句，這要在實踐中慢慢體會。

通過上面的內容，可以發現循環流程關鍵字for的語法比較復雜。為了改變該現象，便出現了關于for循環的另一種語法（增強版for循環），該方式可以簡化for循環的書寫。

增強版for循環的基本格式如下：

for(type 變量名：集合變量名){
}

在上述基本格式中，迭代變量必須在方法體中定義，集合變量除了可以是數組，還可以是實現了Iterable接口的集合類。

下面將通過修改VariableArgument.java類來演示增強版的for，具體內容如下所示：

01  public class VariableArgument {
02       public static int add(int... xs) {
03            int sum = 0;
04            for (int x : xs) {                    //增強版for循環
05                 sum = sum + x;
06            }
07            return sum;                           //返回變量sum
08       }
09  }

【代碼說明】上述代碼中通過for(int x : xs)語句代替了for (int x = 0; x < xs.length; x++)語句，實現了相應的循序迭代功能，即運行VariableArgumentTest.java類，會顯示出正確的信息。

4.3.2 while循環

在英文中“while”這個詞的意思是“當”，而在Java程序設計中，也可以將其理解為“當”。其語法結構如下。

while (條件)
{
    目的一;
    目的二;
    …
}

當滿足某種條件，就執行“目的一”、“目的二”等，while語句的循環體在{}中。

【實例4-11】下面看一段程序段，通過分析它，讓讀者更加清楚while循環語句。

01  //通過判斷y是否大于0
02  //如果y大于0的話則將計費次數減1，x加1
03  public class control8
04  {
05       public static void main(String[] args) {
06            int x=0;
07            int y=100;
08            int sum=0;
09            while(y>0)                           //while循環
10            {
11                 x=x+1;
12                 y--;                            //值自減
13                 sum+=x;
14            }
15            System.out.println(sum);             //輸出和
16       }
17  }

【代碼說明】這個程序段是將數字從1一直加到100，條件是只要y大于0，就會執行大括號里的語句。y初始值是100，滿足條件，所以執行大括號的表達式。先將x+1賦給x，因為x的初始值是0，所以x從1開始計數，然后，將y自減1，此時y變成了99，將sum加上x賦給sum。此時，執行語句結束了，又會回到小括號的條件，最后再比較y=99是否大于0，如果大于0，再繼續執行大括號里的語句。

一旦y自減到小于等于0，則將結束執行大括號里的語句，開始執行大括號外的語句。在上面的程序段中，y就相當于一個計數器。

【運行效果】

5050

同樣，在編寫while語句時，要先繪制流程圖，根據流程圖再來編寫程序段，整個思路就會很清晰了。下面先看while的流程圖，如圖4-6所示。

其實while語句很簡單，根據這個流程圖，就可以思路清晰地編寫程序段。下面針對上面的程序段來繪制流程圖，如圖4-7所示。

看了這個流程圖，會發現按照流程圖來編寫程序簡單多了。為了鞏固以上所述，再看一個例子。

【實例4-12】試編寫程序實現輸出1～100間的整數，并且此整數必須滿足：它是3的倍數，但不是5的倍數，也不是9的倍數。針對這個例子，先來繪制一個流程圖，如圖4-8所示。

根據流程圖，現在來編寫程序段。

01  public class control9 {
02       public static void main(String[] args) {
03            int x = 1;
04            //判斷是否在100以內，并且是3的倍數
05             while (((3 * x > 1) && (3 * x < 100))) {
06                 if ((3 * x) % 5 != 0) {             //然后再判斷這些數是否不是5的倍數
07                      if ((3 * x) % 9 != 0) {        //最后判斷這些數是否不是9的倍數
08                            System.out.println(3 ＊ x);
09                      }
10                 }
11                 x++;
12            }
13       }

14 }

【代碼說明】第5行是一個循環判斷條件，判斷是否在100以內，并且是3的倍數。第6行是一個條件語句，判斷這些數是否不是5的倍數。第7行也是一個條件語句，判斷這些數是否不是9的倍數。

【運行效果】

3
6
12
21
24
33
39
42
48
51
57
66
69
78
84
87
93
96

按照先繪制流程圖，后編寫程序的步驟，會顯得思路更清晰。其實從上面的程序段中，可以總結一點：當由多個條件形成循環條件時，可以選擇其中一個作為循環條件，而剩下的條件可以在循環體中作為條件語句。

4.3.3 do…while語句

在學習do…while語句之前，先清楚while語句是如何工作的。while語句是先進行條件判斷，再執行大括號內的循環體。do…while語句與while語句不同的是，它先執行大括號內的循環體，再判斷條件，如果條件不滿足，下次不再執行循環體。也就是說，在判斷條件之前，就已經執行大括號內的循環體。

do…while循環語句格式為：

 do
     執行代碼;
 while(布爾表達式)

【實例4-13】下面先看一個程序段。

01  public class control10 {
02       public static void main(String[] args) {
03            int x = 1;
04            do {
05                 //首先判斷這個數是否是3的倍數，并且是否不是5的倍數
06                  if ((3 * x) % 5 != 0) {
07                      if ((3 * x) % 9 != 0) {            //再判斷是否不是9的倍數
08                            System.out.println(3 ＊ x);
09                      }
10                 }
11                 x++;
12            } while (((3 * x > 1) && (3 * x < 100)));  //最后判斷是否在100以內
13       }
14  }

【運行效果】

3
6
12
21
24
33
39
42
48
51
57
66
69
78
84
87
93
96

【代碼說明】從上面的程序段輸出結果可以看出，與使用while語句的輸出結果是一樣的，為什么會是一樣的呢？下面來分析。

當“x=33”時，先不會檢驗“3*33=99”是否小于100，而是先執行大括號內的循環體。當檢測到99是9的倍數時，條件是“false”，于是就會退出條件語句，繼續執行“x”自加1表達式，于是“x”變成了34，由于“34*3=102”大于100，所以結束循環體。因此程序執行到“x=32”后就無輸出了，最后輸出的結果當然和while語句的輸出一樣。

其實在實際程序開發中，不經常使用do…while循環語句。因為這種語句是先執行循環體再檢測條件，所以會有一些危險數據不經檢測，就會被執行。建議使用while語句或者for循環語句來編寫代碼。

4.4 中斷與繼續語句

在實際編程中，可能會出現中斷某個程序；或從一個程序點開始，繼續執行程序的特殊情況。對于這些特殊情況，Java會使用中斷與繼續功能來解決。

4.4.1 中斷控制語句

在Java程序開發中，使用關鍵字break來表示中斷控制。中斷控制語句用來強行退出程序的循環體部分或分支語句（如switch語句）。在switch分支語句中，已經使用過break語句，一旦執行該跳轉語句，程序就退出switch語句。

【實例4-14】為了能熟悉中斷控制語句，下面看一個簡單的程序段，通過這個例子，可以看到中斷控制語句在實際開發中的用處。

01  //通過system.out語句可以將數據打印出來
02  public class control11
03  {
04      public static void main(String[] args)
05      {
06          int i=1;
07          while(i<=10)                         //循環
08          {
09              System.out.println(i);
10              i++;                             //值自加
11              if(i>5)
12              {break;}                         //退出
13          }
14      }
15  }

【代碼說明】第11行添加了一個條件語句，當變量i大于5時，使用break語句退出while循環體。

【運行效果】

1
2
3
4
5

【實例4-15】如果上述代碼中，沒有中斷語句強行退出，則代碼如下所示：

01  //如果沒有中斷語句，則會循環到最后
02  public class control12
03  {
04      public static void main(String[] args)
05      {
06          int i=1;
07          while(i<=10)                             //循環
08          {
09              System.out.println(i);               //輸出值
10              i++;
11          }
12       }
13  }

【代碼說明】第7～11行是while循環體，這里沒有使用中斷語句，所以符合條件的變量i值全部輸出。

【運行效果】

1
2
3
4
5
6
7
8
9
10

從上面兩個實例的程序段運行結果可以看出：當使用了break語句后，程序執行到“x=6”時，根據條件判斷“x>5”，執行中斷語句，直接退出程序的循環體部分。

【實例4-16】下面再看一個有關中斷語句的例子。

01  //將system.out語句放置在中斷語句之前，則會循環一次，再退出循環
02  public class control13
03  {
04      public static void main(String[] args)
05      {
06          for(int i=2;i<10;i++)
07          {
08              System.out.println(i);                        //輸出語句
09              if(i%2==0)
10              {break;}                                      //退出
11          }
12          System.out.println("退出來了");                    //輸出提示
13      }
14  }

【代碼說明】第9～10行是條件語句和中斷語句的集合，在符合條件的時候，退出for循環體。當“i”是偶數的時候，直接中斷循環體。由于第8行的輸出方法屬于循環體中的方法，所以不會執行它。

【運行效果】

2
退出來了

【實例4-17】將輸出方法的位置進行調整，再看下面的代碼。

01  //將system.out語句的位置放置在中斷語句之后，則直接退出循環
02  public class control14
03  {
04      public static void main(String[] args)
05      {
06          for(int i=2;i<10;i++)                        //for循環
07          {
08              if(i%2==0)
09              {break;}                                 //退出
10              System.out.println(i);                   //輸出值
11          }
12          System.out.println("退出來了");               //輸出提示
13      }
14  }

【代碼說明】與前面的程序段一樣，代碼會直接跳出循環體程序，第12行的輸出方法在循環體外，所以得以執行。

【運行效果】

退出來了

通過上述幾個實例，可以總結出中斷語句的使用方法：一般和條件判斷語句結合使用，中斷語句是中斷整個循環體。跳出循環體后，直接執行循環體以外的語句。

4.4.2 繼續語句

在Java程序設計中，繼續語句使用關鍵字continue表示。當執行continue語句時，程序從循環體的開始處執行，而不考慮循環體中已經執行了多少輪循環，在for循環語句中，執行到continue語句時，不再執行循環體中其他代碼，而是直接跳轉到增量表達式，再開始下一輪的for循環。在while和do…while語句中，運行到continue語句時則跳轉到相應的條件表達式，再開始下一輪的循環。

【實例4-18】下面先看一個有關繼續語句的實例。

01  //只在奇數時，才輸出，偶數時，會退出本次循環
02  public class control15
03  {
04      public static void main(String[] args)
05      {
06          for(int i=1;i<10;i++)                        //for循環
07          {
08              if(i%2==0)
09              {continue;}                              //繼續語句
10              System.out.println(i);                   //輸出值
11          }
12          System.out.println("退出來了");               //輸出提示
13      }
14  }

【代碼說明】仔細分析以上的程序段，如果使用break語句，那么運行結果中只有一個“1”，而用了繼續語句，則輸出了10以內的奇數。在程序中，如果i是偶數，遇到繼續語句，就終止“System.out.println(i)”這條語句，又跳到循環開始，重新循環。所以，只要遇到偶數就會終止程序，遇到奇數程序就會繼續運行。

【運行效果】

1
3
5
7
9
退出來了

4.5 分支語句

在講述條件判斷語句時，曾經提到當判斷條件過多時，可以使用分支語句來編寫。之所以使用分支語句而不是if/else條件語句，是因為當需要判斷的條件過多時，后者實現時會顯得很煩瑣，為了解決該問題，可以利用分支語句。

分支語句的基本結構是：

switch(整數因子)
{
    case 整數值1：語句；break;
    case 整數值2：語句；break;
    case 整數值3：語句；break;
    case 整數值4：語句；break;
    case 整數值5：語句；break;
    …
        default:語句；
}

同樣，先看看分支語句的流程圖，如圖4-9所示。

如果仍然使用條件判斷語句，整個程序段會顯得層次過多，程序顯得過于復雜，不易閱讀。

【實例4-19】下面通過實際程序段，來了解條件判斷語句和分支語句的區別。

01  public class control16
02  {
03      public static void main(String[] args)
04      {
05          int i=8;                                   //定義變量i
06          if(i==1)                                   //當變量i為1時
07          {System.out.println("是一月份");}
08           if(i==2)                                  //當變量i為2時
09          {System.out.println("是二月份");}
10           if(i==3)                                  //當變量i為3時
11          {System.out.println("是三月份");}
12           if(i==4)                                  //當變量i為4時
13          {System.out.println("是四月份");}
14           if(i==5)                                  //當變量i為5時
15          {System.out.println("是五月份");}
16           if(i==6)                                  //當變量i為6時
17          {System.out.println("是六月份");}
18           if(i==7)                                  //當變量i為7時
19          {System.out.println("是七月份");}
20           if(i==8)                                  //當變量i為8時
21          {System.out.println("是八月份");}
22           if(i==9)                                  //當變量i為9時
23          {System.out.println("是九月份");}
24           if(i==10)                                 //當變量i為10時
25          {System.out.println("是十月份");}
26           if(i==11)                                 //當變量i為11時
27          {System.out.println("是十一月份");}
28           if(i==12)                                 //當變量i為12時
29          {System.out.println("是十二月份");}
30      }
31  }

【代碼說明】第6～29行是12個if條件語句。這是判斷月份，如果要判斷的條件更多，是不是需要寫更多的if語句呢？這說明判斷條件非常多時，使用if語句顯得層次有些混亂。

【運行效果】

是八月份

這個程序段看著不是很舒服，并且有點雜亂，下面再看看使用分支語句編寫的程序段是什么樣子。先來繪制一下流程圖，如圖4-10所示。

【實例4-20】為了便于瀏覽，圖4-10只繪制了1～6月份的流程。下面是這個程序的具體代碼。

01  public class control17
02  {
03      public static void main(String[] args)
04      {
05          int i=8;
06          switch(i)                                      //選擇語句
07          {
08              case 1:   System.out.println("是一月份");break;    //退出語句
09              case 2:   System.out.println("是二月份");break;
10              case 3:   System.out.println("是三月份");break;
11              case 4:   System.out.println("是四月份");break; 
12              case 5:   System.out.println("是五月份");break; 
13              case 6:   System.out.println("是六月份");break; 
14              case 7:   System.out.println("是七月份");break; 
15              case 8:   System.out.println("是八月份");break;
16              case 9:   System.out.println("是九月份");break;
17              case 10:  System.out.println("是十月份");break;
18              case 11:  System.out.println("是十一月份");break;
19              case 12:  System.out.println("是十二月份");break;
20              default:  System.out.println("fault");               //默認語句
21          }
22      }
23  }

【代碼說明】第6～21行是完整的分支語句，每個條件通過case來設置，條件執行完后，通過break語句來中斷。第20行的default表示上述條件都不滿足時，則執行它設置的輸出。

【運行效果】

是八月份

4.6 返回語句

返回語句就是在執行程序的過程中，跳轉到另一個程序。一般返回語句用在子程序或程序的函數方法中。返回語句使用關鍵字return來表示。下面通過一個簡單的實例，了解返回語句的用法。

01  public void set(int a,int b)
02  {
03       i=a＊b
04       return;                        //返回語句
05  }

以上是一個小程序段，在程序中出現了return關鍵字，說明這個程序段結束了，返回到主運行程序中。還有一種情況，先看看下面的例子。

01  public int set()
02  {
03      return i=a*b                    //返回值
04  }

這種情況不但要返回到主運行程序，而且還要將“i=a*b”的值帶回主運行程序中，將其值賦給主運行程序中的“i”。返回語句牽扯到不同方法之間的調用問題，我們會在講解了類的方法之后再詳細了解其應用環境。

4.7 常見疑難解答

4.7.1 普通循環是使用for語句還是while語句

根據情況不同而定，for循環語句主要針對有限循環而言，也就是說，當循環有上限的時候，一般使用for循環。while循環語句則針對那些無限循環的代碼而言，當循環沒有明確上限，上限只是根據程序中的條件而定。

4.7.2 一般的程序可否用分支語句來代替條件語句

這個要視具體情況而定，如果條件在三重之內，最好使用條件語句。如果超過了三重，最好使用分支語句。

4.8 小結

本章講解的是Java程序設計中的流程控制，這是每種開發語言的基礎，如果你學習過C語言，則本章內容并不復雜。流程控制主要通過條件判斷、循環、中斷、執行等一系列語句來完成，每個語句實現的功能不同，或者說技巧也不同。建議讀者對本章中的每個例子都能親自動手實現，如果出現了問題，還要多注意如何解決問題，這樣就能知道更多的知識和技巧。

4.9 習題

一、填空題

1.循環語句總共有3種常見的形式：3.輸入一個正整數，輸出該數的階乘。__________、__________和__________。

2.在Java程序開發中，使用關鍵字__________來表示中斷控制。

3.__________就是在執行程序的過程中，跳轉到另一個程序。

二、上機實踐

1.通過程序實現求1～100之間不能被3整除的數之和。

【提示】關鍵代碼如下：

for(int i=0;i<=100;i++){
      if(i%3!=0){
           sum=sum+i;
    }
}

2.通過程序實現求整數1～100的累加值，但要求跳過所有個位為3的數。

【提示】關鍵代碼如下：

for(int i=0;i<=100;i++){
     // 判斷個位數字是否為3
      if(i%10==3){
          continue;
     }
     sum=sum+i;
}

3.輸入一個正整數，輸出該數的階乘。

【提示】整數n的階乘公式為：n!=1×2×…×n。（n!表示n的階乘）。

4.輸入一個正整數n，判斷該數是不是質數，如果是質數輸出“n是一個質數”，否則輸出“n不是質數”。

【提示】質數的含義：除了1和它本身不能被任何數整除。