控制流程教程詳解
1 、順序語句
語句：使用分號分隔的代碼稱做爲一個語句。java
注意：沒有寫任何代碼只是一個分號的時候，也是一條語句，稱做空語句。spring
順序語句就是按照從上往下的順序執行的語句。數組
2 、判斷(if…else)
在咱們找工做的過程當中，要求兩年工做經驗以上且年齡超過30歲。dom
什麼是判斷語句：用於判斷的語句叫判斷語句。spa
1.格式一 設計
if(判斷條件){
若是符合條件執行的代碼;
執行的代碼塊1；
執行的代碼塊2；
……………….；
執行的代碼塊n；
}
練習：提示用戶輸入一個整數。若是該整數是5的倍數，打印「5的倍數」若是是2的倍數打印「2的倍數」blog
提示：爲了便於讓用戶輸入數據，咱們使用Scanner這個類，固定用法Scanner sc=new Scanner(System.in); 該類須要導入包import java.util.Scanner;遊戲
int nextInt = sc.nextInt();獲取用戶輸入的數字內存
import java.util.Scanner;
public class Demo9 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int nextInt = sc.nextInt();
if(nextInt%5==0){
System.out.println("是5的倍數");
}
if(nextInt%2==0){
System.out.println("是2的倍數");
}
}
}
2.格式二 作用域
if(判斷條件){
執行的代碼塊1；
執行的代碼塊2；
……………….；
執行的代碼塊n；
}else{
執行的代碼塊1；
執行的代碼塊2；
……………….；
執行的代碼塊n；
}
案例：判斷一個整數是奇數仍是偶數
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個整數：");
int nextInt = sc.nextInt();
if (nextInt % 2 == 0)
System.out.println("是偶數");
else
System.out.println("是奇數");
System.out.println("over");
}
一樣道理若是花括號中只有一條語句，那麼花括號能夠省略不寫，初學者不推薦省略。
觀察發現if else語句有點相似於三元運算符.其實三元運算符是if else 的一種簡寫格式.
Public static void main(String[] args) {
int x = 0, y = 1, b;
// if else 語句
if (x > y) {
b = x;
} else {
b = y;
}
System.out.println(b);// 1
// 3元運算
b = x > y ? x : y;
System.out.println(b); // 1
}
三元運算符：這兩種格式是同樣的。if else 結構 簡寫格式： 變量 = (條件表達式)?表達式1：表達式2；
好處：能夠簡化if else代碼。
弊端：由於是一個運算符，因此運算完必需要有一個結果。
3．格式三
if(判斷條件1){
執行的代碼塊1；
}else if(判斷條件2){
執行語句;
}else if(判斷條件3){
執行語句；
}
需求: 根據用戶定義的數值不一樣,打印對應的星期英文。
if 只能進行一層判斷,if else 只能進行兩層判斷,那麼須要多層判斷時呢?星期但是有7個數的。如何設計代碼？
使用if 語句
public static void main(String[] args) {
int x = 8;
if (x == 1) {
System.out.println("星期一");
}
if (x == 2) {
System.out.println("星期二");
}
if (x == 3) {
System.out.println("星期三");
}
}
使用if else ，若是用戶輸入的是7之外的數據，那麼怎麼處理？就須要使用else 了若是這樣設計的話,第一個if語句執行完畢後,第二個語句仍會執行（去判斷）,是一個順序結構.那麼事實上當前定義的星期以後會有一個.假如,第一個已經符合條件,那麼剩餘的執行就沒有意義了。屬於邏輯錯誤。
方案2：使用if else if語句
public static void main(String[] args) {
int x = 8;
if (x == 1) {
System.out.println("星期一");
} else if (x == 2) {
System.out.println("星期二");
} else if (x == 3) {
System.out.println("星期三");
} else if (x == 4) {
System.out.println("星期四");
} else if (x == 5) {
System.out.println("星期五");
} else if (x == 6) {
System.out.println("星期六");
} else if (x == 7) {
System.out.println("星期日");
} else {
System.out.println("請輸入數字1-7");
}
}
注意：
public static void main(String[] args) {
int x = 5;
if (x == 1) {
System.out.println("1");
}
if (x == 2) {
System.out.println("2");
}
if (x == 3) {
System.out.println("3");
} else {
System.out.println("4"); // 4
}
}
該if 語句不是一個總體,第一個if 是一個語句，第二個又是一個語句,最後的if else 又是一個語句。
if語句特色
- 第二種格式與三元運算符的區別：三元運算符運算完要有值出現。好處是：能夠寫在其餘表達式中。
- 條件表達式不管寫成什麼樣子，只看最終的結構是不是true 或者 false。
練習1: 根據用戶輸入的月份,打印出月份所屬的季節.
練習2: 根據用戶輸入的成績，進行評級，根據學生考試成績劃分ABCD
練習1：
public static void main(String[] args) {
int x = 1;
if (x == 3) {
System.out.println("spring");
} else if (x == 4) {
System.out.println("spring");
}
}
仔細觀察：發現if和else if要執行的語句是同樣的，可不能夠合併呢。固然是能夠的。怎麼合併？使用邏輯運算符，那麼使用哪一個邏輯運算符呢， &確定不行。須要所有爲真才爲真，月份是不可能同時知足的 那麼使用|鏈接符號便可。意思只要其中一個爲真，就爲真。另外可使用短路功能。
public static void main(String[] args) {
int x = 1;
if (x == 3 || x == 4 || x == 5) {
System.out.println("spring");
} else if (x == 6 || x == 7 || x == 8) {
System.out.println("Summer");
} else if (x == 9 || x == 10 || x == 11) {
System.out.println("autumn");
} else {
System.out.println("Winter");
} else {
System.out.println("月份不存在");
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請輸入考試分數：");
double score = sc.nextDouble();
char grade;
if (score >= 90.0)
grade = 'A';
else if (score >= 80.0)
grade = 'B';
else if (score >= 70.0)
grade = 'C';
else if (score >= 60.0)
grade = 'D';
else
grade = 'F';
System.out.println("你的成績是:" + grade);
}
練習2：
If語句常見的錯誤：
1．忘記必要的括號：若是代碼塊中只有一條語句的時候，能夠省略花括號，可是當花括號將多條語句擴在一塊兒時，花括號就不能在省略。
double radius = 4;
double area;
if (radius >= 0)
area = radius * radius * 3.14;
System.out.println("The area " + " is " + area);
double radius = 4;
double area;
if (radius >= 0) {
area = radius * radius * 3.14;
System.out.println("The area " + " is " + area);
}
2．if語句後出現分號雖然代碼同樣多，可是第一個會編譯報錯（area沒有出初始化），第二個正常運行。就是由於少了花括號。因此必定要仔細。
double radius = 0;
double area;
if (radius > 0); {
area = radius * radius * 3.14;
System.out.println("The area " + " is " + area);
}
至關於判斷符合條件後，執行一個空語句。注意：這是一個邏輯錯誤，編譯和運行都不會報錯，只是不會出現想要的結果。
double radius = 0;
double area;
if (radius > 0){}{
area = radius * radius * 3.14;
System.out.println("The area " + " is " + area);
}
判斷閏年
1：什麼是閏年？能夠被4整除不能被100整除，或者能夠被400整除，那麼這一年就是閏年（leap year）
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請輸入年份：");
int year = sc.nextInt();
// 判斷年份可否被4整除
boolean isLeapYear = (year % 4 == 0);
// 年份能被4整除，而且不能被100整除而且使用&&（and）
isLeapYear = isLeapYear && (year % 100 != 0);
// 年份或者可以被400整除
isLeapYear = isLeapYear || (year % 400 == 0);
if (isLeapYear) {
System.out.println(year + "是閏年！");
}
// 簡寫格式；
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
System.out.println(year + "是閏年！");
}
}
三、選擇判斷語句(switch)
switch語句
格式：
switch(表達式)
{
case 取值1:
執行語句；
break；
case 取值2:
執行語句；
break；
…...
default:
執行語句；
break；
}
1,switch語句選擇的類型只有四種：byte，short，int ， char。switch語句特色：
2,case之間與default沒有順序。先判斷全部的case，沒有匹配的case執行
default。
3,switch語句中止的條件是遇到了break關鍵字或者結束switch語句的大括號。
4,若是匹配的case或者default沒有對應的break，那麼程序會繼續向下執行，運
行能夠執行的語句，直到遇到break或者switch結尾結束。
5，switch case中的值必需要與switch表達式的值具備相同的數據類型。並且case後跟的值必須是常量，不能跟變量。
案例：
public static void main(String[] args) {
int x = 3;
switch (x) {
case 1:
System.out.println("1");
break;
case 2:
System.out.println("2");
break;
case 3:
System.out.println("3");
break;
default:
System.out.println("ok");
break;
}
}
注意: case後跟的是冒號:case 就像選擇題的答案之一。 break 就是若是該答案正確那麼就能夠跳出switch 了,意思就是說 已經找出了正確的答案了。那麼這道題也就作完了。若是 case 沒有匹配接着進行下一個case 匹配,直到匹配爲止。 最後若是都沒有匹配上,那麼 switch 給提供了一個默認的答案,就是 default。
每一個case中的執行語句必定要加break；
練習:
需求2:根據用於指定的月份,打印該月份所屬的季節.
一旦case匹配,就會順序執行後面的程序代碼,而無論後面的case是否匹配,直到碰見break,利用這一特性可讓好幾個case執行統一語句.
345 spring 678 sunmer 9 10 11 autumn 12 1 2 winter
public static void main(String[] args) {
int x = 3;
switch (x) {
case 3:
case 4:
case 5:
System.out.println("spring");
break;
case 6:
case 7:
case 8:
System.out.println("sunmer");
break;
case 9:
case 10:
case 11:
System.out.println("autumn");
break;
case 12:
case 0:
case 1:
System.out.println("winter");
default:
System.out.println("ok");
break;
}
}
練習：char 類型在switch 中的使用.
public static void main(String[] args) {
int x = 1, y = 2;
char ch = '*';
switch (ch) {
case '+':
System.out.println("x*y=" + (x + y));
break;
case '-':
System.out.println("x-y="+(x-y));
break;
case '*':
System.out.println("x*y="+(x*y));
break;
case '/':
System.out.println("x/y="+(x/y));
break;
default:
System.out.println("不靠譜");
}
}
若是判斷的具體數值很少,而是符號byte,short int char 四種類型.if 和switch 語句很像，具體什麼場景下,應用哪一個語句呢?
雖然2個語句均可以使用,建議使用switch語句.由於效率稍高.
其餘狀況:
對區間判斷,對結果爲boolean 類型判斷,使用if if的使用範圍更廣。
if 除了能判斷具體數值還能判斷區間。switch 判斷區間會很費勁的。要寫好多case 對於運算結果是boolean型的 if 能判斷 switch 是不能實現的。例如：根據學生考試成績劃分ABCD A90-100 B80-89 C70-79 D60-69 E0-59。
實際開發怎麼選擇呢?
若是要對具體數值進行判斷,而且數值很少,那麼 就用switch 來完成。switch的case條件都是編譯期整數常量，編譯器能夠作到表格跳轉查詢，查找速度快。
可是switch 的侷限性比較大必須是4種類型,而且值很少。通常都是使用if。 最後在jdk 7中對switch 進行了加強 還能夠判斷字符串。5.0 增長了對枚舉的判斷。
備註：JDK7.0開始可使用switch可使用字符串類型的數據了.
4 、While循環
需求：須要打印一行字符串"hello gzitcast"，100次
就須要將該語句打印100遍System.out.println("hello gzitcast");
那麼如何解決該問題？
Java提供個一個稱之爲循環的結構，用來控制一個操做的重複執行。
int count = 0;
while (count < 100) {
System.out.println("hello gzitcast");
count++;
}
System.out.println("over");
Java提供了三種類型的循環語句：while循環，do-while循環和for循環。變量count初始化值爲0，循環檢查count<100 是否爲true,若是爲true執行循環體（while後{}之間的語句），輸出"hello gzitcast"語句，而後count自增一，重複循環，直到count是100時，也就是count<100爲false時，循環中止。執行循環以後的下一條語句。
一、while語句格式：
while(條件表達式)
{
執行語句；
}
定義需求: 想要打印5次helloworld
public static void main(String[] args) {
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
System.out.println("hello world");
}
二、
public static void main(String[] args) {
int x = 0;
while (x < 5) {
System.out.println("hello java ");
}
}
這就是真循環或者死循環。由於x<5 永遠爲真。若是是在dos裏編譯和運行，是不會中止，除非系統死機。須要ctrl+c來結束。
public static void main(String[] args) {
int x = 0;
while (x < 5) {
System.out.println("hello java ");
x++;
}
}
練習：想要打印出1-100之間的奇數讓x自增，那麼就會有不知足條件的時候。循環就會結束。
public static void main(String[] args) {
int x = 1;
while (x < 100) {
System.out.println(x);
x = x + 2;
}
}
public static void main(String[] args){
int x=1;
while(x<100){
if(x%2!=0){
System.out.print(x);
}
x++;
}
System.out.println();
}
int sum = 0;
int i = 1;
while (i < 10) {
sum = sum + i;
i++;
}
System.out.println(sum);
練習2：計算1+2+3+4+5+6+7+8+9 的值
注意：要精確控制循環的次數。常犯錯誤是是循環多執行一次或者少執行一次。
例如會執行101次，想要執行100次，要麼是count初始值爲1，而後count<=100
要麼是count初始值爲0，coung<100
int count = 0;
while (count <=100) {
System.out.println("hello gzitcast");
count++;
}
System.out.println("over");
猜數字遊戲:
編寫程序隨即生成一個0-100之間的隨機數。程序提示用戶輸入一個數字，不停猜想，直到猜對爲止。最後輸出猜想的數字，和猜想的次數。而且若是沒有猜中要提示用戶輸入的值是大了仍是小了。
思考：
如何生成1-100之間隨機數？
(int)(Math.random()*100)+1;
如何提示用戶輸入數字，
Scanner sc=new Scanner(System.in);
int guessNum = sc.nextInt();
須要將隨機數和用戶輸入的數字進行比較。
猜一次：
Scanner sc = new Scanner(System.in);
int num = (int)(Math.random()*100)+1;
System.out.println("請輸入0-100之間整數");
int guessNum = sc.nextInt();
if (guessNum == num) {
System.out.println("中啦");
} else if (guessNum < num) {
System.out.println("小啦");
} else {
System.out.println("大了");
}
可使用while循環這個程序只能才一次，如何讓用戶重複輸入直到猜對？
public static void main(String[] args) {
int num = (int)(Math.random()*100)+1;
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("請輸入1-100之間整數");
int guessNum = sc.nextInt();
if (guessNum == num) {
System.out.println("中啦");
} else if (guessNum < num) {
System.out.println("小啦");
} else {
System.out.println("大了");
}
}
}
該方案發現了問題，雖然實現了讓用戶不停的輸入，可是即便猜中了程序也不會中止。
那麼就須要控制循環次數了。也就是while() 括號中的條件表達式。當用戶猜想的數和系統生成的數字不相等時，就須要繼續循環。
int num = (int)(Math.random()*100)+1;
Scanner sc = new Scanner(System.in);
int guessNum = -1;
while (guessNum != num) {
System.out.println("請輸入1-100之間整數");
guessNum = sc.nextInt();
if (guessNum == num) {
System.out.println("中啦");
} else if (guessNum < num) {
System.out.println("小啦");
} else {
System.out.println("大了");
}
}
爲何將guessNum初始化值爲-1？由於若是初始化爲0到100之間程序會出錯，由於多是要猜的數。
1：首先程序生成了一個隨機數
2：用戶輸入一個數字
3：循環檢查用戶數字和隨機數是否相同，知道相同位置，循環結束
5 、do while 語句
do while語句格式：
do
{
執行語句；
}while(條件表達式);
do while特色是條件不管是否知足，
循環體至少被執行一次。
public static void main(String[] args) {
int x = 0, y = 0;
do {
System.out.println(x);
x++;
} while (x < 0);
// do while do會先執行一次,無論是否知足循環條件。
while (y < 0) {
System.out.println(y);
y++;
}
}
while:先判斷條件，只有條件知足才執行循環體。
do while: 先執行循環體，再判斷條件，條件知足，再繼續執行循環體。
簡單一句話：do while：不管條件是否知足，循環體至少執行一次。
注意一個細節do while 後面的分號;
案例：改寫猜數字遊戲
public static void main(String[] args) {
// 記錄用戶輸入的數字
int guess = -1;
// 記錄用戶輸入次數
int count = 0;
// 生成1-100之間隨機數
int num = (int) (int)(Math.random()*100)+1;
Scanner sc = new Scanner(System.in);
// 循環猜數字
do {
System.out.println("請輸入1-100之間的數字");
guess = sc.nextInt();
if (guess > num) {
System.out.println("哥們，太大了");
} else if (guess < num) {
System.out.println("哥們，過小了");
} else {
System.out.println("恭喜，中啦");
}
count++;
} while (num != guess);
System.out.println("你猜想的數字是:" + num + "猜想了" + count + "次");
}
案例：計算器
系統自動生成2個隨機數用於參與運算。
系統生成0-4之間的隨機數，表示加減乘除取模運算。
使用switch 進行匹配
class Couter {
public static void main(String[] args) throws InterruptedException {
// 生成隨機數Math.random()生成0-1值，不包含0和1，
//乘以10獲得0和10之間的數（double類型），不包含0和10
//強轉爲int，並加1獲得1和10之間的數，包含1和10
int x = (int)(Math.random()*10)+1;
int y = (int)(Math.random()*10)+1;
System.out.println(x);
System.out.println(y);
// 建立0-4隨機數 0 1 2 3 4 各表示加減乘除取模
int z = (int) (int)(Math.random()*5);
System.out.println(z);
switch (z) {
case 0:
System.out.println(x + "+" + y + "=?");
System.out.println("哥們快猜。。。。");
Thread.sleep(2000);
System.out.println(x + "+" + y + "=" + (x + y));
break;
case 1:
System.out.println(x + "-" + y + "=?");
System.out.println("哥們快猜。。。。");
Thread.sleep(2000);
System.out.println(x + "-" + y + "=" + (x - y));
break;
case 2:
System.out.println(x + "*" + y + "=?");
System.out.println("哥們快猜。。。。");
Thread.sleep(2000);
System.out.println(x + "*" + y + "=" + (x * y));
break;
case 3:
System.out.println(x + "/" + y + "=?");
System.out.println("哥們快猜。。。。");
Thread.sleep(2000);
System.out.println(x + "/" + y + "=" + (x / y));
break;
case 4:
System.out.println(x + "%" + y + "=?");
System.out.println("哥們快猜。。。。");
Thread.sleep(2000);
System.out.println(x + "%" + y + "=" + (x % y));
break;
}
}
}
程序生成了3個隨機數，前兩個數參與運算，第三個數用於匹配運算符。要注意除數爲0的狀況。計算器2：上述中只能計算一次。可使用whileu循環來不停計算。
int x = (int)(Math.random()*10)+1;
Math.random() 生成0-1之間的數字，double類型
Math.random()*10 就是0-9之間的數，是double類型
(int)(Math.random()*10)將double類型強轉成int類型，去掉小數點，便於計算。
(int)(Math.random()*10)+1，生成了1到10之間隨機數。
int z = (int) (int)(Math.random()*5);
生成0-4之間的數字，能夠用0表示加，1表示減，2表示乘，3表示除，4表示取模
爲了減慢程序，使用了Thread.sleep(2000); 讓程序等待一會。
6 、 for 循環
1.格式
：for(初始化表達式；循環條件表達式；循環後的操做表達式)
{
執行語句；
}
2.定義需求: 想要打印5次helloworld
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
System.out.println("hello java");
}
}
for 知道要進行循環，讀到x=0 的時候，在內存中開闢了空間,定義變量x 賦值爲0。接着進行條件判斷 x<5，爲真，這個時候對知足條件後執行了循環體的內容System.out.println("hello java");當循環體執行完畢以後,執行x < 5;後的表達式即 x++ 。x自增後變爲了1 ，再次進行判斷 x<5 (int x=0 只執行一次)，若是爲真就再次運行System.out.println("hello java");若是爲假，for循環結束。3.for的執行流程
二、for 和while的區別
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
System.out.println("hello java");
}
System.out.println(x);
//x cannot be resolved to a variable
int y = 0;
while (y < 5) {
System.out.println("hello world");
y++;
}
System.out.println(y);
}
4. 錯誤
解釋 x 爲何會找不到,注意了變量的做用域,也就是變量的做用範圍。x 只在 for 循環的大括號內有效,出了這個區域，就無效了.在內存中就消失了。x消失後,仍要訪問它,確定會報錯的。
y 就不同了，y 是定義在while 外的。while循環完畢仍有效 while的初始化 動做在外邊，循環結束後y 仍然存在。
當定義的y 只做爲循環增量存在的話的，循環完畢後y就沒有用了，可是y仍是佔着一塊內存。因此，若是定義的變量只做爲循環增量存在的話，就用for 循環能夠節約內存。
其實for 和while 是能夠互換的。
最後總結
一、for裏面的兩個表達式運行的順序，初始化表達式只讀一次，判斷循環條件，爲真就執行循環體，而後再執行循環後的操做表達式，接着繼續判斷循環條件，重複找個過程，直到條件不知足爲止。
二、while與for能夠互換，區別在於for爲了循環而定義的變量在for循環結束時就在內存中釋放。而while循環使用的變量在循環結束後還能夠繼續使用。
三、最簡單無限循環格式：while(true) , for(;;),無限循環存在的緣由是並不知道循環多少次，而是根據某些條件，來控制循環。推薦使用while(true)
while(true){
}
for(;;){
}
for(;true;){
}
for 練習:
- 獲取1-10的和，並打印。
- 1-100之間 7的倍數的個數,並打印。
public static void main(String[] args) {
// 獲取1到10的和1+2+3+4+5+6+7+8+9+10
int sum = 0;
for (int x = 1; x <= 10; x++) {
System.out.println((sum + x) + "=" + sum + "+" + x);
sum = sum + x;
}
System.out.println(sum);// 55
}
public static void main(String[] args) {
// 1-100之間 7的倍數的個數,並打印。
int count = 0;
for (int x = 0; x <= 100; x++) {
if (x % 7 == 0) {
System.out.println(x);
count++;
}
}
System.out.println(count);
}
累加思想：經過變量記錄住循環操做後的結果；經過循環的形式.進行累加的動做。
計數器思想：經過一個變量記錄住數據的狀態變化，也是經過循環完成。
循環常見錯誤：
多加分號：在for括號後和循環體之間加分號是常見錯誤。
錯誤：
程序編譯運行均可以經過，只是否是咱們想要的結果。
for(int i=0;i<100;i++);{
System.out.println("hello ");
}
for(int i=0;i<100;i++){
System.out.println("hello ");
}
正確：
錯誤；是一個死循環
int i=0;
while(i<100);{
System.out.println("hello");
i++;
}
int i=0;
while(i<100){
System.out.println("hello");
i++;
}
正確：
語句的嵌套應用
什麼是嵌套形式，其實就是語句中還有語句。
想要打印出矩形：
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
System.out.println("*");
}
}
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
System.out.print("*");
}
}
這裏用「*」表示矩形的邊。
打印此種格式的圖案
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
for(int y=0;y<6;y++){
System.out.print("*");
}
System.out.println();
}
}
forfor 嵌套for循環練習2
*****
****
***
**
*
public static void main(String[] args) {
for (int x = 5; x > 0; x--) {
for(int y=x;y>0;y--){
System.out.print("*");
}
System.out.println("");
}
}
練習：
*
**
***
****
*****
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
for (int y = 0; y <= x; y++) {
System.out.print("*");
}
System.out.println("");
}
}
練習：99乘法表
public static void main(String[] args) {
for (int x = 1; x <= 9; x++) {
for (int y = 1; y <= x; y++) {
System.out.print(y + "*" + x + "=" + x * y + '\t');
}
System.out.println(" ");
}
}
七、 加強for循環
foreach循環
Java5 引入了一種主要用於數組的加強型 for 循環。
Java 加強 for 循環語法格式以下:
for(聲明語句 : 表達式) {
//代碼句子
}
聲明新的局部變量，該變量的類型必須和數組元素的類型匹配。其做用域限定在循環語句塊，其值與此時數組元素的值相等。聲明語句：
表達式：
表達式是要訪問的數組名，或者是返回值爲數組的方法。
for(數組類型 變量名 : 數組名){
System.out.println(變量名);
}
示例：
int[] a = {1,2,3,4,5,6};
//加強for循環
for(int i : a){
System.out.println(i);
}
break關鍵字：break 語句用於終止最近的封閉循環或它所在的 switch 語句。控制傳遞給終止語句後面的語句（若是有的話）。八、break、continue關鍵字
適用：for循環 、 switch兩種循環語句。
break的用法：
- 單獨使用。
- 與標籤一塊兒使用。(標籤：即一個名字，知足標識符的條件便可)。
使用細節： 不要再break語句以後，編寫其餘語句，永遠都執行不到，編譯報錯。
continue關鍵字：語句將控制權傳遞給它所在的封閉迭代語句的下一次迭代。(跳出本循環，執行下一次循環)。
適用於：while 、 do while 、 for循環語句
使用細節：
1. 若是continue出如今循環的末尾(最後一條語句),那麼能夠省略。
2. 若是continue出如今循環的第一條語句，那麼後面的語句都沒法執行，因此編譯報錯。
3. 能夠結合標記使用。
九、循環標籤
語法：
標籤名 ：
使用：
break 標籤名; 或 continue 標籤名;
示例：
a: for (int i = 1; i <= 10; i++) {
System.out.println("i="+i);
b: for (int j = 1; j <= 10; j++) {
if(j==5){
//continue a;
break a;
}
System.out.println("j="+j);
}
}
標籤名的語法規則要遵循標識符的語法要求；規則：
- break 標籤名 ： 跳出該標籤名後面的循環；
- continue 標籤名： 跳過該標籤名的本次循環，繼續進行下次迭代；
- 1. Python基礎教程，流程控制語句詳解
- 2. PMP-變動控制流程圖詳解
- 3. Node.js中Async詳解:流程控制
- 4. Async詳解之一：流程控制
- 5. Go流程控制與函數詳解
- 6. Python流程控制語句詳解
- 7. PMP-變更控制流程圖詳解
- 8. Java入門教程三(流程控制)
- 9. 《簡明 PHP 教程》06 流程控制
- 10. python教程(五)流程控制
- 更多相關文章...
- • Lua 流程控制 - Lua 教程
- • Git 工作流程 - Git 教程
- • Java 8 Stream 教程
- • YAML 入門教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Python基礎教程，流程控制語句詳解
- 2. PMP-變動控制流程圖詳解
- 3. Node.js中Async詳解:流程控制
- 4. Async詳解之一：流程控制
- 5. Go流程控制與函數詳解
- 6. Python流程控制語句詳解
- 7. PMP-變更控制流程圖詳解
- 8. Java入門教程三(流程控制)
- 9. 《簡明 PHP 教程》06 流程控制
- 10. python教程(五)流程控制