流程控制

　

作者：　許裕永

程式碼執行的流程，預設是由左而右，由上而下，逐敍述句執行。若設計師希望能指定部份的程式碼，在某些狀況下不要執行，或指定部份的程式碼，在某些狀況下能重複執行。這時就需要針對敍述句的運算流程加以控制，本章介紹的便是控制程式碼執行流程的語法。
而流程的控制，不外乎判斷與迴圈。判斷指的是：「在條件成立或不成立的情況下執行指定的敍述句」；迴圈指的是：「在條件成立的情況下，重複執行指定的敍述 句」。本章介紹的語法雖多，但都是判斷與迴圈的各種變化。每一種語法都相當重要，初學者應該把重點放在本章，多加練習。這是程式設計的基礎，把底打好，後 面的章節學起來才會比較輕鬆。
玩積木，除了要知道每一塊積木的樣式，更重要的是：「了解各種不同樣式的積木，組合起來所產生的變化」。能掌握的變化越多，越能作出別人作不出來的成品。 程式語言就像積木，每個人使用的元件（學會的基礎語法）都一樣。但能否用一塊塊的小元件，堆積出一件傲人的作品。靠的就是：「了解每一個元件的變化及應用 方式」。而這種能力不是看別人的作品就能看來的。即使看懂了，折開後也不見得能再組回來。要能深入了解並完全應用這些基礎語法，只有一個方式：不斷的練， 重複的練。記住，不光是要學會，還要熟練。
1. ｉｆ　ｅｌｓｅ
１－１　基本語法：
if(布林值){
　敍述區Ａ；
}[else{
　敍述區Ｂ；
}]
若布林值的值為ｔｒｕｅ就執行敍述區Ａ，若布林值的值為ｆａｌｓｅ就執行敍述區Ｂ。中括號代表可以省略，省略後的意思為：若布林值的值為ｔｒｕｅ就執行敍述區Ａ，若布林值的值為ｆａｌｓｅ就不執行敍述區Ａ。
布林值指的是：「運算結果為ｔｒｕｅ或ｆａｌｓｅ的運算式」。也就是用條件運算符號及邏輯運算符號組成的運算式。另外，也可以是布林值型態的變數，或是運算結果為布林值的方法。
敍述區Ａ或Ｂ指的是敍述句的集合，置於區塊（大括號）中，若敍述句只有一句，大括號可以省略。但初學者在未能完全掌握程式流程之前，並不建議省略。
例一：
if(5<3){
　System.out.println(“Hello!”);
}
此例不執行任何輸出
例二：
if(5<3){
　System.out.println(“Hello“);
}else{
　System.out.println(“World”);
}
此例輸出Ｗｏｒｌｄ
例三：
if(5<3)
　System.out.println(“Hello”);
System.out.println(“World”);
此例輸出Ｗｏｒｌｄ。在Ｊａｖａ中，所有的敍述句以分號結束，除非用大括號集合起來。本例中的ｉｆ敍述並沒有使用大括號，所以ｉｆ的敍述在第一個分號出現時便結束了。第三行敍述句不屬於ｉｆ敍述的一部份。
例四：
if(5<3)
　System.out.println(“Hello”);
　System.out.println(“World”);
else
　System.out.println(“Java”);
此例編譯錯誤，因為ｉｆ敍述在第二行便已經結束，而ｅｌｓｅ不可以單獨存在。
１－２　學習重點：
學習判斷要先注意：重點不是敍述區Ａ或Ｂ中的敍述句，而是條件運算式的分析與建立。條件成立或不成立時要執行那些敍述句，應該是早就規劃好的；重點是條件運算式要如何寫才能做出正確的判斷。
範例：接收使用者輸入任意整數，程式回應使用者輸入的數字為奇數或偶數。
檔名： IfElseDemo.java
階段一：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以重複接收執行時期的輸入
　}
}
在此階段先輸入程式基本架構，並做好接收使用者輸入的機制，此機制後續的範例時常會用到。不懂的地方，可以先背起來，後續章節才會介紹。
階段二：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以接收執行時期的輸入
　　System.out.print(“請輸入任意一個整數-->”);
　　int value=s.nextInt();
　}
}
此階段為提示輸入，及接收輸入，並將使用者輸入之數字儲存於變數ｖａｌｕｅ。指派運算符號右側的ｓ‧ｎｅｘｔＩｎｔ（）執行時，程式會暫停執行，直到使用者輸入Ｅｎｔｅｒ後，程式再繼續執行。
階段三：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以接收執行時期的輸入
　　System.out.print(“請輸入任意一個整數-->”);
　　int value=s.nextInt();
　　if(){
　　　System.out.println(value + “為奇數”);

}else{
　System.out.println(value + “為偶數”)
　　}
　}
}
在條件運算式尚未建立前，可以先把要執行的敍述區完成，這樣也可以增加思考條件運算式的靈感。
階段四：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以接收執行時期的輸入
　　System.out.print(“請輸入任意一個整數-->”);
　　int value=s.nextInt();
　　if(value%2==1){
　　　System.out.println(value + “為奇數”);
　　}else{
　　　System.out.println(value + “為偶數”);
　　}
　}
}
條件運算式為：運算ｖａｌｕｅ除以２的餘數。若餘數等於１，此條件運算式的值便為ｔｒｕｅ；若餘數不等於１，此條件運算式的值便為ｆａｌｓｅ。
１－３　二個以上的敍述區：
一個條件運算式可以控制一個敍述區，搭配ｅｌｓｅ最多控制兩個敍述區。若有兩個以上的敍述區呢？比方說，剛才奇數偶數的範例若要考慮０呢？０不是奇數也不是偶數，所以程式碼多了一個輸出的變化：「必須告訴使用者輸入的是０」。那麼這一個敍述應該加在那裏呢？
換個角度來看就是：「兩個敍述區至少須要一個條件運算式，三個敍述區至少須要二個條件運算式，四個敍述區至少須要三個條件運算式‧‧‧以此類推」。而如何排列這些條件運算式，就是讀者必須多加練習的重點了。
關鍵：由外往內寫。先寫外圍條件，再決定內圍條件應該附屬於外圍條件的成立區塊或不成立區塊。
例一：
if(value%2==1){
　System.out.println(value + “為奇數”);
}else{
　if(value==0){
　　System.out.println(value + “為０”);
　}else{
　　System.out.println(value + “為偶數”);
　}
}
在此例中若ｖａｌｕｅ的值為０，則ｖａｌｕｅ除以２的餘數為０，所以ｖｌｕｅ是否為０的判斷，要依附於ｅｌｓｅ。
例二：
if(value%2==０){
　if(value==0){
　　System.out.println(value + “為０”);
　}else{
　　System.out.println(value + “為偶數”);
　}
}else{
　System.out.println(value + “為奇數”);
}
在此例中，外圍ｉｆ的條件運算式，改為判斷ｖａｌｕｅ除以２的餘數是否為０，所以ｖａｌｕｅ是否為０的判斷依附於ｉｆ。
例三：
if(value==０){
　System.out.println(value + “為０”);
}else{
　if(value%2==１){
　　System.out.println(value + “為奇數”);
　}else{
　　System.out.println(value + “為偶數”);
　}
}
在此例中，ｉｆ的條件運算式改成ｖａｌｕｅ是否為０的判斷，只有在ｖａｌｕｅ不是０的時才判斷餘數。
例四：
if(value==０){
　System.out.println(value + “為０”);
}else if(value%2==１){
　System.out.println(value + “為奇數”);
}else{
　System.out.println(value + “為偶數”);
}
在此例中，我們把原先寫在ｅｌｓｅ區塊中的判斷，改寫到ｅｌｓｅ後面。形成了：如果條件１成立則‧‧‧，否則如果條件２成立則‧‧‧，否則‧‧‧的判斷。 而條件的判斷可以沒有次數限制的以ｅｌｓｅ　ｉｆ的方式持續加上去，這是為了避免條件判斷比較多的時候，寫成巢狀判斷會過於複雜，影響程式碼可讀性的寫 法。
例五：
if(value%2==０){
　System.out.println(value + “為偶數”);
}else if(value%2==１){
　System.out.println(value + “為奇數”);
}else{
　System.out.println(value + “為0”);
}
在此例中，語法架構和例四是一樣的，但條件運算式的排列不一樣。執行的結果就會產生誤差。ｖａｌｕｅ的值若為偶數或奇數都可以得到正確的結果，但若ｖａｌｕｅ的值為０時，在第一個ｉｆ判斷時就會成立，所以列印結果是：「０是偶數」。這種狀況，我們就稱之為「邏輯錯誤」。
透過這五個案例，希望可以讓初學者體會到，前面關於積木的說法。進而不斷練習不同的組合方式，來達成各種不同或相同的結果。當你對巢狀判斷感到迷惑時，謹 記「是在ｉｆ或ｅｌｓｅ的區塊中，視程式的需要來寫內層的ｉｆ；而不是在ｉｆ的外層寫ｉｆ」。當然，更重要的是：「先分析由那一個條件放在最外層」。
範例：使用者輸入年份，程式回應該年是否為潤年（四的倍數年為潤年，一百的倍數年不是潤年。四百的倍數年也是潤年）。
檔名：IfElseDemo2.java
階段一：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(){
　　　System.out.println(year + "是潤年");
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
先寫好輸入及輸出之基本架構，接下來便能專注於條件運算式的建立。
階段二：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　System.out.println(year + "是潤年");
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
再次強調：由外而內，一個條件，一個條件的分開處理。比方說，接下來就可以思考ｙｅａｒ是否為１００的倍數年？應該寫在那一個區塊呢？
階段三：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　System.out.println(year + "不是潤年");
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
因為１００的倍數年可以被４整除，所以在ｉｆ的區塊中判斷ｙｅａｒ是否為１００的倍數年。
階段四：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　if(year%400==0){
　　　　　System.out.println(year + "是潤年");
　　　　}else{
　　　　　System.out.println(year + "不是潤年");
　　　　}
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
因為４００的倍數年可以被１００整除，而判斷是否為１００倍數年的條件運算式是！＝，所以４００倍數年的判斷必須寫在ｅｌｓｅ的區塊中。
階段五：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0){
　　　　System.out.println(year + "是潤年");
　　　}else if(year%400==0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　System.out.println(year + "不是潤年");
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
還記得嗎？ｅｌｓｅ區塊中的ｉｆ可以直接寫在ｅｌｓｅ後面。看起來是不是比較容易懂呢？
階段六：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0 || year%400==0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　System.out.println(year + "不是潤年");
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
如果，ｉｆ跟ｅｌｓｅ　ｉｆ的區塊中，要執行的敍述一樣的話，是可以用ｏｒ的邏輯運算符號串聯起來的。
階段七：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0 && year%100!=0 || year%400==0){
　　　System.out.println(year + "是潤年");
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
ｉｆ的條件運算式跟區塊中的ｉｆ的條件運算式，其實就是ａｎｄ的關係。
什麼？繞了一大圈，結果竟然一個條件運算式就搞定了！是的，但是這七個階段你一個也不能省，這是循序漸進的，每完成一個階段代表你對判斷語法，有更深一層 的認識，日後就會多一種的應用。（喂！大哥。做範例不是看著書照打，練英打嗎？把書合起來，自己寫。寫不出來，再來偷看。）
１－４　常見錯誤
撰寫ｉｆ敍述時，常見的錯誤是小括號中用了運算結果不是布林值的運算式，以及因為大括號省略而產生語意上的誤解。
例一：
int x=1;
if(x=1){
　System.out.println(x);
}
此例小括號中運算式的意思是：把１指派給變數ｘ，再以ｘ的值作為小括號的運算值。但因為ｘ不是布林值，所以會造成編譯錯誤。
例二：
boolean b=false;
if(b=true){
　System.out.println(b);
}
此例的小括號中運算式的意思是：把布林值ｔｒｕｅ指派給變數ｂ，再以ｂ的值作為小括號的運算值。而ｂ的值已經是ｔｒｕｅ，所以會列印ｔｒｕｅ。
例三：
if(5>3)
　if(5<3)
　　System.out.println(8);
　else
System.out.println(10);
此例中的ｅｌｓｅ到底是第一個ｉｆ，還是第二個ｉｆ的呢？因為省略了大括號，所以就很容易造成誤解。答案是第二個ｉｆ的。自己試試看吧！
１－５　課後練習：
練習１：提款機登入程式＝＞讓使用者輸入八個數字的晶片密碼，若符合你預設的數字（比如：１２３４５６７８），則輸出“歡迎光臨大笨銀行”，否則輸出“密碼錯誤，請重新輸入”。但是，此程式最多接受三次的輸入。（不使用迴圈）
練習２：手機開機程式＝＞讓使用者輸入兩組四個數字的密碼，一組為ＳＩＭ卡密碼，一組為手機密碼，必須兩組都對才輸出“已開機”，否則請明確告知使用者，是ＳＩＭ卡密碼錯誤，或是手機密碼錯誤，或是兩組都錯。

2. ？：（條件運算符號）
２－１　基本語法：
（條件運算式？敍述句Ａ：敍述句Ｂ）
如果條件運算式的值為ｔｒｕｅ，執行敍述句Ａ；如果條件運算式的值為ｆａｌｓｅ，執行敍述句Ｂ。 而敍述句Ａ和敍述句Ｂ都必須是：「會產生一個值的運算式」。也就是說，整個小括號代表一個值，如果條件運算式的值為ｔｒｕｅ，這個小括號就代表敍述句Ａ運算後的值；如果條件運算式的值為ｆａｌｓｅ，這個小括號就代表敍述句Ｂ運算後的值。
小括號中的敍述，並不算完整的敍述句，只能算是產生一個值的運算式，所以它不能單獨存在。它必須是某一句敍述句中的一部份。小括號可以省略，但為了程式碼的可讀性，建議不要省略。
例一：
int a=10;
int b=12;
int c=a>b?a:b;
此例ｃ的值為１２。
例二：
int a=10;
int b=12;
int c=14;
int d=a+(a>b?a:b);
此例ｄ的值為２０。
例三：
int a=10;
int b=12;
int c=14;
int d=a+a>b?a:b;
此例ｄ的值為１０，省略小括號後ａ＋ａ會先運算。
例四：
int a=10;
int b=12;
int c=14;
boolean d=c>(a>b?a:b);
此例ｄ的值為ｔｒｕｅ，但若省略小括號則會造成編譯錯誤。因為條件運算式會變成ｃ＞ａ＞ｂ？ａ：ｂ。其中的ｃ＞ａ＞ｂ編譯器是看不懂的。
例五：
int a=10;
int b=12;
int c=14;
int d=(a>b?a:(b>c?b:c));
此例ｄ的值為１４，就像巢狀的ｉｆ判斷一樣，此運算式也可以是巢狀的。
範例：接受輸入任意一個整數後，輸出該整數的絕對值。
檔名：ABS.java
import java.util.*;
public class ABS{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　System.out.println("絕對值:" + (value>0 ? value : -value));
　}
}

