五、Java控制流程
Java流程式控制制*
用戶交互Scanner、Scanner進階使用
用戶交互Scanner
之前我們學習的基本語法中我們並沒有實現程式和人的交互，但是Java給我們提供了這樣一個工具類，我們可以獲取用戶的輸入。java.util.Scanner 是java5的新特徵，我們可以通過Scanner類來獲取用戶的輸入
基本語法：
Scanner s = new Scanner(System.in);
//有些程式碼大家可能不理解，比如這個new，大家目前先不用理解程式碼的意思，先學會跟著操作，之後我們講面向對象的時候你就會逐一明白這些程式碼每一個具體的意思
通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字元串，在讀取前我們一般需要使用 hasNext() 與 hasNexLine() 來判斷是否還有輸入的數據。
下面我們來實踐一下加深理解和記憶
使用next方式讀取：
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args){
//創建一個掃描器對象 用於接收鍵盤數據
//使用IDEA開發工具輸入Scanner之後回車，它就會自動導入這個類import java.util.Scanner;
//我們之前一直用的是System.out是輸出；System.in是輸入
//這裡引用了Scanner數據類型
//通過new Scanner(System.in);接收用戶的輸入，並且把它封裝成了scanner對象
Scanner scanner = new Scanner(System.in);
//輸出一行字
System.out.println("使用next()方法接收：");
//判斷用戶有沒有輸入字元串
//if語句還沒學，if就是如果的意思
//如果scanner這個對象有沒有用戶輸入，（==true不寫就是默認上節課講過，一般新手才會加）有的話就使用執行裡面的語句
if (scanner.hasNext()){
//使用next方式接收用，並封裝給數據類型為String的str變數
String str = scanner.next();
//輸出用戶輸入的內容
System.out.println("輸入的內容為："+str);
}
//凡是屬於IO流的類如果不關閉會一直佔用資源，要養成好習慣用完就關
scanner.close();
}
}
我們運行起來之後，他會顯示使用next方式讀取，然後等待你輸入字元串，我輸入hello world返回輸入的內容為：hello；然後程式結束
String str = scanner.next();這句程式碼執行完程式會等待用戶輸入完畢，如果你沒去輸入數據那麼程式就會一直卡在那
但是有沒有發現我們輸入的hello world它只輸出了一個hello
剛才我們使用的是next()，現在我們使用nextLine()試一下：
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine()方法讀取：");
if (scanner.hasNext()) {
//使用nextLine()方式讀取，並封裝給數據類型為String的str變數
String str = scanner.nextLine();
System.out.println("輸入的內容為："+str);
}
scanner.close();
}
}
這次輸入hello world，返回的也是hello world
那我們來看一下next()和nextLine()兩種接收用戶輸入到底有上面區別
next()：
- 一定要讀取到有效字元後才可以結束輸入。
- 對輸入有效符之前遇到的空白，next()方法會自動去掉
例如我輸入： hello；則返回：hello
-
只有輸入有效字元後才將其後面輸入的空白作為分隔符或結束符
-
next() 不能讀取帶有空格的字元串
nextLine()：
- 以Enter為結束符，也就說 nextLine()方法返回的是輸入回車之前的所有字元
- 可以獲得空白
我們還沒有學習到if上面的程式碼看起來會比較複雜，我下面寫一個不用if語句和判斷用戶輸入方法的的程式碼，讓大家自己分析，我就不寫注釋了
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入數據：");
String str = scanner.nextLine();
System.out.println("輸入的內容為："+str);
scanner.close();
}
}
以上內容請務必掌握！！！
Scanner進階使用
萬一我們需要用戶輸入指定類型的數據，那該怎麼判斷用戶輸入的是否是我們指令類型的數據
我們在IDEA定義好scanner對象後；輸入scanner.後會跳出很多方法出來
比如scanner.hasNextInt() ：這樣就是判斷是否輸入的是Int類型；這樣我們就能配合if…else…語句來使用；if…else…就是如果就否則就的意思。
讀取數據的方法也要變成scanner.nextInt()
下面我們來演示一下
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = 0;
float f = 0.0F;
//提示用戶輸入
System.out.println("請輸入數據：");
//使用hasNextInt()方法判讀用戶輸入的數據是否為Int類型
if (scanner.hasNextInt()) {
//使用nextInt()方法讀取Int數據，並賦值給i(這裡因為i我們上面已經定義了所以不用在指定類型)
i = scanner.nextInt();
System.out.println("輸入的數據為："+i);
}else {
System.out.println("請輸入整數類型的數據!");
String a = scanner.nextLine();
}
//提示用戶輸入
System.out.println("請輸入數據：");
//使用hasNextFloat()方法判讀用戶輸入的數據是否為Float類型
if (scanner.hasNextFloat()) {
//使用nextFloat()方法讀取float數據，並賦值給f(這裡因為f我們上面已經定義了所以不用在指定類型)
f = scanner.nextFloat();
System.out.println("輸入的數據為："+f);
}else {
System.out.println("請輸入小數類型的數據!");
}
scanner.close();
}
}
運行的結果為：
第一種情況：
請輸入數據：
1
輸入的數據為：1
請輸入數據：
1.2
輸入的數據為：1.2
第二種情況
請輸入數據：
xiaodi
請輸入整數類型的數據!
請輸入數據：
xiaodi
請輸入小數類型的數據!
有沒有發現我在第一個if…else…語句中的else中加了一行程式碼
String a = scanner.nextLine();
你不加這行程式碼的話，你運行起來，你第一個數據輸入錯誤了，它會直接將第一個數據拿到第二次做判斷，導致你第二次不能輸入數據。（但是有的地方會有需要這種情況，但是我們這裡測試的話就不用了）
案例：
我們可以輸入多個數字，並求其總和與平均數，每輸入一個數字用回車確認，通過輸入輸入非數字來結束輸入並輸出執行結果
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//和,有可能會輸入小數，所以使用double類型
double sum = 0.0;
//個數，因為最後要求平均值，平均值就是和除以個數
int m = 0;
//使用while循，判斷是否輸入數字，如果是就一直循環獲取用戶輸入，如果不是則退出循環
while (scanner.hasNextDouble()) {
//獲取用戶輸入，並賦值給i
double i = scanner.nextDouble();
//把和加上獲取的輸入
sum = sum + i;
//個數加1
m = m + 1;//m++
System.out.println("您輸入了第"+m+"個數據當前的總和為："+sum);
}
//輸出總和和平均數
System.out.println("您輸入的數據的總和為："+sum);
System.out.println("您輸入的數據的平均數為："+(sum / m));
scanner.close();
}
}
運行結果：
10.5
您輸入了第1個數據當前的總和為：10.5
19.5
您輸入了第2個數據當前的總和為：30.0
30
您輸入了第3個數據當前的總和為：60.0
40
您輸入了第4個數據當前的總和為：100.0
x
您輸入的數據的總和為：100.0
您輸入的數據的平均數為：25.0
其中while循環還不懂沒關係，你先跟著我的程式碼寫一遍，等一下學到你再回來看一下，你就會恍然大悟，原來是這個樣子的！
順序結構
-
Java的基本結構就是順序結構，除非特別指明，否則就按照順序一句一句執行
-
順序結構是最簡單的演算法結構
-
語句與語句之間，框與框之間是按從上到下的順序進行的，它是又若干個依次執行的處理步驟組成的，它是任何一個演算法都離不開的一種基本演算法結構
選擇結構*
if選擇結構
if單選擇結構
我們很多時候需要去判斷一個東西是否可行，然後我們才去執行，這樣一個過程在程式中用if語句來表示
語法：
if (布爾表達式) {
//如果布爾表達式為true將執行的語句，如果為false則跳過if語句
}
演示：
package com.xiaodi.operator.struct;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入內容：");
String s = scanner.nextLine();
//equals：判斷字元串是否一致的方法，是字元串的一種方法
if (s.equals("Hello")) {
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
第一次輸入Hello則執行if語句結果如下：
請輸入內容：
Hello
Hello
End
第二次輸入XiaoDi則跳過if語句結果如下：
請輸入內容：
XiaoDi
End
if雙選擇結構
那現在有一個需求，學校要一個輸入分數來判定學生成績是否及格的程式，>=60分為及格，<60分為不及格。這樣的需求用一個if就搞不定了，我們需要有兩個判斷，需要一個雙選擇結構，所以就要使用if-else結構
語法：
if (布爾表達式) {
//如果布爾表達式值為true執行的程式碼
}else {
//如果布爾表達式值為false執行的程式碼
}
演示：
package com.xiaodi.operator.struct;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入你的分數：");
int score = scanner.nextInt();
if (score>=60) {
System.out.println("及格");
}else {
System.out.println("不及格");
}
scanner.close();
}
}
第一個同學考了10分(走了else的分支)結果如下：
請輸入你的分數：
10
不及格
第二個同學考了90分(走了if的分支)結果如下：
請輸入你的分數：
90
及格
if多選擇結構
我們發現剛才的程式碼不符合實際情況，真實的情況還可能存在SABCD，存在區間多級判斷。比如90-100就是S，80-90就是B..等等，在生活中我們很多時候的選擇也不僅僅只有兩個，所以我們需要一個多選擇結構來處理這類問題!
語法：
if (布爾表達式1){
//如果布爾表達式1的值為true執行的程式碼
}else if {
//如果布爾表達式2的值為true執行的程式碼
}else if {
//如果布爾表達式2的值為true執行的程式碼
}else {
//如果以上布爾表達式都不為true執行的程式碼
}
演示：
package com.xiaodi.operator.struct;
import java.util.Scanner;
import java.util.SortedMap;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入你的成績：");
int score = scanner.nextInt();
if (score<40 && score>=0) {
System.out.println("你的成績評級為：D");
}else if (score>=40 && score<60) {
System.out.println("你的成績評級為：C");
}else if (score>=60 && score<80) {
System.out.println("你的成績評級為：B");
}else if (score>=80 && score<90) {
System.out.println("你的成績評級為：A");
}else if (score>=90 && score<=100) {
System.out.println("你的成績評級為：S");
}else {
System.out.println("本次評級的分數為0-100,請輸入正確的成績");
}
scanner.close();
}
}
太多分支，可以自己執行看看！我這裡就不演示執行結果了！會使文章看起來怪怪的
嵌套的if結構
使用嵌套的if…else語句是合法的。也就是你可以在另一個if或 else if語句中使用if或else if語句，你可以像if語句一樣嵌套else if…else
語法：
if (布爾表達式1) {
//如果布爾表達式1的值為true執行的程式碼
if (布爾表達式2) {
//如果布爾表達式2的值為true執行的程式碼
}
}
有時候我們在解決一些問題的時候，可以縮小操作範圍，它可以通過層級來判斷，提高效率
比如我們現在有一個需求：要查找1-100之間這樣的一個數字，這樣的話是比較麻煩的；
我們最笨的方法就是將用戶輸入的數字去1-100之間一個一個的對比，但是萬一他輸入了100，那程式就要對比到100才能成功，這樣就會花費更多的資源和時間；我們就可以用if嵌套來判斷，把這個100分成1-50，50-100去判斷用戶輸入的值在哪個裡面，或者分成更多份去判斷；
我們生活在這個大數據時代，我們應該不斷去思考如何提高我們程式的效率，或許哪一天你就想出來了能夠提高效率的演算法那你將在程式的歷史上留下一些痕迹了！
記住一點：我們流程式控制制語句都可以相互嵌套而互不影響
Switch選擇結構
多選擇結構還有一個實現方法就是switch case語句。
switch case 語句判斷一個變數與一系列值中某個值是否相等，每個值稱為一個分支
語法：
switch(expression) {
case value :
//語句
break; //可選
case value :
//語句
break //可選
default : //可選
語句
}
switch語句中的變數類型可以是：
byte、short、int或char
從Java SE7開始，switch支援String類型了
同時case標籤必須在為字元串常量或字面量
演示：
package com.xiaodi.operator.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
char grade = 'C';
switch (grade) {
case 'A' :
System.out.println("優秀");
break; //可選
case 'B' :
System.out.println("良好");
case 'C' :
System.out.println("及格");
case 'D' :
System.out.println("再接再厲");
case 'E' :
System.out.println("掛科");
}
}
}
當grade為C時運行如下：
及格
再接再厲
掛科
當grade為A時運行如下：
優秀
為什麼會這樣，我說過這個break是可選的，如果不寫break他就會執行匹配到的分支以及後面的分支直到遇到break，如果沒遇到，就會直接執行到最後；這種現象叫做case穿透；(所以要養成一個好習慣，寫完每一個case後面都應該加一個break(除非特殊需求))
我們還可以來一個default
package com.xiaodi.operator.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
char grade = 'F';
switch (grade) {
case 'A' :
System.out.println("優秀");
break; //可選
case 'B' :
System.out.println("良好");
break; //可選
case 'C' :
System.out.println("及格");
break; //可選
case 'D' :
System.out.println("再接再厲");
break; //可選
case 'E' :
System.out.println("掛科");
break; //可選
default :
System.out.println("未知等級");
}
}
}
當grade不等於任何一個case的時候就會執行default分支;
跟if比起來switch是有一些好處的，它在執行case語句的時候會先匹配，匹配成功就會返回當前case的值，然後再根據它是否有break判斷是否繼續輸出。if是判斷匹配區間，而switch是匹配一個具體的值！
接下來演示JDL7開始才支援的字元串類型：
package com.xiaodi.operator.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "曉迪";
switch (name) {
case "小迪" :
System.out.println("小迪");
break;
case "曉迪" :
System.out.println("曉迪");
break;
default :
System.out.println("神馬東西？？");
}
}
}
運行結果為：曉迪
還記不記得我之前講過字元的本質還是數字，給大家講一個東西反編譯
什麼叫反編譯：比如.java文件編譯成.class文件，這個class文件叫做位元組碼文件是人類看不懂的，我們要看懂就要進行反編譯
反編譯教程：
使用IDEA，點開享目結構(File–>Project Structure)，就能看到Compiler output，將地址複製到文件管理器，打開找對對應需要反編譯的文件，你可以使用notepad++打開看一下，你會發現看不懂，沒事我也看不懂。
在IDEA文件夾那邊右鍵，選擇Open ln，再選擇Explorer打開對應文件夾，把class文件複製進去，在IDEA雙擊這個位元組碼文件，選擇Accept，這個就是反編譯之後的
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.xiaodi.operator.struct;
public class SwitchDemo02 {
public SwitchDemo02() {
}
public static void main(String[] args) {
String name = "曉迪";
byte var3 = -1;
switch(name.hashCode()) {
case 767419:
if (name.equals("小迪")) {
var3 = 0;
}
break;
case 848887:
if (name.equals("曉迪")) {
var3 = 1;
}
}
switch(var3) {
case 0:
System.out.println("小迪");
break;
case 1:
System.out.println("曉迪");
break;
default:
System.out.println("神馬東西？？");
}
}
}
你會發現 switch (name) {} 變成了 switch(name.hashCode()) {} ； case “曉迪” : 變成了 case 848887: ，也就是說它進行編譯之後是通過hashCode()進行判斷的，什麼是hashCode()，你現在可以理解為每一個對象都有一個hashCode，它是通過一些特定演算法生成的，而我們case後面的字元串中文都會有一個自己對應的hash值，然後它就判斷這個hash值是否跟name的hash值相同，這就是JDK7新特性的原理
循環結構*
while 循環
while是最基本的循環，她的結構為：
while (布爾表達式) {
//循環內容
}
- 只要布爾表達式為 true ，循環就會一直執行下去。
- 我們大多數情況會讓循環停止下來，我們需要一個讓表達式失效的方式來結束循環
- 少部分情況需要循環一直執行，比如伺服器的請求響應監聽等
- 循環條件一直為true就會造成無限循環【死循環】，我們正常的業務編程中應該盡量避免死循環。會影響程式性能或者造成程式卡死崩潰！
演示輸出1-100：
package com.xiaodi.operator.struct;
public class WhileDemo01 {
public static void main(String[] args) {
int i = 0;
while (i<100) {
i++;//i = i + 1;
System.out.println(i);
}
}
}
運行會輸出1-100
演示死循環：
package com.xiaodi.operator.struct;
public class WhileDemo02 {
public static void main(String[] args) {
while (true) {
System.out.println(1);
}
}
}
運行會無限輸出1 直到程式崩潰
演示：計算1+2+3+…+100=？
package com.xiaodi.operator.struct;
public class WhileDemo03 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
while (i<100) {
i++;
sum = sum + i;
}
System.out.println(sum);
}
}
結果5050
其中while循環還能像下面這樣寫自己思考一下有什麼不同
while (i<=100) {
sum = sum + i;
i++;
}
do..while 循環
- 對於 while 循環而言，如果不滿足條件，則不能進入循環。但有時候我們需要即使不滿足條件，也至少執行一次。
- do…while 循環和 while 循環相似，不同的是，do…while 循環至少會執行一次。
語法：
do {
//程式碼語句
}while (布爾表達式);
同樣是1+2+3…+100，看看DoWhile是怎麼實現的吧！
package com.xiaodi.operator.struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
i++;
sum = sum + i;
}while (i<100);
System.out.println(sum);
}
}
While和do-While的區別：
- while先判斷後執行。dowhile是先執行後判斷！
- Do…while總是保證循環體會被至少執行一次！這是他們的主要差別。
演示：兩者區別
package com.xiaodi.operator.struct;
public class DoWhileDemo02 {
public static void main(String[] args) {
int a = 0;
int sum = 0;
while (a<0) {
System.out.println(a);
a++;
}
System.out.println("===========");
do {
System.out.println(a);
a++;
}while (a<0);
}
}
輸出結果為：
===========
0
for 循環
-
雖然所有的循環結構都可以用while或者do…while表示，但java提供了另一種語句 for循環，使一些循環結構變得更加簡單
-
for循環語句是支援迭代的一種通用結構,是最有效、最靈活的循環結構
-
在IDEA直接輸入100.for然後回車能快捷生成
-
for循環執行的次數是在執行前就確定的。語法格式如下：
for (初始化;布爾表達式;迭代) {
//程式碼語句
}
實例：
package com.xiaodi.operator.struct;
public class ForDemo01 {
public static void main(String[] args) {
int a = 1;//初始化條件
while (a<=100) { //布爾表達式
System.out.println(a);//輸出a
a+=2; //迭代
}
System.out.println("while循環結束");
//初始化;布爾表達式;迭代
for (int i=0;i<=100;i++) {
System.out.println(i);
}
System.out.println("For循環結束");
}
}
for的死循環
package com.xiaodi.operator.struct;
public class ForDemo02 {
public static void main(String[] args) {
for (;;) {
}
}
}
練習1：計算0-100之間的基數和偶數的和；
package com.xiaodi.operator.struct;
public class ForDemo03 {
public static void main(String[] args) {
int oddSum = 0;
int evenSum = 0;
for (int i=0;i<100;i++) {
if (i%2!=0) { //奇數
oddSum+=i;
}else { //偶數
evenSum+=i;
}
}
System.out.println("0-100之間的奇數和："+oddSum);
System.out.println("0-100之間的偶數和："+evenSum);
}
}
練習2：用while或for循環輸出1-1000之間能被5整除的數，並且每行輸出3個
第一種方法：
package com.xiaodi.operator.struct;
public class ForDemo04 {
public static void main(String[] args) {
for (int i=0;i<1000;i++) {
if (i%5==0) {
System.out.print(i+"\t");
}
if (i%(3*5)==0) {
System.out.println();
//System.out.print("\n");
}
}
//println 輸出完會換行
//print 輸出完不會換行
}
}
第二種方法：
package com.xiaodi.operator.struct;
public class ForDemo04_1 {
public static void main(String[] args) {
for (int i = 0; i < 1000; i+=5) {
System.out.print(i+"\t");
if (i%(3*5)==0) {
System.out.println();
}
}
}
}
這些練習不一定要用我寫的方法才能實現，大家也可以多思考，主要思路肯定是循環
至於我為什麼這題要寫兩種方法呢？
- 第一種使用的是i++每次只+1，需要循環1000次，第二種使用的是直接+5，只需循環200次即可，如果遇到非常大的數據時可以減少%75的資源，這是一件很好的事情哈
我們可以在不影響程式正常工作的條件下，減少程式運行所需資源
練習3：列印99乘法表
package com.xiaodi.operator.struct;
//效果如下
//1*1=1
//1*2=2 2*2=4
//1*3=3 2*3=6 3*3=9
//1*4=4 2*4=8 3*4=12 4*4=16
//1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
//1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
//1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
//1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
//1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
public class ForDemo05 {
public static void main(String[] args) {
//1、我們先列印第一列，這個大家應該都會
//for (int i = 1; i <= 9; i++) {System.out.println("1*"+i+"="+(1*i));}
//2、我們把固定的1再用一個循環包起來
//使用for (int j = 1; j <= 9; j++) {}把上面的包起來 把固定的1換成循環的j
//3、去掉重複項，
//i<=j
//4、調整樣式
//使用print使其不換行 間隔用"\t"
//裡面的循環每次完成一次則輸出一次換行 System.out.println();
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(i+"x"+j+"="+(j*i) + "\t");
}
System.out.println();
}
}
}
這道題主要學習思路，學會把一個大問題拆分成若干個小問題，逐一攻破！，這也是我們以後開發項目的一個基本思路！
增強型for循環
- 這裡我們先只是先見一面，做個了解，之後數組我們重點使用
- Java5引入了一種主要用於數組或集合的增強型 for循環。
語法：
for (聲明語句 : 表達式) {
//程式碼句子
}
聲明語句：聲明新的局部變數，該變數的類型必須和數組元素的類型匹配，其作用域限定在循環語句塊，其值與此時數組元素的值相等
表達式：表達式是要訪問的數組名，或者是返回值為數組的方法。
演示：
package com.xiaodi.operator.struct;
public class ForDemo06 {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50}; //定義了一個數組
//遍曆數組的元素
for (int x:numbers) {
System.out.println(x);
}
}
}
分析：把numbers這個數組每一項遍歷出來，賦值給int x，每次循環x就從numbers中取值
我們用普通for循環演示一下 上面的操作，上面使用的增量型for循環就是用來簡化下面的操作，核心原理是一樣的，大家簡單理解一下
package com.xiaodi.operator.struct;
public class ForDemo07 {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
for (int i = 0;i<5;i++) {
System.out.println(numbers[i]);
}
}
}
現在能理解當然是最好的了，不理解也沒關係，我們現在只是讓大家知道一下我們以後會學一個這樣簡化的東西！不理解不必深究！
break &continue*
- break在任何循環語句的主體部分，均可用break控制循環的流程。break用於強行退出循環，不執行循環中剩餘的語句。（break語句也在switch’語句中使用）
演示：
package com.xiaodi.operator.struct;
public class BreakDemo01 {
public static void main(String[] args) {
int i = 0;
while (i<100) {
i++;
System.out.println(i);
if (i==30) { //如果i等於30的時候，則跳出循環體
break;
}
}
System.out.println("123"); //證明break只是跳出循環體
}
}
break只是跳出循環，程式還會繼續執行。
- continue 語句用在循環語句體中，用於終止某次循環過程，即跳過循環體中尚未執行的語句，接著進行下一次是否執行循環的判定。
演示：
package com.xiaodi.operator.struct;
public class ContinueDemo01 {
public static void main(String[] args) {
int i = 0;
while (i<100) {
i++;
if ((i%10)==0) { //如果i能被10整除，則輸出換行，然後跳過當前這次循環
System.out.println();
continue;
}
System.out.print(i+"\t");
}
}
}
通過上面的演示，break可以理解為，我不幹了；continue可以理解為，我不幹了第二天又慫了又回來繼續干
練習
列印5行的三角形
解題思維：
我們把三角形切一下，然後分部完成
第一步列印1
package com.xiaodi.operator.struct;
public class TestDemo01 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print("*");
}
System.out.println();
}
}
}
第二部列印2，然後把第一步列印的內容變為空格
package com.xiaodi.operator.struct;
public class TestDemo01 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
第三步列印第三部分
package com.xiaodi.operator.struct;
public class TestDemo01 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
如果不理解使用IDEA中的Debug
在你不理解的行開始打上斷點，就是在行號後面點一下，然後點擊小蟲子圖標，然後程式運行到斷點會停住，然後通過↓這個符號一步一步的去運行下去，去一步一步理解！點擊console能看見當前輸出的結果
這個提主要還是學思維哈，一定要去認真的理解一下，Debug也要學起來
