郁欣 孫元 王曦東 王克宏
與 C、 C++相 同 ,Java程 序 通 過 流 控 制 來 執 行 程 序 流 ,完 成 一 定 的 任 務 。 程 序 流 是 由 若 干
個 語 句 組 成 的 。 語 句 可 以 是 單 一 的 一 條 語 句 ( 如 c=a+b; ),也 可 以 是 用 大 括 號 {}括 起 來 的 一 個
復 合 語 句 。
下 面 我 們 分 別 來 介 紹 Java中 的 流 控 制 語 句 ,包 括
1.分 支 語 句 :if-else, break, switch, return.
2.循 環 語 句 :while, do-while, for, continue.
3.例 外 處 理 語 句 :try-catch-finally, throw
最 後 我 們 簡 單 介 紹 一 下 注 釋 語 句 。
§ 4.1分 支 語 句
分 支 語 句 提 供 了 一 種 控 制 機 制 ,使 得 程 序 的 執 行 可 以 跳 過 某 些 語 句 不 執 行 ,而 轉 去 執
行 特 定 的 語 句 。
4.1.1條 件 語 句 if-else.
if-else語 句 根 據 判 定 條 件 的 真 假 來 執 行 兩 種 操 作 中 的 一 種 , 它 的 格 式 為 :
if(boolean-eXPression)
statement1;
[else
statement2;]
1.布 爾 表 達 式 boolean-expression是 任 意 一 個 返 回 布 爾 型 數 據 的 表 達 式 (這 比 C、 C++的 限 制
要 嚴 格 )。
2.每 個 單 一 的 語 句 後 都 必 須 有 分 號 。
3.語 句 statement1,statement2可 以 為 復 合 語 句 ,這 時 要 用 大 括 號 {} 括 起 。 建 議 對 單 一 的 語 句
也 用 大 括 號 括 起 ,這 樣 程 序 的 可 讀 性 強 ,而 且 有 利 於 程 序 的 擴 充 (可 以 在 其 中 填 加 新 的 語 句
)。 {}外 面 不 加 分 號 。
4.else子 句 是 任 選 的 。
5.若 布 爾 表 達 式 的 值 為 true,則 程 序 執 行 statement1,否 則 執 行 st atement2。
6.if-else語 句 的 一 種 特 殊 形 式 為 :
if(expression1){
statement1
}else if (expression2){
statement2
}……
}else if (expressionM){
statementM
}else {
statementN
}
@@@[
else子句不能單獨作為語句使用,它必須和if配對使用。else總是與離它最近的if配對
。可以通過使用大括號{}來改變配對關系。
7.舉例:
例4.1 比較兩個數的大小,並按從小到大的次序輸出。
@@@[
public class CompareTwo{
public static void main( String args[] ){
double d1=23.4;
double d2=35.1;
if(d2＞=d1)
System.out.println(d2+" ＞= "+d1);
else
System.out.println(d1+" ＞= "+d2);
}
}
運行結果為:
C:＞java CompareTwo
35.1 ＞= 23.4
例 4.2 判 斷 某 一 年 是 否 為 閏 年 。
閏 年 的 條 件 是 符 合 下 面 二 者 之 一 :① 能 被 4整 除 ,但 不 能 被 10 0整 除 ;② 能 被 4整 除 ,又 能 被
100整 除 。
public class LeapYear{
public static void main( String args[] ){
int year=1989; //method 1
if( (year%4==0 && year%100!=0) (year%400==0) )
System.out.println(year+" is a leap year.");
else
System.out.println(year+" is not a leap year.");
year=2000; //method 2
boolean leap;
if( year%4!=0 )
leap=false;
else if( year%100!=0 )
leap=true;
else if( year%400!=0 )
leap=false;
else
leap=true;
if( leap==true )
System.out.println(year+" is a leap year.");
else
System.out.println(year+" is not a leap year.");
year=2050; //method3
if( year%4==0){
if( year%100==0 ){
if( year%400==0)
leap=true;
else
leap=false;
}else
leap=false;
}else
leap=false;
if( leap==true )
System.out.println(year+" is a leap year.");
else
System.out.println(year+" is not a leap year.");
}
}
運行結果為
C:＞java LeapYear
1989 is not a leap year.
2000 is a leap year.
2050 is not a leap year.
該 例 中 ,方 法 1用 一 個 邏 輯 表 達 式 包 含 了 所 有 的 閏 年 條 件 ,方 法 2使 用 了 if-else語 句 的 特 殊
形 式 ,方 法 3則 通 過 使 用 大 括 號 {}對 if-else進 行 匹 配 來 實 現 閏 年 的 判 斷 。 大 家 可 以 根 據 程 序 來
對 比 這 三 種 方 法 ,體 會 其 中 的 聯 系 和 區 別 ,在 不 同 的 場 合 選 用 適 合 的 方 法 。
4.1.2多 分 支 語 句 switch
switch 語 句 根 據 表 達 式 的 值 來 執 行 多 個 操 作 中 的 一 個 ,它 的 一 般 格 式 如 下 :
switch (expression){
case value1 : statement1;
break;
case value2 : statement2;
break;
…………
case valueN : statemendN;
break;
[default : defaultStatement; ]
}
1.表 達 式 expression可 以 返 回 任 一 簡 單 類 型 的 值 (如 整 型 、 實 型 、 字 符 型 ),多 分 支 語 句 把
表 達 式 返 回 的 值 與 每 個 case子 句 中 的 值 相 比 。 如 果 匹 配 成 功 ,則 執 行 該 case子 句 後 的 語 句 序
列 。
2.case子 句 中 的 值 valueI必 須 是 常 量 ,而 且 所 有 case子 句 中 的 值 應 是 不 同 的 。
3.default子 句 是 任 選 的 。 當 表 達 式 的 值 與 任 一 case子 句 中 的 值 都 不 匹 配 時 ,程 序 執 行
default後 面 的 語 句 。 如 果 表 達 式 的 值 與 任 一 case子 句 中 的 值 都 不 匹 配 且 沒 有 default子 句 ,則 程
序 不 作 任 何 操 作 ,而 是 直 接 跳 出 switch語 句 。
4.break語 句 用 來 在 執 行 完 一 個 case分 支 後 ,使 程 序 跳 出 switch語 句 ,即 終 止 switch語 句 的 執 行
。 因 為 case子 句 只 是 起 到 一 個 標 號 的 作 用 ,用 來 查 找 匹 配 的 入 口 並 從 此 處 開 始 執 行 ,對 後 面
的 case子 句 不 再 進 行 匹 配 ,而 是 直 接 執 行 其 後 的 語 句 序 列 , 因 此 應 該 在 每 個 case分 支 後 ,要 用
break來 終 止 後 面 的 case分 支 語 句 的 執 行 。
在 一 些 特 殊 情 況 下 ,多 個 不 同 的 case值 要 執 行 一 組 相 同 的 操 作 ,這 時 可 以 不 用 break。
5.case分 支 中 包 括 多 個 執 行 語 句 時 ,可 以 不 用 大 括 號 {}括 起 。
6.switch語 句 的 功 能 可 以 用 if-else來 實 現 ,但 在 某 些 情 況 下 ,使 用 switch語 句 更 簡 煉 ,可 讀 性 強
,而 且 程 序 的 執 行 效 率 提 高 。
7.舉 例 :
例 4.3.根 據 考 試 成 績 的 等 級 打 印 出 百 分 制 分 數 段 。
public class GradeLevel{
public static void main( String args[] ){
System.out.println("
** first situation **");
char grade=´C´; //normal use
switch( grade ){
case ´A´ : System.out.println(grade+" is 85～100");
break;
case ´B´ : System.out.println(grade+" is 70～84");
break;
case ´C´ : System.out.println(grade+" is 60～69");
break;
case ´D´ : System.out.println(grade+" is ＜60");
break;
default : System.out.println("input error");
}
System.out.println("
** second situation **");
grade=´A´; ∥creat error without break statement
switch( grade ){
case ´A´ : System.out.println(grade+" is 85～100");
case ´B´ : System.out.println(grade+" is 70～84");
case ´C´ : System.out.println(grade+" is 60～69");
case ´D´ : System.out.println(grade+" is ＜60");
default : System.out.println("input error");
}
System.out.println("
** third situation **");
grade=´B´; ∥several case with same operation
switch( grade ){
case ´A´ :
case ´B´ :
case ´C´ : System.out.println(grade+" is ＞=60");
break;
case ´D´ : System.out.println(grade+" is ＜60");
break;
default : System.out.println("input error");
}
}
}
運行結果為
C:＞java GradeLevel
**** first situation ****
C is 60～69
**** second situation ****
A is 85～100
A is 70～84
A is 60～69
A is ＜60
input error
**** third situation ****
B is ＞=60
從 該 例 中 我 們 可 以 看 到 break語 句 的 作 用 。
4.1.3 break語 句
1.在 switch語 中 ,break語 句 用 來 終 止 switch語 句 的 執 行 。 使 程 序 從 switch語 句 後 的 第 一 個 語 句
開 始 執 行 。
2.在 Java中 ,可 以 為 每 個 代 碼 塊 加 一 個 括 號 ,一 個 代 碼 塊 通 常 是 用 大 括 號 {}括 起 來 的 一 段
代 碼 。 加 標 號 的 格 式 如 下 :
BlockLabel: { codeBlock }
break語 句 的 第 二 種 使 用 情 況 就 是 跳 出 它 所 指 定 的 塊 ,並 從 緊 跟 該 塊 的 第 一 條 語 句 處 執
行 。 其 格 式 為 :
break BlockLabel;
例如:
a:{…… //標記代碼塊a
b: {…… //標記代碼塊b
c: {…… //標記代碼塊c
break b;
…… //will not be executed
}
…… //will not be executed
}
…… /execute from here
}
3.與 C、 C++不 同 ,Java中 沒 有 goto語 句 來 實 現 任 意 的 跳 轉 ,因 為 g oto語 句 破 壞 程 序 的 可 讀 性
,而 且 影 響 編 譯 的 優 化 。 但 是 從 上 例 可 以 看 出 ,Java用 break來 實 現 goto語 句 所 特 有 的 一 些 優 點
。 如 果 break後 所 指 定 的 標 號 不 是 一 個 代 碼 塊 的 標 號 ,而 是 一 個 語 句 ,則 這 時 break完 全 實 現
goto的 功 能 。 不 過 應 該 避 免 這 種 方 式 的 使 用 。 ？ (未 完 待 續 )
4.1.4返 回 語 句 return
return語 句 從 當 前 方 法 中 退 出 ,返 回 到 調 用 該 方 法 的 語 句 處 , 並 從 緊 跟 該 語 句 的 下 一 條 語
句 繼 續 程 序 的 執 行 。 (有 關 方 法 的 內 容 ,我 們 將 在 第 六 章 詳 細 講 述 。 前 面 例 子 中 的 main( )就
是 一 個 方 法 )。 返 回 語 句 有 兩 種 格 式 :
1.return expression
返 回 一 個 值 給 調 用 該 方 法 的 語 句 ,返 回 值 的 數 據 類 型 必 須 和 方 法 聲 明 中 的 返 回 值 類 型
一 致 。 可 以 使 用 強 制 類 型 轉 換 來 使 類 型 一 致 。
2.return
當 方 法 說 明 中 用 void聲 明 返 回 類 型 為 空 時 ,應 使 用 這 種 格 式 ,它 不 返 回 任 何 值 。
return 語 句 通 常 用 在 一 個 方 法 體 的 最 後 ,以 退 出 該 方 法 並 返 回 一 個 值 。 Java中 ,單 獨 的
return語 句 用 在 一 個 方 法 體 的 中 間 時 ,會 產 生 編 譯 錯 誤 ,因 為 這 時 會 有 一 些 語 句 執 行 不 到 。 但
可 以 通 過 把 return語 句 嵌 入 某 些 語 句 (如 if-else)來 使 程 序 在 未 執 行 完 方 法 中 的 所 有 語 句 時 退 出
,例 如 :
int method (int num) {
∥ return num; ∥will cause compile time error
if (num＞0)
return num;
…… ∥ may or may not be executed
∥depending on the value of num
§ 4.2循 環 語 句
循 環 語 句 的 作 用 是 反 復 執 行 一 段 代 碼 ,直 到 滿 足 終 止 循 環 的 條 件 為 止 ,一 個 循 環 一 般
應 包 括 四 部 分 內 容 :
1.初 始 化 部 分 (initialization):用 來 設 置 循 環 的 一 些 初 始 條 件 , 如 計 數 器 清 零 等 。
2.循 環 體 部 分 (body):這 是 反 復 循 環 的 一 段 代 碼 ,可 以 是 單 一 的 一 條 語 句 ,也 可 以 是 復 合 語
句 。
3.迭 代 部 分 (iteration):這 是 在 當 前 循 環 結 束 ,下 一 次 循 環 開 始 前 執 行 的 語 句 ,常 常 用 來 使 計
數 器 加 1或 減 1。
4.終 止 部 分 (termination):通 常 是 一 個 布 爾 表 達 式 ,每 一 次 循 環 都 要 對 該 表 達 式 求 值 ,以 驗 證
是 否 滿 足 循 環 終 止 條 件 。
Java中 提 供 的 循 環 語 句 有 :while語 句 ,do-while語 句 和 for語 句 ,下 面 分 別 介 紹 。
4.2.1while語 句
while語 句 實 現 "當 型 "循 環 ,它 的 一 般 格 式 為 ;
[initialization]
while (termination){
body;
[iteration;]
}
1.當 布 爾 表 達 式 (termination)的 值 為 true時 ,循 環 執 行 大 括 號 中 的 語 句 。 並 且 初 始 化 部 分 和
迭 代 部 分 是 任 選 的 。
2.while語 句 首 先 計 算 終 止 條 件 ,當 條 件 滿 足 時 ,才 去 執 行 循 環 體 中 的 語 句 。 這 是 "當 型 "循
環 的 特 點 。
4.2.2 do-while語 句
do-while 語句實現"直到型"循環,它的一般格式為:
[initialization]
do {
body;
[iteration;]
} while (termination);
1.do-while語 句 首 先 執 行 循 環 體 ,然 後 計 算 終 止 條 件 ,若 結 果 為 true,則 循 環 執 行 大 括 號 中 的
語 句 ,直 到 布 爾 表 達 式 的 結 果 為 false。
2.與 while語 句 不 同 的 是 ,do-while語 句 的 循 環 體 至 少 執 行 一 次 , 這 是 "直 到 型 "循 環 的 特 點 。
4.2.3 for語 句
for語 句 也 用 來 實 現 "當 型 "循 環 ,它 的 一 般 格 式 為 :
for (initialization; termination; iteration){
body;
}
1.for語 句 執 行 時 ,首 先 執 行 初 始 化 操 作 ,然 後 判 斷 終 止 條 件 是 否 滿 足 ,如 果 滿 足 ,則 執 行 循
環 體 中 的 語 句 ,最 後 執 行 迭 代 部 分 。 完 成 一 次 循 環 後 ,重 新 判 斷 終 止 條 件 。
2.可 以 在 for語 句 的 初 始 化 部 分 聲 明 一 個 變 量 ,它 的 作 用 域 為 整 個 for 語 句 。
3.for語 句 通 常 用 來 執 行 循 環 次 數 確 定 的 情 況 (如 對 數 組 元 素 進 行 操 作 ),也 可 以 根 據 循 環
結 束 條 件 執 行 循 環 次 數 不 確 定 的 情 況 。
4.在 初 始 化 部 分 和 迭 代 部 分 可 以 使 用 逗 號 語 句 ,來 進 行 多 個 操 作 。 逗 號 語 句 是 用 逗 號
分 隔 的 語 句 序 列 。 例 如 :
for( i=0, j=10; i＜j; i++, j--){
……
}
5.初 始 化 、 終 止 以 及 迭 代 部 分 都 可 以 為 空 語 句 (但 分 號 不 能 省 ),三 者 均 為 空 的 時 候 ,相
當 於 一 個 無 限 循 環 。
4.2.4 continue語 句
1.continue語 句 用 來 結 束 本 次 循 環 ,跳 過 循 環 體 中 下 面 尚 未 執 行 的 語 句 ,接 著 進 行 終 止 條
件 的 判 斷 ,以 決 定 是 否 繼 續 循 環 。 對 於 for語 句 ,在 進 行 終 止 條 件 的 判 斷 前 ,還 要 先 執 行 迭 代
語 句 。 它 的 格 式 為 :
continue;
2.也 可 以 用 continue跳 轉 到 括 號 指 明 的 外 層 循 環 中 ,這 時 的 格 式 為
continue outerLable;
例 如 :
outer: for( int i=0; i＜10; i++ ){ ∥外層循環
for( int j=0; j＜20; j++ ){ ∥內層循環
if( j＞i ){
……
continue outer;
}
……
}
……
}
該 例 中 ,當 滿 足 j＞i的 條 件 時 ,程 序 執 行 完 相 應 的 語 句 後 跳 轉 到 外 層 循 環 ,執 行 外 層 循 環
的 迭 代 語 句 i++;然 後 開 始 下 一 次 循 環 。
4.2.5舉 例
例 4.4 下 例 分 別 用 while、 do-while和 for語 句 實 現 累 計 求 和 。
public class Sum{
public static void main( String args[] ){
System.out.println("
** while statement **");
int n=10,sum=0; ∥initialization
while( n＞0 ){ ∥termination
sum+=n; ∥body
n--; ∥iteration
}
System.out.println("sum is "+sum);
System.out.println("
** do_while statement **");
n=0; ∥initialization
sum=0;
do{
sum+=n; ∥body
n++; ∥iteration
}while( n＜=10 ); ∥termination
System.out.println("sum is "+sum);
System.out.println("
** for statement **");
sum=0;
for( int i=1; i＜=10; i++){
∥initialization,termination,iteration
sum+=i;
}
System.out.println("sum is "+sum);
}
}
運行結果為:
C:＞java Sum
** while statement **
sum is 55
** do_while statement **
sum is 55
** for statement **
sum is 55
可以從中來比較這三種循環語句,從而在不同的場合選擇合適的語句。
例4.5 求100～200間的所有素數
public class PrimeNumber{
public static void main( String args[] ){
System.out.println(" ** prime numbers between 100 and 200 **");
int n=0;
outer:for(int i=101;i＜200;i+=2){ ∥outer loop
int k=15; ∥select for convinence for(int j=2;j＜=k;j++){ ∥inner loop
if( i%j==0 )
continue outer;
}
System.out.print(" "+i);
n++; ∥output a new line
if( n＜10 ) ∥after 10 numbers
continue;
System.out.println();
n=0;
}
System.out.println();
}
}
運行結果為:
C:＞java PrimeNumber
** prime numbers between 100 and 200 **
101 103 107 109 113 127 131 137 139 149
151 157 163 167 173 179 181 191 193 197
199
該 例 通 過 一 個 嵌 套 的 for語 句 來 實 現 。 !U4§ 4.3例 外 處 理 語 句
例 外 處 理 語 句 包 括 try、 catch、 finally以 及 throw語 句 。 與 C、 C+ +相 比 ,例 外 處 理 語 句 是
Java所 特 有 的 。 我 們 將 在 第 八 章 作 專 門 的 介 紹 。 !U4§ 4.4 注 釋 語 句
Java中 可 以 采 用 三 種 注 釋 方 式 :
1 ∥ 用於單行注釋。注釋從∥開始,終止於行尾。
2 /* … */ 用於多行注釋。注釋從/*開始,到*/結束,且這種注釋不能互相嵌套。
3 /** … */ 是Java所特有的doc注釋。它以/**開始,到*/結束。這種注釋主要是
為支持JDK工具javadoc而采用的。javadoc能識別注釋中用標記@標識的一些非凡變量,並把
doc注釋加入它所生成的Html文件。對javadoc的具體講述可參見附錄。