3. ｓｗｉｔｃｈ
３－１　基本語法：
switch(運算式){
　case 值A:
　　敍述區;
　　break;
　[case 值B:
　　敍述區;
　　break;
　default:
　　敍述區;]
}
ｓｗｉｔｃｈ是把運算式的運算結果，和ｃａｓｅ後面的值做比對。若相等的話，則執行該ｃａｓｅ的敍述區。
運算式的運算結果必須是ｉｎｔ、ｂｙｔｅ或ｓｈｏｒｔ型別的整數值，當然包含可以自動轉換為ｉｎｔ型別的ｃｈａｒ。也就是說，它可以是一個會產生整數值的運算式或變數（不包含ｌｏｎｇ型別）。
例：
int a=s.nextInt();//接收使用者輸入
switch(a){
　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(“請輸入正確數值”);
}
在此例中，程式會依照使用者的輸入，由上而下來比對所有ｃａｓｅ後面的值，若找到相等的值就執行該ｃａｓｅ的敍述區，執行完就離開ｓｗｉｔｃｈ敍述。若所有ｃａｓｅ後面的值都不相等，就會執行ｄｅｆａｕｌｔ的敍述，執行完結束ｓｗｉｔｃｈ。
區塊中的ｃａｓｅ沒有個數的限制，而且不必依照值的大小排列。
例：
switch(a){
　case 6:
　case 7:
　case ‘1’://此字元代表整數值４９（字元碼）
　case 4:
}
此例是合法的。
但ｃａｓｅ後方的值一樣必須是整數，而且其值不可以超過，ｓｗｉｔｃｈ小括號中的運算式的型別的最大或最小值的範圍。
例：
byte b=s.nextByte();
switch(b){
　case 128:
}
此例ｃａｓｅ後面的值大於ｂｙｔｅ的最大值，所以不合法。
區塊中所有ｃａｓｅ的值不可以重複。
例：
int a=s.nextInt();
switch(a){
　case 8:
　case 5:
　case 8:
}
此例ｃａｓｅ後面的值重複，所以不合法。
因為ｃａｓｅ後面的值必須在編譯時期就確認，所以不可以是變數。
例一：
int a=s.nextInt();
int b=s.nextInt();
switch(a){
　case 6:
　case 8:
　case b:
}
此例變數ｂ置於ｃａｓｅ後方，所以不合法。
例二：
int a=s.nextInt();
final int b=8;
switch(a){
　case 5:
　case 10:
　case b:
}
此例ｂ為常數（ｆｉｎａｌ），屬於編譯時期就確認的值。所以合法。
例三：
int a=s.nextInt();
final int b；
b=8;
switch(a){
　case 5:
　case 10:
　case b:
}
Ｊａｖａ中的常數為了提高實用性，在宣告句中可以不指派。但這樣子的常數不算是編譯時期就可以確認的值，所以不能放在ｃａｓｅ的後面。此例會產生編譯錯誤。
ｂｒｅａｋ用來中斷ｓｗｉｔｃｈ，當ｓｗｉｔｃｈ中某一個ｃａｓｅ成立後，便會執行該ｃａｓｅ的敍述區。若這個敍述區沒有ｂｒｅａｋ，則會繼續執行下一個 敍述區，一直到遇到ｂｒｅａｋ才會中斷。但若一直沒有遇到ｂｒｅａｋ，就會執行到這個ｓｗｉｔｃｈ的末端。此種特性，大部份會使用在需要數個ｃａｓｅ敍述 區共用的時候。
例：
int a=s.nextInt();
switch(a){
　case 3:
　case 5:
　　a++;
　case 6:
　　a++;
　　break;
}
此例中若ａ＝３或５，則ｓｗｉｔｃｈ執行完，ａ的值會分別為５或７。若ａ＝６，則ｓｗｉｔｃｈ執行完，ａ的值為７。
ｄｅｆａｕｌｔ可以省略，若沒有省略也不一定要置於最末端。只不過若沒有置於最末端，就必須注意有沒有必要加ｂｒｅａｋ。原先沒有加ｂｒｅａｋ是因為：「若置於最末端，則ｄｅｆａｕｌｔ執行完，整個ｓｗｉｔｃｈ就結束，沒必要加，而不是不能加」。
例：
int a=s.nextInt();
switch(a){
　case 2:
　　a++;
　case 5:
　　a++;
　　break;
　default:
　　a++;
　case 3:
　　a++;
}
此例中，若ａ＝２，ｓｗｉｔｃｈ執行完ａ的值為４。若ａ＝５，ｓｗｉｔｃｈ執行完ａ的值為６。請注意若ａ＝３，ｓｗｉｔｃｈ執行完ａ的值為４。 ｄｅｆａｕｌｔ不管放在什麼位置，都必須是所有ｃａｓｅ均不成立的狀況下才會執行。當ａ＝３時，並不會因為ｄｅｆａｕｌｔ置於ｃａｓｅ　３的上方而先執行 ｄｅｆａｕｌｔ的敍述區。但是，若ａ不是２或３或５，比方說ａ＝７，則執行完，ａ的值為９。因為ｄｅｆａｕｌｔ的敍述區中沒有ｂｒｅａｋ，所以會繼續往下 執行。
範例：使用者輸入月份，程式回應該月份有幾天。
檔名：MonthDay.java
階段一：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　}
}
先輸入基本架構，再思考敍述區的共用及排列方式
階段二：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　switch(month){
　　　case 1:
　　　case 3:
　　　case 5:
　　　case 7:
　　　case 8:
　　　case 10:
　　　case 12:
　　　　System.out.println(month + "月 有31天");
　　　　break;
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　System.out.println(month + "月 有30天");
　　　　break;
　　　case 2:
　　　　System.out.println(month + "月 有28天");
　　　　break;
　　　default:
　　　　System.out.println("請輸入正確月份");
　　}
　}
}
階段三：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　int day=0;
　　switch(month){
　　　case 1:
　　　case 3:
　　　case 5:
　　　case 7:
　　　case 8:
　　　case 10:
　　　case 12:
　　　　day=31;
　　　　break;
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　day=30;
　　　　break;
　　　case 2:
　　　　day=28;
　　　　break;
　　　default:
　　　　System.out.println("請輸入正確月份");
　　}
　　System.out.println(month + "月 有" + day + "天");
　}
}
在此階段中，用變數ｄａｙ來儲存該月份的天數，於ｓｗｉｔｃｈ結束後再執行輸出，可以減低程式碼的複雜性。但這樣卻產生了一個邏輯錯誤「如果使用者輸入的不是正確月份，在執行完ｄｅｆａｕｌｔ的敍述區之後，ｓｗｉｔｃｈ外面的輸出敍述句也會執行」，怎麼辦呢？
階段四：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　int day=0;
　　switch(month){
　　　case 1:
　　　case 3:
　　　case 5:
　　　case 7:
　　　case 8:
　　　case 10:
　　　case 12:
　　　　day=31;
　　　　break;
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　day=30;
　　　　break;
　　　case 2:
　　　　day=28;
　　　break;
　　}
　　if(month>=1 && month <=12){
　　　System.out.println(month + "月 有" + day + "天");
　　}else{
　　　System.out.println("請輸入正確月份");
　　}
　}
}
ｓｗｉｔｃｈ外面的輸出要執行之前，先用ｉｆ來檢測月份。而ｓｗｉｔｃｈ中的ｄｅｆａｕｌｔ就可以省略了。
階段五：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　int day=31;
　　switch(month){
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　day=30;
　　　　break;
　　　case 2:
　　　　day=28;
　　　　break;
　　}
　　if(month>=1 && month <=12){
　　　System.out.println(month + "月 有" + day + "天");
　　}else{
　　　System.out.println("請輸入正確月份");
　　}
　}
}
又變短了？沒錯，程式碼自然是越短越好，短到讓別人看不懂，才能表示你的程式邏輯比別人強啊！好好加油吧！
３－２　與ｉｆ　ｅｌｓｅ　ｉｆ的差異：
ｓｗｉｔｃｈ的範例用ｉｆ　ｅｌｓｅ　ｉｆ的架構也可以寫的出來。那為什麼還要學ｓｗｉｔｃｈ呢？它們有什麼差異呢？使用時機有什麼不同嗎？
以剛才月份天數的案例來講，用ｉｆ的架構當然也可以寫出來，但條件運算式會寫得很複雜，看起來就會比較亂。但並不是ｓｗｉｔｃｈ就一定比較好 用！ｓｗｉｔｃｈ只有在一個運算式的運算結果要和多個值比對的時候，才會用得上。但是ｉｆ　ｅｌｓｅ　ｉｆ中，每個條件運算式，可以是完全沒有關係的條件 運算式。
例一：
int a=s.nextInt();
int b=s.nextInt();
if(a+b==3){
}else if(a+b==5){
}else if(a+b==8){
}
例二：
int a=s.nextInt();
int b=s.nextInt();
switch(a+b){
　case 3:
　case 5:
　case 8:
}
例三：
int a=s.nextInt();
int b=s.nextInt();
int c=s.nextInt();
if(a+b>5){
}else if(a-b<0) {
}else if(a>b*100){
}else if(c>0){
}
例一和例二是可以替代的，不過例二寫起來比較輕鬆，看起來也清爽。但例三用ｓｗｉｔｃｈ可就寫不出來了。
例三中最後一個ｉｆ的條件運算式和上面的三個ｉｆ的條件運算式完全無關，邏輯上很奇怪，但這是合法的。
什麼時候該用ｉｆ　ｅｌｓｅ　ｉｆ什麼時候該用ｓｗｉｔｃｈ好好體會一下吧！
３－３　課後練習：
練習１：修改３－２中的範例ＭｏｎｔｈＤａｙ，讓使用者除了輸入月份外也輸入年份，然後判斷輸入的年份是否為潤年，來決定２月份天數的輸出。
練習２：接收使用者輸入考試成績，然後加以評等：１００－＞Ａ＋，９０～９９－＞Ａ，８０～８９－＞Ｂ，７０～７９－＞Ｃ，６０～６９－＞Ｄ，其他分數為Ｅ。（限用ｓｗｉｔｃｈ，不可以用ｉｆ）

4. ｆｏｒ
ｆｏｒ迴圈，是讓部份程式碼重複執行的機制，這個機制主要分成兩個部份，一個是讓迴圈持續執行的條件，另一個是敍述區。
４－１　基本語法：
for([宣告或指派運算式];[條件運算式];[算術運算式]){
敍述區；
}
在ｆｏｒ的小括號中有兩個分號把小括號區隔成三個部份，用來分別輸入三種運算式，而這三種運算式都可以分別省略或全部省略，但分號不能省略。
宣告或指派運算式指的是：指派變數值的運算式，這個變數可以是已經存在的變數，或是新宣告的變數，若變數有一個以上，用‘，’隔開。例：“ｉｎｔ　 ａ＝０；”或　“ｉｎｔ　ａ＝０，ｂ＝０；”或　“ａ＝０；”但是，新宣告的變數只能在ｆｏｒ的區塊中使用，ｆｏｒ的敍述結束後，該變數就不能使用了。
條件運算式指的是：運算結果為布林值的運算式。若值為ｔｒｕｅ表示繼續迴圈的執行，若值為ｆａｌｓｅ表示停止迴圈的執行。在這個部份只能產生一個布林值， 也就是只能有一個條件運算式（可以使用邏輯運算符號）。但不能用‘，’隔開，寫一個以上的條件運算式。例：“ａ＞＝１０；”　或　“ａ＞＝１０　＆＆　 ｂ＞＝１０；”是合法的。但是：“ａ＞＝０，ｂ＞＝２０；”是不合法的。
算術運算式指的是：變數值的運算，用‘，’隔開可以寫一個以上的算術運算式。例：“ａ＋＋”　或　“ａ＋＝２”　或　“ａ＋＋，ｂ＋＝２”。不過，此部份只要不是宣告運算式，其實都是可以寫的，等日後基本寫法學會了再練習看看吧！
敍述區的敍述句如果只有一句，大括號可以省略。換個角度看，如果沒有大括號，那迴圈的敍述區範圍，僅止於小括號後面所遇到的第一個分號。

ｆｏｒ迴圈執行流程示意
ｆｏｒ（Ａ；Ｂ；Ｃ）｛ Ｄ； ｝	第一次迴圈
	Ａ－＞Ｂ（若Ｂ的值為ｔｒｕｅ）－＞Ｄ－＞Ｃ
	第一次以後之迴圈
	Ｂ（若Ｂ的值為ｔｒｕｅ）－＞Ｄ－＞Ｃ－＞Ｂ（一直循還到Ｂ的值為ｆａｌｓｅ時，結束迴圈）

例一：
for(int a=1;a<=10;a++){
　System.out.println(“Hello!”);
}
第一次執行時宣告變數ａ，並指派其值為１。條件ａ＜＝１０成立，執行輸出“Ｈｅｌｌｏ！”，再執行ａ＋＋。第一次迴圈執行完ａ的值為２。
第二次執行時，直接運算條件運算式，此時ａ的值是２，條件ａ＜＝１０成立，執行輸出“Ｈｅｌｌｏ！”，再執行ａ＋＋。第二次迴圈執行完ａ的值為３。
第十次執行，此時ａ的值為１０，條件ａ＜＝１０成立，執行輸出”Ｈｅｌｌｏ！“，再執行ａ＋＋。第十次迴圈執行完ａ的值為１１。
第十一次執行，此時ａ的值為１１，條件ａ＜＝１０不成立，迴圈結束。敍述區總共執行十次。
在此例中，如果小括號中的指派運算式改成：“ｉｎｔ　ａ＝０；”。則此迴圈的敍述區，將執行１１次。如果條件運算式改成：“ａ＜１０；”則此迴圈的敍述 區，將執行９次。如果將算術運算式改成：“ａ＋＝２”，則此迴圈的敍述區，將執行５次。所以三個運算式中的任何一個運算式，都會改變迴圈的次數，請多加練 習。
例二：
for(int a=10;a>=1;a--){
　System.out.println(“Hello!”);
}
此例迴圈的敍述區會執行十次，撰寫時請注意條件運算式與算術運算式的搭配。如果把此例中的算數運算式改成：“ａ＋＋”。因為條件ａ＞＝１將會永遠成立，此迴圈會執行無數次，我們稱之為無窮迴圈。
例三：
int a;
for(a=1;a<=10;a++){
　System.out.println(“Hello!”);
}
System.out.println(a);
此例中的指派運算式，所指派的變數ａ是ｆｏｒ執行前就已經存在的變數，這樣的變數在ｆｏｒ結束後，一樣可以使用。但若不是必要，並不建議把迴圈要用的變 數，宣告在迴圈外面，因為這個變數會佔用記憶體空間，直到方法結束。要注意的是：「不可以重複宣告」。以此例而言，若把指派運算式改成：“ｉｎｔ　 ａ＝１；”，會造成編譯錯誤。
例四：
int a=1;
for(;a<=10;a++){
　System.out.println(“Hello!“);
}
同例三，使用已存在之變數。並省略指派運算式。要注意的是：「變數宣告後，是否有指派」。如果把宣告句改成：“ｉｎｔ　ａ；”，則因為ａ沒有指派值，會造成編譯錯誤。
例五：
for(int a=1;;a++){
　if(a>10){
　　break;
　}
　System.out.println(“Hello!”);
}
此例中省略了條件運算式，但必須搭配ｉｆ及ｂｒｅａｋ的使用，來明確中斷迴圈的時機，否則會編譯錯誤。
例六：
for(int a=1;a<=10;){
　System.out.println(“Hello!”);
　a++;
}
此例中把算術運算式，寫到敍述區中是可以的。
例七：
for(int a=1;a<=10;)
　a++;
　System.out.println(“Hello!”);
此例只會輸入一次“Ｈｅｌｌｏ！”，因為省略大括號，所以迴圈的敍述區只包含一個敍述句，就是：“ａ＋＋；”。而“Ｈｅｌｌｏ”是在迴圈結束後才列印的。
例八：
for(int a=1;a<=10;a++);
{
　System.out.println(“Hello”);
}
此例執行結果為列印一次”Ｈｅｌｌｏ“。在Ｊａｖａ中，用大括號來建立任意的敍述區是合法的。以此例而言，因為ｆｏｒ的小括號後面加上分號，表示迴圈到此結束。所以接下來的大括號變成是獨立的敍述區塊而不屬於ｆｏｒ。
例九：
for(int a=1;a<=10;System.out.println(a++)){}
for(int a=10;a>=1;System.out.println(a--));
這兩句都是合法的，第一句會從１列印到１０，第二句會從１０列印到１。並不建議現在大家就使用這種寫法，但你可以先試試看，免得以後看到別人這樣寫被嚇呆了。
４－２　學習重點：
在正式寫迴圈範例時，初學者一定要注意，迴圈的重點是在敍述區，而不是迴圈的次數。寫迴圈之前要先分析清楚，到底是那些敍述句要重複執行，先把敍述區寫 好，外面再加上ｆｏｒ來控制次數。換個角度就是：「如果只執行一次的話，你程式碼會怎麼寫，就先把它寫出來，外面再加上ｆｏｒ就對了」。
範例：使用者輸入兩個整數，程式運算這兩個整數之間（含這兩個整數），的所有數字的總和。
檔名：Total.java
階段一：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　int total=0;
　　for(int a=1;a<=10;a++){
　　　total+=1;
　　}
　　System.out.println("總和為:" + total);
　}
}
此階段先運算１加１０次之總和，初學者可以先看看，如果把ｆｏｒ拿掉，只剩下“ｔｏｔａｌ＝ｔｏｔａｌ＋１；”是不是就是“ｔｏｔａｌ＋１”加一次，外面加上迴圈１０次的ｆｏｒ，就是“ｔｏｔａｌ＋１”加１０次。體會一下，迴圈是從裏面寫到外面。
階段二：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　int total=0;
　　for(int a=1;a<=10;a++){
　　　total+= a;
　　}
　　System.out.println(“總和為:” + total);
　}
}
將“ｔｏｔａｌ＝ｔｏｔａｌ＋１；”改成“ｔｏｔａｌ＝ｔｏｔａｌ＋ａ；”，就變成從１加到１０，執行結果為５５。
階段三：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　for(int a=firstNumber;a<=secondNumber;a++){
　　　total+= a;
　　}
　　System.out.println("總和為:" + total);
　}
}
接收兩個整數後，分別取代迴圈計數值ａ的起始值及結束值，結果就是從ｆｉｒｓｔＮｕｍｂｅｒ至ｓｅｃｏｎｄＮｕｍｂｅｒ之間數字的總和了。但是，這樣的程 式碼是有Ｂｕｇ的。試試看：如果ｆｉｒｓｔＮｕｍｂｅｒ的值大於ｓｅｃｏｎｄＮｕｍｅｒ的值時，這支程式會怎樣？怎麼辦呢？
階段四：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　if(firstNumber<secondNumber){
　　　for(int a=firstNumber;a<=secondNumber;a++){
　　　　total+= a;
　　　}
　　}else{
　　　for(int a=secondNumber;a<=firstNumber;a++){
　　　　total+= a;
　　　}
　　}
　　System.out.println("總和為:" + total);
　}
}
這個時候，可以先用ｉｆ判斷兩個數字的大小，再決定執行那一個迴圈。想想看：還有沒有其他的方法呢？
階段五：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　if(firstNumber>secondNumber){
　　　int temp=firstNumber;
　　　firstNumber=secondNumber;
　　　secondNumber=temp;
　　}
　　for(int a=firstNumber;a<=secondNumber;a++){
　　　total+= a;
　　}
　　System.out.println("總和為:" + total);
　}
}
在進入迴圈之前，如果ｓｅｃｏｎｄＮｕｍｂｅｒ的值大於ｆｉｒｓｔＮｕｍｂｅｒ，就把兩個變數的值對調。再想想：還有沒有其他方法呢？
階段六：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　for(int a=(firstNumber<secondNumber?firstNumber:secondNumber);
　　　　　　a<=(firstNumber>secondNumber?firstNumber:secondNumber);
　　　　　　a++){
　　　total+= a;
　　}
　　System.out.println("總和為:" + total);
　}
}
和階段五比較起來，這裏的程式碼反而複雜，並不建議這樣使用。這裏只是示範條件運算符號（？：）的使用方式。指派運算式中的ａ會等於兩個整數中的較小值，條件運算式中的ａ會小於等於兩個整數中的較大值。
階段七：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　for(int a=(firstNumber<secondNumber?firstNumber:secondNumber);
　　　　　a<=(firstNumber>secondNumber?firstNumber:secondNumber);
　　　　　total+=a++);
　　System.out.println("總和為:" + total);
　}
}
當你可以寫成這樣的時候，別人想要看懂你的程式碼，就有點難度了，加油吧！
範例：使用者輸入整數，程式判斷該整數是否為質數。（無法均分為任意等份的數字；除了１與數字本身，任何數字都無法整除的數字）
檔名：Prime.java
階段一：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　if(value%2==0){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
我們先假設只要被２整除就不是質數來寫出上面的程式碼。然後再來思考，除了２以外，我們還要繼續除以３、４‧‧‧一直到ｖａｌｕｅ－１為止，都沒有被整除才是質數，而這些運算式能夠寫在ｉｆ的小括號中嗎？當然不行，那要寫在那裏呢？
階段二：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<value;a++){
　　　if(value%a==0){
　　　　prime=false;
　　　}
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
先宣告一個布林值變數ｐｒｉｍｅ＝ｔｒｕｅ，而迴圈中只要２～ｖａｌｕｅ－１中的任何一個數字整除ｖａｌｕｅ，ｐｒｉｍｅ的值會變成ｆａｌｓｅ，表示 ｖａｌｕｅ不是質數，最後再把ｐｒｉｍｅ交給ｉｆ判斷後輸出。值得思考的是，迴圈中的ｉｆ如果加上ｅｌｓｅ　ｐｒｉｍｅ＝ｔｒｕｅ的話，結果會變怎樣呢？ 自己想想看吧！
而程式到這裏可以說已經完成，但並不是一支好程式。因為執行了太多不必要的運算。比如說：若要檢測１００是否為質數，在第一次迴圈時，１００就會被２整除，那剩下的９７次迴圈，不是就沒有必要了嗎？
階段三：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<value;a++){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
此階段中，只多了一行敍述句：“ｂｒｅａｋ；”。表示只要有任何一個數字整除ｖａｌｕｅ，就代表ｖａｌｕｅ不是質數，迴圈便中斷，不必再執行。也就是說： 「如果檢測的數字是１００，那麼此迴圈執行一次便會結束，而不必執行９８次」。接下來，我們再想想看，有沒有必要除以２的倍數？
階段四：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<value;){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　　if(a==2)
　　　　a++;
　　　else
　　　　a+=2;
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
當ａ的值是２的時候，執行“ａ＋＋；”，當ａ的值是３以後執行“ａ＋＝２”，那麼ａ的值就會以３，５，７‧‧‧的奇數往下跑，也就節省了一半的運算次數。 以此類推，那如果也不要除以３或５或７的倍數，不是省更多嗎？當然沒錯，不過寫起來就複雜了，本範例只是提醒大家要減少不必要的運算，不要想太多。
階段五：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<=value/2;){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　　if(a==2)
　　　　a++;
　　　else
　　　　a+=2;
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
此階段的變化只有：把迴圈中的條件運算式ａ＜ｖａｌｕｅ改成ａ<=ｖａｌｕｅ／２。因為數字是不可能被大於它一半的數字整除的。所以又省了一半的運算。但事實上更節省的方式是“ａ＜=ｖａｌｕｅ開根號的值”，不過那必須用到我們還沒教的方法，所以就不講了。有興趣的同學，自己試試看。
階段六：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<=value/2;a+=(a==2?1:2)){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
節省完不必要的運算後，接下來便是程式碼的精簡了。利用條件運算符號（？：）來取代ｉｆ的判斷。這樣的程式碼看起來，是不是比較有深度了呢？
階段七：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　int a=2;
　　for(;a<=value/2;a+=(a==2?1:2)){
　　　if(value%a==0){
　　　　break;
　　　}
　　}
　　if(a<=value/2){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}　
　}
}
使用ｂｒｅａｋ之後，程式碼也可以改成這樣。ａ宣告在迴圈之前，是因為迴圈之後，下面的ｉｆ還會用到。而ｉｆ中的“ａ＜=ｖａｌｕｅ／２”是什麼意思呢？我們必須思考迴圈結束時，ａ的值的變化。
若迴圈不是因為ｂｒｅａｋ而中斷，而是因為“ａ＜=ｖａｌｕｅ／２”不成立才結束，表示說：「沒有任何數字整除ｖｌａｕｅ」。也就表示說「迴圈結束時，ａ的值是大於ｖａｌｕｅ／２的」。所以在迴圈下面的“ｉｆ（ａ＜=ｖａｌｕｅ／２）”便不會成立，於是輸出“ｖａｌｕｅ是質數”。
相對的，若迴圈是因為ｂｒｅａｋ而結束（ｖａｌｕｅ已被整除），表示ａ的值還沒有跑到ｖａｌｕｅ／２的時候，迴圈就結束了。所以迴圈下面的“ｉｆ（ａ＜=ｖａｌｕｅ／２）”便成立，然後輸出“ｖａｌｕｅ不是質數”。
如果讀者對上述文字看起來有看沒有懂，請用實際數字代進去（例如：７、８），然後用筆自行運算看看，可以協助理解。
４－３　巢狀迴圈：
巢狀迴圈是指迴圈之中還有迴圈。但這是文字上的說明，真正在撰寫時，還是建議從裏面（內迴圈）寫到外面（外迴圈）。就像在寫一般迴圈時，敍述區先寫一樣，巢狀迴圈就是某一個迴圈要重複執行，所以只要內迴圈先寫好，外圍再加上迴圈就完成了。
範例：顯示三角形數字矩陣。
１
１２
１２３
１２３４
１２３４５
檔名：NumberMatrix.java
階段一：
public class NumberMatrix{
　public static void main(String[] args){
　　System.out.print("1");
　}
}
分析問題，找出最基礎的敍述。
階段二：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int a=1;a<=5;a++){
　　　System.out.print("1");
　　}
　}
}
顯示五個１。
階段三：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int a=1;a<=5;a++){
　　　System.out.print(a);
　　}
　}
}
顯示１２３４５。
階段四：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int b=1;b<=5;b++){
　　　for(int a=1;a<=5;a++){
　　　　System.out.print(a);
　　　}
　　　System.out.println();
　　}
　}
}
在剛才顯示１２３４５的迴圈外圍，再加上一層執行五次的迴圈，結果會顯示五列１２３４５。每列印完一列，要記得換行。
階段五：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int b=1;b<=5;b++){
　　　for(int a=1;a<=b;a++){
　　　　System.out.print(a);
　　　}
　　　System.out.println();
　　}
　}
}
內迴圈的執行次數不再固定執行五次，改為依照外迴圈的變數值改變。此即為解答。
再強調一次，初學者先學會由內往外寫，熟練了再由外往內寫。
接下來讀者可以先想想看如果要寫成這樣，你會怎麼寫？
５
５４
５４３
５４３２
５４３２１
階段六：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int b=1;b<=5;b++){
　　　for(int a=1;a<=b;a++){
　　　　System.out.print(6-a);
　　　}
　　　System.out.println();
　　}
　}
}
沒錯，做一點小小的改變就可以了，大家可以再多做些變化，來完全掌握計數值的運用。
範例：九九乘法表。
１＊１＝１　１＊２＝２　１＊３＝３　………　１＊９＝９
２＊１＝２　………
……………
……………
９＊１＝９　９＊２＝１８　………………………９＊９＝８１　
檔名：NineNine.java
階段一：
public class NineNine{
　public static void main(String[] args){
　　System.out.print("1*1=1");
　}
}
先列印最基礎敍述句。
階段二：
public class NineNine{
　public static void main(String[] args){
　　for(int a=1;a<=9;a++){
　　　System.out.print("1*1=1\t");
　　}
　}
}
列印九次“１＊１＝１”，‘＼ｔ’代表Ｔａｂ。
階段三：
public class NineNine{
　public static void main(String[] args){
　　for(int a=1;a<=9;a++){
　　　System.out.print("1*" + a + "=" + 1*a + "\t");
　　}
　}
}
用迴圈的變數ａ，來取代輸出文字中後面的１，就會變成１＊１～１＊９。
階段四：
public class NineNine{
　public static void main(String[] args){
　　for(int b=1;b<=9;b++){
　　　for(int a=1;a<=9;a++){
　　　　System.out.print("1*" + a + "=" + 1*a + "\t");
　　　}
　　　System.out.println();
　　}
　}
}
列印九行１＊１～１＊９。
階段五：
public class NineNine{
　public static void main(String[] args){
　　for(int b=1;b<=9;b++){
　　　for(int a=1;a<=9;a++){
　　　　System.out.print(b + "*" + a + "=" + b*a + "\t");
　　　}
　　　System.out.println();
　　}
　}
}
把外迴圈的變數ｂ，取代輸出文字的１。這樣九九乘法表就完成了。從裏面開始寫，是不是很輕鬆呢？
４－４　課後練習：
練習１：顯示本月份之月曆。例：
２００６　年　１１　月
日　　一　　二　　三　　四　　五　　六
　　　　　　　　　　１　　２　　３　　４
　５　　６　　７　　８　　９　１０　１１
１２　１３　１４　１５　１６　１７　１８
１９　２０　２１　２２　２３　２４　２５
２６　２７　２８　２９　３０　
練習２：將練習１改成，讓使用者指定欲顯示之月份。（有空再練習）
練習３：將練習２改成，讓使用者指定欲顯示之年份及月份。（非常有空再練習）
練習４：列印出２到１００的所有質數。
練習５：接受使用者輸入任意兩個整數，程式回應這兩整數的最小公倍數。

5. ｗｈｉｌｅ
５－１　基本語法：
while(布林值)｛
　敍述區；
｝
迴圈的第二種寫法。小括號中的布林值指的是：「可以產生布林值的運算式，或布林值型別的變數」。另外也可以直接輸入布林值ｔｒｕｅ，但不可以直接輸入布林值ｆａｌｓｅ。
這種寫法在使用時機上和ｆｏｒ是有很大的差異性的。ｆｏｒ是以次數為主，也就是敍述區的執行由變數值及條件式控制；而ｗｈｉｌｅ是單純以條件運算式來控制。
雖然兩種寫法可以相互替換（ｆｏｒ能寫的，用ｗｈｉｌｅ也能寫，反之亦然）。但在這裏還是希望讀者能夠在不同的時機，使用不同的寫法。而初學者應該先練好ｆｏｒ之後，再用相同範例來練習ｗｈｉｌｅ的寫法。
例一：
int a=1;
while(a<=10){
　System.out.println(“Hello”);
　a++;
}
執行結果會列印十次“Ｈｅｌｌｏ”，但像這樣的案例，用ｆｏｒ的寫法是比較適當的。但是因為現在讀者學會的方法並不多，還沒有辦法單純用條件運算式來控制 迴圈，所以只好用次數的案例來先讓讀者知道ｗｈｉｌｅ的基本架構。ｗｈｉｌｅ的使用時機，還是應該用在不確定次數的案例比較合適。
範例：持續接受使用者輸入文字，並將之列印在螢幕上，直到使用者輸入ＧａｍｅＯｖｅｒ才結束程式。
檔名：InputString.java
import java.util.*;
public class InputString{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.println("請輸入任意文字後按Enter,欲結束請輸入　GameOver");
　　String value=null;
　　while(!((value=s.next()).equals("GameOver"))){
　　　System.out.println(value);
　　}
　}
}
本範例用了讀者目前尚未學到的指令及方法，您不必把它們弄懂，只要知道「ｗｈｉｌｅ基本上是運用在這類執行次數不一定，而以條件運算式判斷為主的案例上就可以了」。

6. ｄｏ　ｗｈｉｌｅ
６－１　基本語法：
do{
敍述區；
}while(布林值);
迴圈的第三種寫法，寫法和ｗｈｉｌｅ很像，但它的ｗｈｉｌｅ放在最後面，而且必須以‘；’結束。這種寫法和ｆｏｒ及ｗｈｉｌｅ有一個很大的差異點：「至少 執行一次」。ｆｏｒ及ｗｈｉｌｅ的迴圈如果一開始條件就不成立的話，迴圈內的敍述區是完全不執行。但這種寫法，因為是執行完敍述區後，再判斷要不要執行下 一次，所以即使條件式不成立，也已經執行一次了。使用時機就是：「撰寫至少要執行一次的迴圈」。
例一：
for(int a=1;a<0;a++){
　System.out.println(“Hello!”);
}
int b=1;
while(b<0){
　System.out.println(“Hello!”);
　b++;
}
int c=1;
do{
　System.out.println(“Hello!”);
　c++;
}while(c<0);
此例中的ｆｏｒ及ｗｈｉｌｅ中的敍述區都不會執行。會ｄｏ　ｗｈｉｌｅ會列印一次“Ｈｅｌｌｏ”。
６－２　課後練習：
練習１：提款機登入程式＝＞讓使用者輸入四個數字的密碼，若符合你預設的數字（比如：１２３４），則輸出“歡迎光臨大笨銀行”，否則輸出“密碼錯誤，請重新輸入”。但是，此程式最多接受三次的輸入。（使用迴圈，並請分析應該使用那一種寫法）
練習２：猜數字遊戲＝＞接受使用者先指定數字範圍（１００以上），程式便會產生一個該範圍內之亂數。並依照不同的數字範圍來設定使用者猜數字的次數。使用者每次猜完都必須提示太高或太低，最後依照使用者猜測的次數給予評語。
ＰＳ‧亂數：Ｍａｔｈ‧ｒａｎｄｏｍ（）。此敍述的運算結果為大於等於０小於１的亂數。
　
7. ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ，設定標籤
７－１　ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ：
ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是中斷迴圈的指令。不同的是：ｂｒｅａｋ是結束整個迴圈的執行；ｃｏｎｔｉｎｕｅ是中斷這一次的敍述區的執行。但是，兩者都必須搭配判斷敍述使用。
例一：
for(int a=1;a<=10;a++){
　if(a%3==0){
　　break;
　}
　System.out.print(a + “,”);
}
此例會顯示１，２。當a的值為3時，迴圈結束，而ｉｆ敍述外面的輸出敍述句，便不會執行。
例二：
for(int a=1;a<=10;a++){
　if(a%3==0){
　　continue;
　}
　System.out.println(a + “,”);
}
此例會顯示１，２，４，５，７，８，１０。當ａ的值為３的倍數時，ｉｆ中的ｃｏｎｔｉｎｕｅ會中斷該次敍述區的執行，所以ｉｆ敍述後面的輸出敍述句，便不會執行，而直接進入下一輪的迴圈。
７－２　標籤：
ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是用來中斷撰寫該指令的迴圈，但在巢狀迴圈中，如果要中斷的對象是外圍迴圈時，便必須搭配標籤使用。而標籤必須宣告在迴圈的上方。
標籤的名稱和變數一樣，可以自訂。
例一：
int s=1;
outer:
for(int a=1;a<=10;a++){
　while(s<=10){
　　System.out.println(“Hello!”);
　　s++;
　　break outer;
　}
　System.out.println(“World”);
}
此例執行的結果只會列印一次“Ｈｅｌｌｏ”，列印完ｂｒｅａｋ的對象是外圍的ｆｏｒ迴圈，所以“Ｗｏｒｌｄ”連一次都沒有列印。另外要注意的是：“ｉｎｔ　ｓ＝１；”的宣告不可以放在標籤“ｏｕｔｅｒ：”的宣告之後，因為標籤“ｏｕｔｅｒ：”的後面，必須是迴圈敍述。
例二：
int s=1;
outer:
for(int a=1;a<=10;a++){
　while(s<=10){
　　System.out.println(“Hello!”);
　　s++;
　　continue outer;
　}
　System.out.println(“World”);
}
此例執行的結果會列印十次“Ｈｅｌｌｏ”，但因為每次列印完ｃｏｎｔｉｎｕｅ的對象是外圍的ｆｏｒ迴圈，所以“Ｗｏｒｌｄ”還是連一次都沒有列印。

8. ｆｏｒ　ｅａｃｈ
在Ｊａｖａ　５‧０中，新增的一種迴圈的寫法，但這種寫法是針對集合物件，而且是要運算集合物件中的每一個元素時才適用。因為我們還沒有學會集合物件，所有大家只要先知道語法架構，實務用法將在後續章節中介紹。
for(資料型別 變數:集合物件){
　敍述區;
}
語法中的變數，將會逐一代表集合物件中的每一個元素，所以宣告變數的資料型別，必須和集合物件中的元素的資料型別吻合。
例：
int[] a={8,55,11,4,6};
for(int b:a){
　System.out.println(b);
}
變數ａ代表一個陣列物件，變數ｂ將代表陣列物件中的每一個元素。此例將會列印ａ陣列中的每一個元素。
9. 認證重點整理
９－３　ｓｗｉｔｃｈ

• 财 ｓｗｉｔｃｈ小括號中的運算式的型別，必須是ｉｎｔ，ｂｙｔｅ，ｓｈｏｒｔ型別的整數值，當然包含可以自動轉換為ｉｎｔ型別的ｃｈａｒ。也就是說，它可以是一個會產生整數值的運算式或變數（不包含ｌｏｎｇ型別）。
• 财 區塊中的ｃａｓｅ沒有個數的限制，而且不必依照值的大小排列。
• 财 ｃａｓｅ後方的值一樣必須是整數，且其值不可以超過運算式的最大或最小值的範圍。
• 财 區塊中所有ｃａｓｅ的值不可以重複。
• 财 因為ｃａｓｅ後面的值必須在編譯時期就確認，所以不可以是變數。
• 财 ｃａｓｅ後面只能放數值或字元或在宣告時立刻指派的常數。
• 财 當ｓｗｉｔｃｈ中某一個ｃａｓｅ成立後，便會執行該ｃａｓｅ的敍述區，直到遇到ｂｒｅａｋ或這個ｓｗｉｔｃｈ的末端。
• 财 ｄｅｆａｕｌｔ可以省略，也不一定要置於最末端。只不過若沒有置於最末端，就必須注意有沒有必要加ｂｒｅａｋ。
• 财 ｄｅｆａｕｌｔ的敍述區，必須是在所有ｃａｓｅ均不成立的狀況下，才會執行。即使ｃａｓｅ置於ｄｅｆａｕｌｔ下面，也不例外。

９－７　ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ，設定標籤

• 财 ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是中斷迴圈的指令，不同的是：ｂｒｅａｋ是結束整個迴圈的執行；ｃｏｎｔｉｎｕｅ是中斷這一次的敍述區的執行。但是兩者都必須搭配判斷句使用。
• 财 ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是用來中斷撰寫該指令的迴圈。但在巢狀迴圈中，如果要中斷的對象是外圍迴圈時，便必須搭配標籤使用。而標籤必須宣告在迴圈的上方。

９－８　ｆｏｒ　ｅａｃｈ

• 财 小括號中‘：’左側為變數宣告，不必指派值；右側為物件名稱（參考變數）。

流程控制
　

作者：　許裕永

程式碼執行的流程，預設是由左而右，由上而下，逐敍述句執行。若設計師希望能指定部份的程式碼，在某些狀況下不要執行，或指定部份的程式碼，在某些狀況下能重複執行。這時就需要針對敍述句的運算流程加以控制，本章介紹的便是控制程式碼執行流程的語法。
而流程的控制，不外乎判斷與迴圈。判斷指的是：「在條件成立或不成立的情況下執行指定的敍述句」；迴圈指的是：「在條件成立的情況下，重複執行指定的敍述 句」。本章介紹的語法雖多，但都是判斷與迴圈的各種變化。每一種語法都相當重要，初學者應該把重點放在本章，多加練習。這是程式設計的基礎，把底打好，後 面的章節學起來才會比較輕鬆。
玩積木，除了要知道每一塊積木的樣式，更重要的是：「了解各種不同樣式的積木，組合起來所產生的變化」。能掌握的變化越多，越能作出別人作不出來的成品。 程式語言就像積木，每個人使用的元件（學會的基礎語法）都一樣。但能否用一塊塊的小元件，堆積出一件傲人的作品。靠的就是：「了解每一個元件的變化及應用 方式」。而這種能力不是看別人的作品就能看來的。即使看懂了，折開後也不見得能再組回來。要能深入了解並完全應用這些基礎語法，只有一個方式：不斷的練， 重複的練。記住，不光是要學會，還要熟練。
1. ｉｆ　ｅｌｓｅ
１－１　基本語法：
if(布林值){
　敍述區Ａ；
}[else{
　敍述區Ｂ；
}]
若布林值的值為ｔｒｕｅ就執行敍述區Ａ，若布林值的值為ｆａｌｓｅ就執行敍述區Ｂ。中括號代表可以省略，省略後的意思為：若布林值的值為ｔｒｕｅ就執行敍述區Ａ，若布林值的值為ｆａｌｓｅ就不執行敍述區Ａ。
布林值指的是：「運算結果為ｔｒｕｅ或ｆａｌｓｅ的運算式」。也就是用條件運算符號及邏輯運算符號組成的運算式。另外，也可以是布林值型態的變數，或是運算結果為布林值的方法。
敍述區Ａ或Ｂ指的是敍述句的集合，置於區塊（大括號）中，若敍述句只有一句，大括號可以省略。但初學者在未能完全掌握程式流程之前，並不建議省略。
例一：
if(5<3){
　System.out.println(“Hello!”);
}
此例不執行任何輸出
例二：
if(5<3){
　System.out.println(“Hello“);
}else{
　System.out.println(“World”);
}
此例輸出Ｗｏｒｌｄ
例三：
if(5<3)
　System.out.println(“Hello”);
System.out.println(“World”);
此例輸出Ｗｏｒｌｄ。在Ｊａｖａ中，所有的敍述句以分號結束，除非用大括號集合起來。本例中的ｉｆ敍述並沒有使用大括號，所以ｉｆ的敍述在第一個分號出現時便結束了。第三行敍述句不屬於ｉｆ敍述的一部份。
例四：
if(5<3)
　System.out.println(“Hello”);
　System.out.println(“World”);
else
　System.out.println(“Java”);
此例編譯錯誤，因為ｉｆ敍述在第二行便已經結束，而ｅｌｓｅ不可以單獨存在。
１－２　學習重點：
學習判斷要先注意：重點不是敍述區Ａ或Ｂ中的敍述句，而是條件運算式的分析與建立。條件成立或不成立時要執行那些敍述句，應該是早就規劃好的；重點是條件運算式要如何寫才能做出正確的判斷。
範例：接收使用者輸入任意整數，程式回應使用者輸入的數字為奇數或偶數。
檔名： IfElseDemo.java
階段一：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以重複接收執行時期的輸入
　}
}
在此階段先輸入程式基本架構，並做好接收使用者輸入的機制，此機制後續的範例時常會用到。不懂的地方，可以先背起來，後續章節才會介紹。
階段二：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以接收執行時期的輸入
　　System.out.print(“請輸入任意一個整數-->”);
　　int value=s.nextInt();
　}
}
此階段為提示輸入，及接收輸入，並將使用者輸入之數字儲存於變數ｖａｌｕｅ。指派運算符號右側的ｓ‧ｎｅｘｔＩｎｔ（）執行時，程式會暫停執行，直到使用者輸入Ｅｎｔｅｒ後，程式再繼續執行。
階段三：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以接收執行時期的輸入
　　System.out.print(“請輸入任意一個整數-->”);
　　int value=s.nextInt();
　　if(){
　　　System.out.println(value + “為奇數”);

}else{
　System.out.println(value + “為偶數”)
　　}
　}
}
在條件運算式尚未建立前，可以先把要執行的敍述區完成，這樣也可以增加思考條件運算式的靈感。
階段四：
import java.util.*; //引入包含類別Scanner的package
public class IfElseDemo{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　//參考變數s可以接收執行時期的輸入
　　System.out.print(“請輸入任意一個整數-->”);
　　int value=s.nextInt();
　　if(value%2==1){
　　　System.out.println(value + “為奇數”);
　　}else{
　　　System.out.println(value + “為偶數”);
　　}
　}
}
條件運算式為：運算ｖａｌｕｅ除以２的餘數。若餘數等於１，此條件運算式的值便為ｔｒｕｅ；若餘數不等於１，此條件運算式的值便為ｆａｌｓｅ。
１－３　二個以上的敍述區：
一個條件運算式可以控制一個敍述區，搭配ｅｌｓｅ最多控制兩個敍述區。若有兩個以上的敍述區呢？比方說，剛才奇數偶數的範例若要考慮０呢？０不是奇數也不是偶數，所以程式碼多了一個輸出的變化：「必須告訴使用者輸入的是０」。那麼這一個敍述應該加在那裏呢？
換個角度來看就是：「兩個敍述區至少須要一個條件運算式，三個敍述區至少須要二個條件運算式，四個敍述區至少須要三個條件運算式‧‧‧以此類推」。而如何排列這些條件運算式，就是讀者必須多加練習的重點了。
關鍵：由外往內寫。先寫外圍條件，再決定內圍條件應該附屬於外圍條件的成立區塊或不成立區塊。
例一：
if(value%2==1){
　System.out.println(value + “為奇數”);
}else{
　if(value==0){
　　System.out.println(value + “為０”);
　}else{
　　System.out.println(value + “為偶數”);
　}
}
在此例中若ｖａｌｕｅ的值為０，則ｖａｌｕｅ除以２的餘數為０，所以ｖｌｕｅ是否為０的判斷，要依附於ｅｌｓｅ。
例二：
if(value%2==０){
　if(value==0){
　　System.out.println(value + “為０”);
　}else{
　　System.out.println(value + “為偶數”);
　}
}else{
　System.out.println(value + “為奇數”);
}
在此例中，外圍ｉｆ的條件運算式，改為判斷ｖａｌｕｅ除以２的餘數是否為０，所以ｖａｌｕｅ是否為０的判斷依附於ｉｆ。
例三：
if(value==０){
　System.out.println(value + “為０”);
}else{
　if(value%2==１){
　　System.out.println(value + “為奇數”);
　}else{
　　System.out.println(value + “為偶數”);
　}
}
在此例中，ｉｆ的條件運算式改成ｖａｌｕｅ是否為０的判斷，只有在ｖａｌｕｅ不是０的時才判斷餘數。
例四：
if(value==０){
　System.out.println(value + “為０”);
}else if(value%2==１){
　System.out.println(value + “為奇數”);
}else{
　System.out.println(value + “為偶數”);
}
在此例中，我們把原先寫在ｅｌｓｅ區塊中的判斷，改寫到ｅｌｓｅ後面。形成了：如果條件１成立則‧‧‧，否則如果條件２成立則‧‧‧，否則‧‧‧的判斷。 而條件的判斷可以沒有次數限制的以ｅｌｓｅ　ｉｆ的方式持續加上去，這是為了避免條件判斷比較多的時候，寫成巢狀判斷會過於複雜，影響程式碼可讀性的寫 法。
例五：
if(value%2==０){
　System.out.println(value + “為偶數”);
}else if(value%2==１){
　System.out.println(value + “為奇數”);
}else{
　System.out.println(value + “為0”);
}
在此例中，語法架構和例四是一樣的，但條件運算式的排列不一樣。執行的結果就會產生誤差。ｖａｌｕｅ的值若為偶數或奇數都可以得到正確的結果，但若ｖａｌｕｅ的值為０時，在第一個ｉｆ判斷時就會成立，所以列印結果是：「０是偶數」。這種狀況，我們就稱之為「邏輯錯誤」。
透過這五個案例，希望可以讓初學者體會到，前面關於積木的說法。進而不斷練習不同的組合方式，來達成各種不同或相同的結果。當你對巢狀判斷感到迷惑時，謹 記「是在ｉｆ或ｅｌｓｅ的區塊中，視程式的需要來寫內層的ｉｆ；而不是在ｉｆ的外層寫ｉｆ」。當然，更重要的是：「先分析由那一個條件放在最外層」。
範例：使用者輸入年份，程式回應該年是否為潤年（四的倍數年為潤年，一百的倍數年不是潤年。四百的倍數年也是潤年）。
檔名：IfElseDemo2.java
階段一：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(){
　　　System.out.println(year + "是潤年");
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
先寫好輸入及輸出之基本架構，接下來便能專注於條件運算式的建立。
階段二：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　System.out.println(year + "是潤年");
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
再次強調：由外而內，一個條件，一個條件的分開處理。比方說，接下來就可以思考ｙｅａｒ是否為１００的倍數年？應該寫在那一個區塊呢？
階段三：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　System.out.println(year + "不是潤年");
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
因為１００的倍數年可以被４整除，所以在ｉｆ的區塊中判斷ｙｅａｒ是否為１００的倍數年。
階段四：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　if(year%400==0){
　　　　　System.out.println(year + "是潤年");
　　　　}else{
　　　　　System.out.println(year + "不是潤年");
　　　　}
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
因為４００的倍數年可以被１００整除，而判斷是否為１００倍數年的條件運算式是！＝，所以４００倍數年的判斷必須寫在ｅｌｓｅ的區塊中。
階段五：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0){
　　　　System.out.println(year + "是潤年");
　　　}else if(year%400==0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　System.out.println(year + "不是潤年");
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
還記得嗎？ｅｌｓｅ區塊中的ｉｆ可以直接寫在ｅｌｓｅ後面。看起來是不是比較容易懂呢？
階段六：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0){
　　　if(year%100!=0 || year%400==0){
　　　　System.out.println(year + "是潤年");
　　　}else{
　　　　System.out.println(year + "不是潤年");
　　　}
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
如果，ｉｆ跟ｅｌｓｅ　ｉｆ的區塊中，要執行的敍述一樣的話，是可以用ｏｒ的邏輯運算符號串聯起來的。
階段七：
import java.util.*;
public class IfElseDemo2{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入西元年份-->");
　　int year=s.nextInt();
　　if(year%4==0 && year%100!=0 || year%400==0){
　　　System.out.println(year + "是潤年");
　　}else{
　　　System.out.println(year + "不是潤年");
　　}
　}
}
ｉｆ的條件運算式跟區塊中的ｉｆ的條件運算式，其實就是ａｎｄ的關係。
什麼？繞了一大圈，結果竟然一個條件運算式就搞定了！是的，但是這七個階段你一個也不能省，這是循序漸進的，每完成一個階段代表你對判斷語法，有更深一層 的認識，日後就會多一種的應用。（喂！大哥。做範例不是看著書照打，練英打嗎？把書合起來，自己寫。寫不出來，再來偷看。）
１－４　常見錯誤
撰寫ｉｆ敍述時，常見的錯誤是小括號中用了運算結果不是布林值的運算式，以及因為大括號省略而產生語意上的誤解。
例一：
int x=1;
if(x=1){
　System.out.println(x);
}
此例小括號中運算式的意思是：把１指派給變數ｘ，再以ｘ的值作為小括號的運算值。但因為ｘ不是布林值，所以會造成編譯錯誤。
例二：
boolean b=false;
if(b=true){
　System.out.println(b);
}
此例的小括號中運算式的意思是：把布林值ｔｒｕｅ指派給變數ｂ，再以ｂ的值作為小括號的運算值。而ｂ的值已經是ｔｒｕｅ，所以會列印ｔｒｕｅ。
例三：
if(5>3)
　if(5<3)
　　System.out.println(8);
　else
System.out.println(10);
此例中的ｅｌｓｅ到底是第一個ｉｆ，還是第二個ｉｆ的呢？因為省略了大括號，所以就很容易造成誤解。答案是第二個ｉｆ的。自己試試看吧！
１－５　課後練習：
練習１：提款機登入程式＝＞讓使用者輸入八個數字的晶片密碼，若符合你預設的數字（比如：１２３４５６７８），則輸出“歡迎光臨大笨銀行”，否則輸出“密碼錯誤，請重新輸入”。但是，此程式最多接受三次的輸入。（不使用迴圈）
練習２：手機開機程式＝＞讓使用者輸入兩組四個數字的密碼，一組為ＳＩＭ卡密碼，一組為手機密碼，必須兩組都對才輸出“已開機”，否則請明確告知使用者，是ＳＩＭ卡密碼錯誤，或是手機密碼錯誤，或是兩組都錯。

2. ？：（條件運算符號）
２－１　基本語法：
（條件運算式？敍述句Ａ：敍述句Ｂ）
如果條件運算式的值為ｔｒｕｅ，執行敍述句Ａ；如果條件運算式的值為ｆａｌｓｅ，執行敍述句Ｂ。 而敍述句Ａ和敍述句Ｂ都必須是：「會產生一個值的運算式」。也就是說，整個小括號代表一個值，如果條件運算式的值為ｔｒｕｅ，這個小括號就代表敍述句Ａ運算後的值；如果條件運算式的值為ｆａｌｓｅ，這個小括號就代表敍述句Ｂ運算後的值。
小括號中的敍述，並不算完整的敍述句，只能算是產生一個值的運算式，所以它不能單獨存在。它必須是某一句敍述句中的一部份。小括號可以省略，但為了程式碼的可讀性，建議不要省略。
例一：
int a=10;
int b=12;
int c=a>b?a:b;
此例ｃ的值為１２。
例二：
int a=10;
int b=12;
int c=14;
int d=a+(a>b?a:b);
此例ｄ的值為２０。
例三：
int a=10;
int b=12;
int c=14;
int d=a+a>b?a:b;
此例ｄ的值為１０，省略小括號後ａ＋ａ會先運算。
例四：
int a=10;
int b=12;
int c=14;
boolean d=c>(a>b?a:b);
此例ｄ的值為ｔｒｕｅ，但若省略小括號則會造成編譯錯誤。因為條件運算式會變成ｃ＞ａ＞ｂ？ａ：ｂ。其中的ｃ＞ａ＞ｂ編譯器是看不懂的。
例五：
int a=10;
int b=12;
int c=14;
int d=(a>b?a:(b>c?b:c));
此例ｄ的值為１４，就像巢狀的ｉｆ判斷一樣，此運算式也可以是巢狀的。
範例：接受輸入任意一個整數後，輸出該整數的絕對值。
檔名：ABS.java
import java.util.*;
public class ABS{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　System.out.println("絕對值:" + (value>0 ? value : -value));
　}
}

3. ｓｗｉｔｃｈ
３－１　基本語法：
switch(運算式){
　case 值A:
　　敍述區;
　　break;
　[case 值B:
　　敍述區;
　　break;
　default:
　　敍述區;]
}
ｓｗｉｔｃｈ是把運算式的運算結果，和ｃａｓｅ後面的值做比對。若相等的話，則執行該ｃａｓｅ的敍述區。
運算式的運算結果必須是ｉｎｔ、ｂｙｔｅ或ｓｈｏｒｔ型別的整數值，當然包含可以自動轉換為ｉｎｔ型別的ｃｈａｒ。也就是說，它可以是一個會產生整數值的運算式或變數（不包含ｌｏｎｇ型別）。
例：
int a=s.nextInt();//接收使用者輸入
switch(a){
　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(“請輸入正確數值”);
}
在此例中，程式會依照使用者的輸入，由上而下來比對所有ｃａｓｅ後面的值，若找到相等的值就執行該ｃａｓｅ的敍述區，執行完就離開ｓｗｉｔｃｈ敍述。若所有ｃａｓｅ後面的值都不相等，就會執行ｄｅｆａｕｌｔ的敍述，執行完結束ｓｗｉｔｃｈ。
區塊中的ｃａｓｅ沒有個數的限制，而且不必依照值的大小排列。
例：
switch(a){
　case 6:
　case 7:
　case ‘1’://此字元代表整數值４９（字元碼）
　case 4:
}
此例是合法的。
但ｃａｓｅ後方的值一樣必須是整數，而且其值不可以超過，ｓｗｉｔｃｈ小括號中的運算式的型別的最大或最小值的範圍。
例：
byte b=s.nextByte();
switch(b){
　case 128:
}
此例ｃａｓｅ後面的值大於ｂｙｔｅ的最大值，所以不合法。
區塊中所有ｃａｓｅ的值不可以重複。
例：
int a=s.nextInt();
switch(a){
　case 8:
　case 5:
　case 8:
}
此例ｃａｓｅ後面的值重複，所以不合法。
因為ｃａｓｅ後面的值必須在編譯時期就確認，所以不可以是變數。
例一：
int a=s.nextInt();
int b=s.nextInt();
switch(a){
　case 6:
　case 8:
　case b:
}
此例變數ｂ置於ｃａｓｅ後方，所以不合法。
例二：
int a=s.nextInt();
final int b=8;
switch(a){
　case 5:
　case 10:
　case b:
}
此例ｂ為常數（ｆｉｎａｌ），屬於編譯時期就確認的值。所以合法。
例三：
int a=s.nextInt();
final int b；
b=8;
switch(a){
　case 5:
　case 10:
　case b:
}
Ｊａｖａ中的常數為了提高實用性，在宣告句中可以不指派。但這樣子的常數不算是編譯時期就可以確認的值，所以不能放在ｃａｓｅ的後面。此例會產生編譯錯誤。
ｂｒｅａｋ用來中斷ｓｗｉｔｃｈ，當ｓｗｉｔｃｈ中某一個ｃａｓｅ成立後，便會執行該ｃａｓｅ的敍述區。若這個敍述區沒有ｂｒｅａｋ，則會繼續執行下一個 敍述區，一直到遇到ｂｒｅａｋ才會中斷。但若一直沒有遇到ｂｒｅａｋ，就會執行到這個ｓｗｉｔｃｈ的末端。此種特性，大部份會使用在需要數個ｃａｓｅ敍述 區共用的時候。
例：
int a=s.nextInt();
switch(a){
　case 3:
　case 5:
　　a++;
　case 6:
　　a++;
　　break;
}
此例中若ａ＝３或５，則ｓｗｉｔｃｈ執行完，ａ的值會分別為５或７。若ａ＝６，則ｓｗｉｔｃｈ執行完，ａ的值為７。
ｄｅｆａｕｌｔ可以省略，若沒有省略也不一定要置於最末端。只不過若沒有置於最末端，就必須注意有沒有必要加ｂｒｅａｋ。原先沒有加ｂｒｅａｋ是因為：「若置於最末端，則ｄｅｆａｕｌｔ執行完，整個ｓｗｉｔｃｈ就結束，沒必要加，而不是不能加」。
例：
int a=s.nextInt();
switch(a){
　case 2:
　　a++;
　case 5:
　　a++;
　　break;
　default:
　　a++;
　case 3:
　　a++;
}
此例中，若ａ＝２，ｓｗｉｔｃｈ執行完ａ的值為４。若ａ＝５，ｓｗｉｔｃｈ執行完ａ的值為６。請注意若ａ＝３，ｓｗｉｔｃｈ執行完ａ的值為４。 ｄｅｆａｕｌｔ不管放在什麼位置，都必須是所有ｃａｓｅ均不成立的狀況下才會執行。當ａ＝３時，並不會因為ｄｅｆａｕｌｔ置於ｃａｓｅ　３的上方而先執行 ｄｅｆａｕｌｔ的敍述區。但是，若ａ不是２或３或５，比方說ａ＝７，則執行完，ａ的值為９。因為ｄｅｆａｕｌｔ的敍述區中沒有ｂｒｅａｋ，所以會繼續往下 執行。
範例：使用者輸入月份，程式回應該月份有幾天。
檔名：MonthDay.java
階段一：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　}
}
先輸入基本架構，再思考敍述區的共用及排列方式
階段二：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　switch(month){
　　　case 1:
　　　case 3:
　　　case 5:
　　　case 7:
　　　case 8:
　　　case 10:
　　　case 12:
　　　　System.out.println(month + "月 有31天");
　　　　break;
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　System.out.println(month + "月 有30天");
　　　　break;
　　　case 2:
　　　　System.out.println(month + "月 有28天");
　　　　break;
　　　default:
　　　　System.out.println("請輸入正確月份");
　　}
　}
}
階段三：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　int day=0;
　　switch(month){
　　　case 1:
　　　case 3:
　　　case 5:
　　　case 7:
　　　case 8:
　　　case 10:
　　　case 12:
　　　　day=31;
　　　　break;
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　day=30;
　　　　break;
　　　case 2:
　　　　day=28;
　　　　break;
　　　default:
　　　　System.out.println("請輸入正確月份");
　　}
　　System.out.println(month + "月 有" + day + "天");
　}
}
在此階段中，用變數ｄａｙ來儲存該月份的天數，於ｓｗｉｔｃｈ結束後再執行輸出，可以減低程式碼的複雜性。但這樣卻產生了一個邏輯錯誤「如果使用者輸入的不是正確月份，在執行完ｄｅｆａｕｌｔ的敍述區之後，ｓｗｉｔｃｈ外面的輸出敍述句也會執行」，怎麼辦呢？
階段四：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　int day=0;
　　switch(month){
　　　case 1:
　　　case 3:
　　　case 5:
　　　case 7:
　　　case 8:
　　　case 10:
　　　case 12:
　　　　day=31;
　　　　break;
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　day=30;
　　　　break;
　　　case 2:
　　　　day=28;
　　　break;
　　}
　　if(month>=1 && month <=12){
　　　System.out.println(month + "月 有" + day + "天");
　　}else{
　　　System.out.println("請輸入正確月份");
　　}
　}
}
ｓｗｉｔｃｈ外面的輸出要執行之前，先用ｉｆ來檢測月份。而ｓｗｉｔｃｈ中的ｄｅｆａｕｌｔ就可以省略了。
階段五：
import java.util.*;
public class MonthDay{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入月份-->");
　　int month=s.nextInt();
　　int day=31;
　　switch(month){
　　　case 4:
　　　case 6:
　　　case 9:
　　　case 11:
　　　　day=30;
　　　　break;
　　　case 2:
　　　　day=28;
　　　　break;
　　}
　　if(month>=1 && month <=12){
　　　System.out.println(month + "月 有" + day + "天");
　　}else{
　　　System.out.println("請輸入正確月份");
　　}
　}
}
又變短了？沒錯，程式碼自然是越短越好，短到讓別人看不懂，才能表示你的程式邏輯比別人強啊！好好加油吧！
３－２　與ｉｆ　ｅｌｓｅ　ｉｆ的差異：
ｓｗｉｔｃｈ的範例用ｉｆ　ｅｌｓｅ　ｉｆ的架構也可以寫的出來。那為什麼還要學ｓｗｉｔｃｈ呢？它們有什麼差異呢？使用時機有什麼不同嗎？
以剛才月份天數的案例來講，用ｉｆ的架構當然也可以寫出來，但條件運算式會寫得很複雜，看起來就會比較亂。但並不是ｓｗｉｔｃｈ就一定比較好 用！ｓｗｉｔｃｈ只有在一個運算式的運算結果要和多個值比對的時候，才會用得上。但是ｉｆ　ｅｌｓｅ　ｉｆ中，每個條件運算式，可以是完全沒有關係的條件 運算式。
例一：
int a=s.nextInt();
int b=s.nextInt();
if(a+b==3){
}else if(a+b==5){
}else if(a+b==8){
}
例二：
int a=s.nextInt();
int b=s.nextInt();
switch(a+b){
　case 3:
　case 5:
　case 8:
}
例三：
int a=s.nextInt();
int b=s.nextInt();
int c=s.nextInt();
if(a+b>5){
}else if(a-b<0) {
}else if(a>b*100){
}else if(c>0){
}
例一和例二是可以替代的，不過例二寫起來比較輕鬆，看起來也清爽。但例三用ｓｗｉｔｃｈ可就寫不出來了。
例三中最後一個ｉｆ的條件運算式和上面的三個ｉｆ的條件運算式完全無關，邏輯上很奇怪，但這是合法的。
什麼時候該用ｉｆ　ｅｌｓｅ　ｉｆ什麼時候該用ｓｗｉｔｃｈ好好體會一下吧！
３－３　課後練習：
練習１：修改３－２中的範例ＭｏｎｔｈＤａｙ，讓使用者除了輸入月份外也輸入年份，然後判斷輸入的年份是否為潤年，來決定２月份天數的輸出。
練習２：接收使用者輸入考試成績，然後加以評等：１００－＞Ａ＋，９０～９９－＞Ａ，８０～８９－＞Ｂ，７０～７９－＞Ｃ，６０～６９－＞Ｄ，其他分數為Ｅ。（限用ｓｗｉｔｃｈ，不可以用ｉｆ）

4. ｆｏｒ
ｆｏｒ迴圈，是讓部份程式碼重複執行的機制，這個機制主要分成兩個部份，一個是讓迴圈持續執行的條件，另一個是敍述區。
４－１　基本語法：
for([宣告或指派運算式];[條件運算式];[算術運算式]){
敍述區；
}
在ｆｏｒ的小括號中有兩個分號把小括號區隔成三個部份，用來分別輸入三種運算式，而這三種運算式都可以分別省略或全部省略，但分號不能省略。
宣告或指派運算式指的是：指派變數值的運算式，這個變數可以是已經存在的變數，或是新宣告的變數，若變數有一個以上，用‘，’隔開。例：“ｉｎｔ　 ａ＝０；”或　“ｉｎｔ　ａ＝０，ｂ＝０；”或　“ａ＝０；”但是，新宣告的變數只能在ｆｏｒ的區塊中使用，ｆｏｒ的敍述結束後，該變數就不能使用了。
條件運算式指的是：運算結果為布林值的運算式。若值為ｔｒｕｅ表示繼續迴圈的執行，若值為ｆａｌｓｅ表示停止迴圈的執行。在這個部份只能產生一個布林值， 也就是只能有一個條件運算式（可以使用邏輯運算符號）。但不能用‘，’隔開，寫一個以上的條件運算式。例：“ａ＞＝１０；”　或　“ａ＞＝１０　＆＆　 ｂ＞＝１０；”是合法的。但是：“ａ＞＝０，ｂ＞＝２０；”是不合法的。
算術運算式指的是：變數值的運算，用‘，’隔開可以寫一個以上的算術運算式。例：“ａ＋＋”　或　“ａ＋＝２”　或　“ａ＋＋，ｂ＋＝２”。不過，此部份只要不是宣告運算式，其實都是可以寫的，等日後基本寫法學會了再練習看看吧！
敍述區的敍述句如果只有一句，大括號可以省略。換個角度看，如果沒有大括號，那迴圈的敍述區範圍，僅止於小括號後面所遇到的第一個分號。

ｆｏｒ迴圈執行流程示意
ｆｏｒ（Ａ；Ｂ；Ｃ）｛ Ｄ； ｝	第一次迴圈
	Ａ－＞Ｂ（若Ｂ的值為ｔｒｕｅ）－＞Ｄ－＞Ｃ
	第一次以後之迴圈
	Ｂ（若Ｂ的值為ｔｒｕｅ）－＞Ｄ－＞Ｃ－＞Ｂ（一直循還到Ｂ的值為ｆａｌｓｅ時，結束迴圈）

例一：
for(int a=1;a<=10;a++){
　System.out.println(“Hello!”);
}
第一次執行時宣告變數ａ，並指派其值為１。條件ａ＜＝１０成立，執行輸出“Ｈｅｌｌｏ！”，再執行ａ＋＋。第一次迴圈執行完ａ的值為２。
第二次執行時，直接運算條件運算式，此時ａ的值是２，條件ａ＜＝１０成立，執行輸出“Ｈｅｌｌｏ！”，再執行ａ＋＋。第二次迴圈執行完ａ的值為３。
第十次執行，此時ａ的值為１０，條件ａ＜＝１０成立，執行輸出”Ｈｅｌｌｏ！“，再執行ａ＋＋。第十次迴圈執行完ａ的值為１１。
第十一次執行，此時ａ的值為１１，條件ａ＜＝１０不成立，迴圈結束。敍述區總共執行十次。
在此例中，如果小括號中的指派運算式改成：“ｉｎｔ　ａ＝０；”。則此迴圈的敍述區，將執行１１次。如果條件運算式改成：“ａ＜１０；”則此迴圈的敍述 區，將執行９次。如果將算術運算式改成：“ａ＋＝２”，則此迴圈的敍述區，將執行５次。所以三個運算式中的任何一個運算式，都會改變迴圈的次數，請多加練 習。
例二：
for(int a=10;a>=1;a--){
　System.out.println(“Hello!”);
}
此例迴圈的敍述區會執行十次，撰寫時請注意條件運算式與算術運算式的搭配。如果把此例中的算數運算式改成：“ａ＋＋”。因為條件ａ＞＝１將會永遠成立，此迴圈會執行無數次，我們稱之為無窮迴圈。
例三：
int a;
for(a=1;a<=10;a++){
　System.out.println(“Hello!”);
}
System.out.println(a);
此例中的指派運算式，所指派的變數ａ是ｆｏｒ執行前就已經存在的變數，這樣的變數在ｆｏｒ結束後，一樣可以使用。但若不是必要，並不建議把迴圈要用的變 數，宣告在迴圈外面，因為這個變數會佔用記憶體空間，直到方法結束。要注意的是：「不可以重複宣告」。以此例而言，若把指派運算式改成：“ｉｎｔ　 ａ＝１；”，會造成編譯錯誤。
例四：
int a=1;
for(;a<=10;a++){
　System.out.println(“Hello!“);
}
同例三，使用已存在之變數。並省略指派運算式。要注意的是：「變數宣告後，是否有指派」。如果把宣告句改成：“ｉｎｔ　ａ；”，則因為ａ沒有指派值，會造成編譯錯誤。
例五：
for(int a=1;;a++){
　if(a>10){
　　break;
　}
　System.out.println(“Hello!”);
}
此例中省略了條件運算式，但必須搭配ｉｆ及ｂｒｅａｋ的使用，來明確中斷迴圈的時機，否則會編譯錯誤。
例六：
for(int a=1;a<=10;){
　System.out.println(“Hello!”);
　a++;
}
此例中把算術運算式，寫到敍述區中是可以的。
例七：
for(int a=1;a<=10;)
　a++;
　System.out.println(“Hello!”);
此例只會輸入一次“Ｈｅｌｌｏ！”，因為省略大括號，所以迴圈的敍述區只包含一個敍述句，就是：“ａ＋＋；”。而“Ｈｅｌｌｏ”是在迴圈結束後才列印的。
例八：
for(int a=1;a<=10;a++);
{
　System.out.println(“Hello”);
}
此例執行結果為列印一次”Ｈｅｌｌｏ“。在Ｊａｖａ中，用大括號來建立任意的敍述區是合法的。以此例而言，因為ｆｏｒ的小括號後面加上分號，表示迴圈到此結束。所以接下來的大括號變成是獨立的敍述區塊而不屬於ｆｏｒ。
例九：
for(int a=1;a<=10;System.out.println(a++)){}
for(int a=10;a>=1;System.out.println(a--));
這兩句都是合法的，第一句會從１列印到１０，第二句會從１０列印到１。並不建議現在大家就使用這種寫法，但你可以先試試看，免得以後看到別人這樣寫被嚇呆了。
４－２　學習重點：
在正式寫迴圈範例時，初學者一定要注意，迴圈的重點是在敍述區，而不是迴圈的次數。寫迴圈之前要先分析清楚，到底是那些敍述句要重複執行，先把敍述區寫 好，外面再加上ｆｏｒ來控制次數。換個角度就是：「如果只執行一次的話，你程式碼會怎麼寫，就先把它寫出來，外面再加上ｆｏｒ就對了」。
範例：使用者輸入兩個整數，程式運算這兩個整數之間（含這兩個整數），的所有數字的總和。
檔名：Total.java
階段一：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　int total=0;
　　for(int a=1;a<=10;a++){
　　　total+=1;
　　}
　　System.out.println("總和為:" + total);
　}
}
此階段先運算１加１０次之總和，初學者可以先看看，如果把ｆｏｒ拿掉，只剩下“ｔｏｔａｌ＝ｔｏｔａｌ＋１；”是不是就是“ｔｏｔａｌ＋１”加一次，外面加上迴圈１０次的ｆｏｒ，就是“ｔｏｔａｌ＋１”加１０次。體會一下，迴圈是從裏面寫到外面。
階段二：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　int total=0;
　　for(int a=1;a<=10;a++){
　　　total+= a;
　　}
　　System.out.println(“總和為:” + total);
　}
}
將“ｔｏｔａｌ＝ｔｏｔａｌ＋１；”改成“ｔｏｔａｌ＝ｔｏｔａｌ＋ａ；”，就變成從１加到１０，執行結果為５５。
階段三：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　for(int a=firstNumber;a<=secondNumber;a++){
　　　total+= a;
　　}
　　System.out.println("總和為:" + total);
　}
}
接收兩個整數後，分別取代迴圈計數值ａ的起始值及結束值，結果就是從ｆｉｒｓｔＮｕｍｂｅｒ至ｓｅｃｏｎｄＮｕｍｂｅｒ之間數字的總和了。但是，這樣的程 式碼是有Ｂｕｇ的。試試看：如果ｆｉｒｓｔＮｕｍｂｅｒ的值大於ｓｅｃｏｎｄＮｕｍｅｒ的值時，這支程式會怎樣？怎麼辦呢？
階段四：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　if(firstNumber<secondNumber){
　　　for(int a=firstNumber;a<=secondNumber;a++){
　　　　total+= a;
　　　}
　　}else{
　　　for(int a=secondNumber;a<=firstNumber;a++){
　　　　total+= a;
　　　}
　　}
　　System.out.println("總和為:" + total);
　}
}
這個時候，可以先用ｉｆ判斷兩個數字的大小，再決定執行那一個迴圈。想想看：還有沒有其他的方法呢？
階段五：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　if(firstNumber>secondNumber){
　　　int temp=firstNumber;
　　　firstNumber=secondNumber;
　　　secondNumber=temp;
　　}
　　for(int a=firstNumber;a<=secondNumber;a++){
　　　total+= a;
　　}
　　System.out.println("總和為:" + total);
　}
}
在進入迴圈之前，如果ｓｅｃｏｎｄＮｕｍｂｅｒ的值大於ｆｉｒｓｔＮｕｍｂｅｒ，就把兩個變數的值對調。再想想：還有沒有其他方法呢？
階段六：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　for(int a=(firstNumber<secondNumber?firstNumber:secondNumber);
　　　　　　a<=(firstNumber>secondNumber?firstNumber:secondNumber);
　　　　　　a++){
　　　total+= a;
　　}
　　System.out.println("總和為:" + total);
　}
}
和階段五比較起來，這裏的程式碼反而複雜，並不建議這樣使用。這裏只是示範條件運算符號（？：）的使用方式。指派運算式中的ａ會等於兩個整數中的較小值，條件運算式中的ａ會小於等於兩個整數中的較大值。
階段七：
import java.util.*;
public class Total{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入第一個整數-->");
　　int firstNumber=s.nextInt();
　　System.out.print("請輸入第二個整數-->");
　　int secondNumber=s.nextInt();
　　int total=0;
　　for(int a=(firstNumber<secondNumber?firstNumber:secondNumber);
　　　　　a<=(firstNumber>secondNumber?firstNumber:secondNumber);
　　　　　total+=a++);
　　System.out.println("總和為:" + total);
　}
}
當你可以寫成這樣的時候，別人想要看懂你的程式碼，就有點難度了，加油吧！
範例：使用者輸入整數，程式判斷該整數是否為質數。（無法均分為任意等份的數字；除了１與數字本身，任何數字都無法整除的數字）
檔名：Prime.java
階段一：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　if(value%2==0){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
我們先假設只要被２整除就不是質數來寫出上面的程式碼。然後再來思考，除了２以外，我們還要繼續除以３、４‧‧‧一直到ｖａｌｕｅ－１為止，都沒有被整除才是質數，而這些運算式能夠寫在ｉｆ的小括號中嗎？當然不行，那要寫在那裏呢？
階段二：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<value;a++){
　　　if(value%a==0){
　　　　prime=false;
　　　}
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
先宣告一個布林值變數ｐｒｉｍｅ＝ｔｒｕｅ，而迴圈中只要２～ｖａｌｕｅ－１中的任何一個數字整除ｖａｌｕｅ，ｐｒｉｍｅ的值會變成ｆａｌｓｅ，表示 ｖａｌｕｅ不是質數，最後再把ｐｒｉｍｅ交給ｉｆ判斷後輸出。值得思考的是，迴圈中的ｉｆ如果加上ｅｌｓｅ　ｐｒｉｍｅ＝ｔｒｕｅ的話，結果會變怎樣呢？ 自己想想看吧！
而程式到這裏可以說已經完成，但並不是一支好程式。因為執行了太多不必要的運算。比如說：若要檢測１００是否為質數，在第一次迴圈時，１００就會被２整除，那剩下的９７次迴圈，不是就沒有必要了嗎？
階段三：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<value;a++){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
此階段中，只多了一行敍述句：“ｂｒｅａｋ；”。表示只要有任何一個數字整除ｖａｌｕｅ，就代表ｖａｌｕｅ不是質數，迴圈便中斷，不必再執行。也就是說： 「如果檢測的數字是１００，那麼此迴圈執行一次便會結束，而不必執行９８次」。接下來，我們再想想看，有沒有必要除以２的倍數？
階段四：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<value;){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　　if(a==2)
　　　　a++;
　　　else
　　　　a+=2;
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
當ａ的值是２的時候，執行“ａ＋＋；”，當ａ的值是３以後執行“ａ＋＝２”，那麼ａ的值就會以３，５，７‧‧‧的奇數往下跑，也就節省了一半的運算次數。 以此類推，那如果也不要除以３或５或７的倍數，不是省更多嗎？當然沒錯，不過寫起來就複雜了，本範例只是提醒大家要減少不必要的運算，不要想太多。
階段五：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<=value/2;){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　　if(a==2)
　　　　a++;
　　　else
　　　　a+=2;
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
此階段的變化只有：把迴圈中的條件運算式ａ＜ｖａｌｕｅ改成ａ<=ｖａｌｕｅ／２。因為數字是不可能被大於它一半的數字整除的。所以又省了一半的運算。但事實上更節省的方式是“ａ＜=ｖａｌｕｅ開根號的值”，不過那必須用到我們還沒教的方法，所以就不講了。有興趣的同學，自己試試看。
階段六：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　boolean prime=true;
　　for(int a=2;a<=value/2;a+=(a==2?1:2)){
　　　if(value%a==0){
　　　　prime=false;
　　　　break;
　　　}
　　}
　　if(prime==false){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}
　}
}
節省完不必要的運算後，接下來便是程式碼的精簡了。利用條件運算符號（？：）來取代ｉｆ的判斷。這樣的程式碼看起來，是不是比較有深度了呢？
階段七：
import java.util.*;
public class Prime{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.print("請輸入任意整數-->");
　　int value=s.nextInt();
　　int a=2;
　　for(;a<=value/2;a+=(a==2?1:2)){
　　　if(value%a==0){
　　　　break;
　　　}
　　}
　　if(a<=value/2){
　　　System.out.println(value + "不是質數");
　　}else{
　　　System.out.println(value + "是質數");
　　}　
　}
}
使用ｂｒｅａｋ之後，程式碼也可以改成這樣。ａ宣告在迴圈之前，是因為迴圈之後，下面的ｉｆ還會用到。而ｉｆ中的“ａ＜=ｖａｌｕｅ／２”是什麼意思呢？我們必須思考迴圈結束時，ａ的值的變化。
若迴圈不是因為ｂｒｅａｋ而中斷，而是因為“ａ＜=ｖａｌｕｅ／２”不成立才結束，表示說：「沒有任何數字整除ｖｌａｕｅ」。也就表示說「迴圈結束時，ａ的值是大於ｖａｌｕｅ／２的」。所以在迴圈下面的“ｉｆ（ａ＜=ｖａｌｕｅ／２）”便不會成立，於是輸出“ｖａｌｕｅ是質數”。
相對的，若迴圈是因為ｂｒｅａｋ而結束（ｖａｌｕｅ已被整除），表示ａ的值還沒有跑到ｖａｌｕｅ／２的時候，迴圈就結束了。所以迴圈下面的“ｉｆ（ａ＜=ｖａｌｕｅ／２）”便成立，然後輸出“ｖａｌｕｅ不是質數”。
如果讀者對上述文字看起來有看沒有懂，請用實際數字代進去（例如：７、８），然後用筆自行運算看看，可以協助理解。
４－３　巢狀迴圈：
巢狀迴圈是指迴圈之中還有迴圈。但這是文字上的說明，真正在撰寫時，還是建議從裏面（內迴圈）寫到外面（外迴圈）。就像在寫一般迴圈時，敍述區先寫一樣，巢狀迴圈就是某一個迴圈要重複執行，所以只要內迴圈先寫好，外圍再加上迴圈就完成了。
範例：顯示三角形數字矩陣。
１
１２
１２３
１２３４
１２３４５
檔名：NumberMatrix.java
階段一：
public class NumberMatrix{
　public static void main(String[] args){
　　System.out.print("1");
　}
}
分析問題，找出最基礎的敍述。
階段二：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int a=1;a<=5;a++){
　　　System.out.print("1");
　　}
　}
}
顯示五個１。
階段三：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int a=1;a<=5;a++){
　　　System.out.print(a);
　　}
　}
}
顯示１２３４５。
階段四：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int b=1;b<=5;b++){
　　　for(int a=1;a<=5;a++){
　　　　System.out.print(a);
　　　}
　　　System.out.println();
　　}
　}
}
在剛才顯示１２３４５的迴圈外圍，再加上一層執行五次的迴圈，結果會顯示五列１２３４５。每列印完一列，要記得換行。
階段五：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int b=1;b<=5;b++){
　　　for(int a=1;a<=b;a++){
　　　　System.out.print(a);
　　　}
　　　System.out.println();
　　}
　}
}
內迴圈的執行次數不再固定執行五次，改為依照外迴圈的變數值改變。此即為解答。
再強調一次，初學者先學會由內往外寫，熟練了再由外往內寫。
接下來讀者可以先想想看如果要寫成這樣，你會怎麼寫？
５
５４
５４３
５４３２
５４３２１
階段六：
public class NumberMatrix{
　public static void main(String[] args){
　　for(int b=1;b<=5;b++){
　　　for(int a=1;a<=b;a++){
　　　　System.out.print(6-a);
　　　}
　　　System.out.println();
　　}
　}
}
沒錯，做一點小小的改變就可以了，大家可以再多做些變化，來完全掌握計數值的運用。
範例：九九乘法表。
１＊１＝１　１＊２＝２　１＊３＝３　………　１＊９＝９
２＊１＝２　………
……………
……………
９＊１＝９　９＊２＝１８　………………………９＊９＝８１　
檔名：NineNine.java
階段一：
public class NineNine{
　public static void main(String[] args){
　　System.out.print("1*1=1");
　}
}
先列印最基礎敍述句。
階段二：
public class NineNine{
　public static void main(String[] args){
　　for(int a=1;a<=9;a++){
　　　System.out.print("1*1=1\t");
　　}
　}
}
列印九次“１＊１＝１”，‘＼ｔ’代表Ｔａｂ。
階段三：
public class NineNine{
　public static void main(String[] args){
　　for(int a=1;a<=9;a++){
　　　System.out.print("1*" + a + "=" + 1*a + "\t");
　　}
　}
}
用迴圈的變數ａ，來取代輸出文字中後面的１，就會變成１＊１～１＊９。
階段四：
public class NineNine{
　public static void main(String[] args){
　　for(int b=1;b<=9;b++){
　　　for(int a=1;a<=9;a++){
　　　　System.out.print("1*" + a + "=" + 1*a + "\t");
　　　}
　　　System.out.println();
　　}
　}
}
列印九行１＊１～１＊９。
階段五：
public class NineNine{
　public static void main(String[] args){
　　for(int b=1;b<=9;b++){
　　　for(int a=1;a<=9;a++){
　　　　System.out.print(b + "*" + a + "=" + b*a + "\t");
　　　}
　　　System.out.println();
　　}
　}
}
把外迴圈的變數ｂ，取代輸出文字的１。這樣九九乘法表就完成了。從裏面開始寫，是不是很輕鬆呢？
４－４　課後練習：
練習１：顯示本月份之月曆。例：
２００６　年　１１　月
日　　一　　二　　三　　四　　五　　六
　　　　　　　　　　１　　２　　３　　４
　５　　６　　７　　８　　９　１０　１１
１２　１３　１４　１５　１６　１７　１８
１９　２０　２１　２２　２３　２４　２５
２６　２７　２８　２９　３０　
練習２：將練習１改成，讓使用者指定欲顯示之月份。（有空再練習）
練習３：將練習２改成，讓使用者指定欲顯示之年份及月份。（非常有空再練習）
練習４：列印出２到１００的所有質數。
練習５：接受使用者輸入任意兩個整數，程式回應這兩整數的最小公倍數。

5. ｗｈｉｌｅ
５－１　基本語法：
while(布林值)｛
　敍述區；
｝
迴圈的第二種寫法。小括號中的布林值指的是：「可以產生布林值的運算式，或布林值型別的變數」。另外也可以直接輸入布林值ｔｒｕｅ，但不可以直接輸入布林值ｆａｌｓｅ。
這種寫法在使用時機上和ｆｏｒ是有很大的差異性的。ｆｏｒ是以次數為主，也就是敍述區的執行由變數值及條件式控制；而ｗｈｉｌｅ是單純以條件運算式來控制。
雖然兩種寫法可以相互替換（ｆｏｒ能寫的，用ｗｈｉｌｅ也能寫，反之亦然）。但在這裏還是希望讀者能夠在不同的時機，使用不同的寫法。而初學者應該先練好ｆｏｒ之後，再用相同範例來練習ｗｈｉｌｅ的寫法。
例一：
int a=1;
while(a<=10){
　System.out.println(“Hello”);
　a++;
}
執行結果會列印十次“Ｈｅｌｌｏ”，但像這樣的案例，用ｆｏｒ的寫法是比較適當的。但是因為現在讀者學會的方法並不多，還沒有辦法單純用條件運算式來控制 迴圈，所以只好用次數的案例來先讓讀者知道ｗｈｉｌｅ的基本架構。ｗｈｉｌｅ的使用時機，還是應該用在不確定次數的案例比較合適。
範例：持續接受使用者輸入文字，並將之列印在螢幕上，直到使用者輸入ＧａｍｅＯｖｅｒ才結束程式。
檔名：InputString.java
import java.util.*;
public class InputString{
　public static void main(String[] args){
　　Scanner s=new Scanner(System.in);
　　System.out.println("請輸入任意文字後按Enter,欲結束請輸入　GameOver");
　　String value=null;
　　while(!((value=s.next()).equals("GameOver"))){
　　　System.out.println(value);
　　}
　}
}
本範例用了讀者目前尚未學到的指令及方法，您不必把它們弄懂，只要知道「ｗｈｉｌｅ基本上是運用在這類執行次數不一定，而以條件運算式判斷為主的案例上就可以了」。

6. ｄｏ　ｗｈｉｌｅ
６－１　基本語法：
do{
敍述區；
}while(布林值);
迴圈的第三種寫法，寫法和ｗｈｉｌｅ很像，但它的ｗｈｉｌｅ放在最後面，而且必須以‘；’結束。這種寫法和ｆｏｒ及ｗｈｉｌｅ有一個很大的差異點：「至少 執行一次」。ｆｏｒ及ｗｈｉｌｅ的迴圈如果一開始條件就不成立的話，迴圈內的敍述區是完全不執行。但這種寫法，因為是執行完敍述區後，再判斷要不要執行下 一次，所以即使條件式不成立，也已經執行一次了。使用時機就是：「撰寫至少要執行一次的迴圈」。
例一：
for(int a=1;a<0;a++){
　System.out.println(“Hello!”);
}
int b=1;
while(b<0){
　System.out.println(“Hello!”);
　b++;
}
int c=1;
do{
　System.out.println(“Hello!”);
　c++;
}while(c<0);
此例中的ｆｏｒ及ｗｈｉｌｅ中的敍述區都不會執行。會ｄｏ　ｗｈｉｌｅ會列印一次“Ｈｅｌｌｏ”。
６－２　課後練習：
練習１：提款機登入程式＝＞讓使用者輸入四個數字的密碼，若符合你預設的數字（比如：１２３４），則輸出“歡迎光臨大笨銀行”，否則輸出“密碼錯誤，請重新輸入”。但是，此程式最多接受三次的輸入。（使用迴圈，並請分析應該使用那一種寫法）
練習２：猜數字遊戲＝＞接受使用者先指定數字範圍（１００以上），程式便會產生一個該範圍內之亂數。並依照不同的數字範圍來設定使用者猜數字的次數。使用者每次猜完都必須提示太高或太低，最後依照使用者猜測的次數給予評語。
ＰＳ‧亂數：Ｍａｔｈ‧ｒａｎｄｏｍ（）。此敍述的運算結果為大於等於０小於１的亂數。
　
7. ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ，設定標籤
７－１　ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ：
ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是中斷迴圈的指令。不同的是：ｂｒｅａｋ是結束整個迴圈的執行；ｃｏｎｔｉｎｕｅ是中斷這一次的敍述區的執行。但是，兩者都必須搭配判斷敍述使用。
例一：
for(int a=1;a<=10;a++){
　if(a%3==0){
　　break;
　}
　System.out.print(a + “,”);
}
此例會顯示１，２。當a的值為3時，迴圈結束，而ｉｆ敍述外面的輸出敍述句，便不會執行。
例二：
for(int a=1;a<=10;a++){
　if(a%3==0){
　　continue;
　}
　System.out.println(a + “,”);
}
此例會顯示１，２，４，５，７，８，１０。當ａ的值為３的倍數時，ｉｆ中的ｃｏｎｔｉｎｕｅ會中斷該次敍述區的執行，所以ｉｆ敍述後面的輸出敍述句，便不會執行，而直接進入下一輪的迴圈。
７－２　標籤：
ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是用來中斷撰寫該指令的迴圈，但在巢狀迴圈中，如果要中斷的對象是外圍迴圈時，便必須搭配標籤使用。而標籤必須宣告在迴圈的上方。
標籤的名稱和變數一樣，可以自訂。
例一：
int s=1;
outer:
for(int a=1;a<=10;a++){
　while(s<=10){
　　System.out.println(“Hello!”);
　　s++;
　　break outer;
　}
　System.out.println(“World”);
}
此例執行的結果只會列印一次“Ｈｅｌｌｏ”，列印完ｂｒｅａｋ的對象是外圍的ｆｏｒ迴圈，所以“Ｗｏｒｌｄ”連一次都沒有列印。另外要注意的是：“ｉｎｔ　ｓ＝１；”的宣告不可以放在標籤“ｏｕｔｅｒ：”的宣告之後，因為標籤“ｏｕｔｅｒ：”的後面，必須是迴圈敍述。
例二：
int s=1;
outer:
for(int a=1;a<=10;a++){
　while(s<=10){
　　System.out.println(“Hello!”);
　　s++;
　　continue outer;
　}
　System.out.println(“World”);
}
此例執行的結果會列印十次“Ｈｅｌｌｏ”，但因為每次列印完ｃｏｎｔｉｎｕｅ的對象是外圍的ｆｏｒ迴圈，所以“Ｗｏｒｌｄ”還是連一次都沒有列印。

8. ｆｏｒ　ｅａｃｈ
在Ｊａｖａ　５‧０中，新增的一種迴圈的寫法，但這種寫法是針對集合物件，而且是要運算集合物件中的每一個元素時才適用。因為我們還沒有學會集合物件，所有大家只要先知道語法架構，實務用法將在後續章節中介紹。
for(資料型別 變數:集合物件){
　敍述區;
}
語法中的變數，將會逐一代表集合物件中的每一個元素，所以宣告變數的資料型別，必須和集合物件中的元素的資料型別吻合。
例：
int[] a={8,55,11,4,6};
for(int b:a){
　System.out.println(b);
}
變數ａ代表一個陣列物件，變數ｂ將代表陣列物件中的每一個元素。此例將會列印ａ陣列中的每一個元素。
9. 認證重點整理
９－３　ｓｗｉｔｃｈ

• 财 ｓｗｉｔｃｈ小括號中的運算式的型別，必須是ｉｎｔ，ｂｙｔｅ，ｓｈｏｒｔ型別的整數值，當然包含可以自動轉換為ｉｎｔ型別的ｃｈａｒ。也就是說，它可以是一個會產生整數值的運算式或變數（不包含ｌｏｎｇ型別）。
• 财 區塊中的ｃａｓｅ沒有個數的限制，而且不必依照值的大小排列。
• 财 ｃａｓｅ後方的值一樣必須是整數，且其值不可以超過運算式的最大或最小值的範圍。
• 财 區塊中所有ｃａｓｅ的值不可以重複。
• 财 因為ｃａｓｅ後面的值必須在編譯時期就確認，所以不可以是變數。
• 财 ｃａｓｅ後面只能放數值或字元或在宣告時立刻指派的常數。
• 财 當ｓｗｉｔｃｈ中某一個ｃａｓｅ成立後，便會執行該ｃａｓｅ的敍述區，直到遇到ｂｒｅａｋ或這個ｓｗｉｔｃｈ的末端。
• 财 ｄｅｆａｕｌｔ可以省略，也不一定要置於最末端。只不過若沒有置於最末端，就必須注意有沒有必要加ｂｒｅａｋ。
• 财 ｄｅｆａｕｌｔ的敍述區，必須是在所有ｃａｓｅ均不成立的狀況下，才會執行。即使ｃａｓｅ置於ｄｅｆａｕｌｔ下面，也不例外。

９－７　ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ，設定標籤

• 财 ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是中斷迴圈的指令，不同的是：ｂｒｅａｋ是結束整個迴圈的執行；ｃｏｎｔｉｎｕｅ是中斷這一次的敍述區的執行。但是兩者都必須搭配判斷句使用。
• 财 ｂｒｅａｋ和ｃｏｎｔｉｎｕｅ都是用來中斷撰寫該指令的迴圈。但在巢狀迴圈中，如果要中斷的對象是外圍迴圈時，便必須搭配標籤使用。而標籤必須宣告在迴圈的上方。

９－８　ｆｏｒ　ｅａｃｈ

• 财 小括號中‘：’左側為變數宣告，不必指派值；右側為物件名稱（參考變數）。