# 【循環跳轉、循環嵌套、隨機數】
##### 今日復習指南
~~~
1.break和continue(0.5個小時內完成,20%的內容搞定)
(1)Demo02Break.java 測試break的使用
(2)Demo04Continue.java ?測試continue的使用 ? ? ?
?
2.循環嵌套(半個小時內完成,20%的內容搞定):
Demo01ForFor.java 測試循環嵌套的執行流程 ? ?教練安排運動員跑圈
? ? ? ?
3.隨機數(半個小時內完成,20%的內容搞定):
? ?Demo02Random.java 隨機數字的練習
? ? ? ?
4.猜數字游戲案例(1個小時內完成,40%的內容搞定):
Demo03GuessNum.java
~~~
##### 今日內容
~~~
跳出語句break，continue【重點】
循環嵌套【理解】
隨機數字【重點：死格式】
猜數字案例【重點中的重點】
~~~
### 第一章 循環跳轉【理解】
##### 1.1 break的介紹
~~~
break作用:
1.可以使用在switch語句中,結束switch語句
2.可以使用在循環中,結束循環
(1)本次循環不再執行
(2)無論剩余多少次循環,也不再執行,相當于從循環中跳出來,執行循環后面的其它代碼
3.break不能使用在除了switch和循環之外的其它位置
~~~
##### 1.2 break的使用
~~~
public class Demo01Break {
? ?public static void main(String[] args) {
? ? ? ?//break;//錯誤的: 只能寫在循環或者switch內部
?
? ? ? ?for(int i = 1;i<=4;i++) {
? ? ? ? ? ?/*
? ? ? ? ? ? ? ?當i的值等于2時: if后面()中是true,執行if后面{}中的代碼
? ? ? ? ? ? ? ?首先: 執行輸出語句
? ? ? ? ? ? ? ?其次: 執行break,一旦執行break,本次循環的循環體中break后面的代碼將不再執行,
? ? ? ? ? ? ? ?剩余次數的循環也不再執行,直接從循環內部跳出到循環后面的其它語句執行(找老板投訴)
?
? ? ? ? ? ? */
? ? ? ? ? ?if(i==2) {
? ? ? ? ? ? ? ?System.out.println("發現2號包子有個大家伙," +
? ? ? ? ? ? ? ? ? ? ? ?"非常氣憤直接找老板投訴~~~~");
? ? ? ? ? ? ? ?break;
? ? ? ? ? }
?
? ? ? ? ? ?System.out.println("顧客吃完第"+i+"個包子");
? ? ? }
?
? ? ? ?System.out.println("老板: 非常抱歉,給您賠償2萬元");
? }
?
}
?
~~~
##### 圖解分析：
##### 1.3 break的練習
~~~
/*
? ?break的練習
*/
public class Demo02Break {
? ?public static void main(String[] args) {
?
? ? ? ?for (int i = 1; i <= 10; i++) {
? ? ? ? ? ?/*
? ? ? ? ? ? ? ?當i的值等于5時: if后面()中是true,執行if后面{}中的代碼
? ? ? ? ? ? ? ?就執行break,一旦執行break,本次循環的循環體中break后面的代碼將不再執行,
? ? ? ? ? ? ? ?剩余次數的循環也不再執行,直接從循環內部跳出到循環后面的其它語句執行(找老板投訴)
?
? ? ? ? ? ? */
? ? ? ? ? ?if (i % 5 == 0) {
? ? ? ? ? ? ? ?break;
? ? ? ? ? }
? ? ? ? ? ?System.out.println("HelloWorld...." + i);
? ? ? }
? ? ? ?System.out.println("main...end...");
? }
}
?
~~~
##### 圖解分析：
##### 1.4 continue的介紹
~~~
continue的作用:
1.只能使用在循環中,用來提前結束本次循環,繼續進行下一次循環
2.不能使用在除了循環以外的其它位置
~~~
##### 1.5 continue的使用
~~~
public class Demo03Continue {
? ?public static void main(String[] args) {
? ? ? ?//continue;//錯誤的: 只能寫在循環內部
?
? ? ? ?for(int i = 1;i<=4;i++) {
? ? ? ? ? ?/*
? ? ? ? ? ? ? ?當i的值等于2時: if后面()中是true,執行if后面{}中的代碼
? ? ? ? ? ? ? ?首先: 執行輸出語句
? ? ? ? ? ? ? ?其次: 執行continue,一旦執行continue,本次循環的循環體中continue后面的代碼將不再執行,
? ? ? ? ? ? ? ?繼續進行執行下一次循環的操作(步進表達式)
?
? ? ? ? ? ? */
? ? ? ? ? ?if(i==2) {
? ? ? ? ? ? ? ?System.out.println("把2號包弄臟了," +
? ? ? ? ? ? ? ? ? ? ? ?"2號包子不能吃了,繼續吃其它包子");
?
? ? ? ? ? ? ? ?continue;
?
? ? ? ? ? }
?
? ? ? ? ? ?System.out.println("顧客吃完第"+i+"個包子");
? ? ? }
?
? ? ? ?System.out.println("找老板結賬....");
? }
?
}
~~~
##### 圖解分析：
##### 1.6 continue的練習
~~~
public class Demo04Continue {
? ?public static void main(String[] args) {
?
? ? ? ?for (int i = 1; i <= 10; i++) {
? ? ? ? ? ?/*
? ? ? ? ? ? ? ?當i的值等于5或者10時: if后面()中是true,執行if后面{}中的代碼
? ? ? ? ? ? ? ?就執行continue,一旦執行continue,本次循環的循環體中continue后面的代碼將不再執行(被跳過),
? ? ? ? ? ? ? ?繼續進行執行下一次循環的操作(步進表達式)
?
? ? ? ? ? ? */
? ? ? ? ? ?if (i % 5 == 0) {
?
? ? ? ? ? ? ? ?continue;
?
? ? ? ? ? }
?
? ? ? ? ? ?System.out.println("HelloWorld..." + i);
?
? ? ? }
?
? ? ? ?System.out.println("main...end...");
? }
}
~~~
##### 圖解分析：
### 第二章 循環擴展知識點【理解】
##### 2.1 循環嵌套的概念和格式
~~~
1.概念: 使用一個循環作為另外一個循環的循環體,外面的循環稱為外層循環,內部的循環稱為內層循環
2.格式(for嵌套):
for(外初始化表達式1;外布爾表達式2;外步進表達式7) {
for(內初始化表達式3;內布爾表達式4;內步進表達式6){
內循環體5;
}
}
其它語句;
3.執行流程:
1,2(外層循環條件:true)
3,4(內層循環條件:true),5,6 --> 4(內層循環條件:true),5,6 --> ... --> 直到4(內層循環條件:false),說明內層循環結束, 執行7(外層循環的步進表達式)
2(外層循環條件:true)
3,4(內層循環條件:true),5,6 --> 4(內層循環條件:true),5,6 --> ... --> 直到4(內層循環條件:false),說明內層循環結束, 執行7(外層循環的步進表達式)
...
2(外層循環條件:false),結束外層for循環,執行外層for循環后面的其它語句
~~~
##### 執行流程圖解:
~~~
/*
練習: 教練安排運動員跑圈,總共跑3次,每次跑3圈
1.問題:
(1)外層循環的初始化表達式 int i = 1 執行了幾次? 1次
(2)內層循環的初始化表達式 int j = 1 執行了幾次? 3次
(3)內層循環的循環體(運動員跑圈) 執行了幾次? 9次
外層循環次數*內層循環每遍執行的次數
= 3 * 3 = 9
2.總結: 外層循環每執行一次,內層循環要執行完整的一遍(從內層循環的初始化表達式開始)
*/
public class Demo01ForFor {
public static void main(String[] args) {
/*
外層循環第一次: i的值1, i<=3 --> 1<=3 --> true,執行外層循環的循環體(內層循環)
內層循環:
j: 1,2,3 --> j<=3 --> true,執行內層循環的循環體
j: 4 --> j<=3 --> false, 結束內層循環,執行外層循環的步進表達式i++,i變成2
外層循環第二次: i的值2, i<=3 --> 2<=3 --> true,執行外層循環的循環體(內層循環)
內層循環:
j: 1,2,3 --> j<=3 --> true,執行內層循環的循環體
j: 4 --> j<=3 --> false, 結束內層循環,執行外層循環的步進表達式i++,i變成3
外層循環第三次: i的值3, i<=3 --> 3<=3 --> true,執行外層循環的循環體(內層循環)
內層循環:
j: 1,2,3 --> j<=3 --> true,執行內層循環的循環體
j: 4 --> j<=3 --> false, 結束內層循環,執行外層循環的步進表達式i++,i變成4
外層循環第四次: i的值4, i<=3 --> 4<=3 --> false,結束外層循環,不會再執行內層循環
*/
for(int i = 1;i<=3;i++) {//外層循環: 教練控制運動員跑圈的次數
System.out.println("教練安排運動員跑第"+i+"次,跑3圈");
for(int j = 1;j<=3;j++){//內層循環: 控制運動員每次跑的圈數
System.out.println((" 運動員跑第"+i+"次第" + j + "圈"));
}
}
}
}
~~~
##### 循環嵌套概念圖解:
##### 2.2 循環嵌套打印月份
~~~
需求:
使用嵌套循環，打印2021年至2023年月份，格式：xxxx年x月
/*
需求:
使用嵌套循環，打印2021年至2023年月份，格式：xxxx年x月
問題:
1.外層循環的初始化表達式 int year = 1 執行了幾次? 1次
2.內層循環的初始化表達式 int month = 1 執行了幾次? 3次
3.內層循環的循環體(運動員跑圈) 執行了幾次?
外層循環次數*內層循環每遍執行的次數
= 3 * 12 = 36
總結: 外層循環每執行一次,內層循環要執行完整的一遍(從內層循環的初始化表達式開始)
*/
public class Demo02ForForMonth {
public static void main(String[] args) {
for (int year = 2021; year <= 2023; year++) {//外層循環: 控制年份 2021到2023年
for (int month = 1; month <= 12; month++) {//內層循環: 控制月份,每年都有12個月 從1月到12月
System.out.println(year+"年"+month+"月");
}
}
System.out.println("main...end...");
}
}
~~~
##### 圖解分析:
##### 2.3 循環嵌套模擬鐘表
~~~
需求:
模擬鐘表的時針和分針
時針(外層循環)走一個格,分鐘(內層循環)走一圈
對應:
外層循環執行一次,內層循環執行完整的一遍
/*
需求:
模擬鐘表的時針和分針
時針(外層循環)走一個格,分鐘(內層循環)走一圈
對應:
外層循環執行一次,內層循環執行完整的一遍
問題:
1.外層循環的初始化表達式 int hour = 0 執行了幾次? 1次
2.內層循環的初始化表達式 int minute = 0 執行了幾次? 24次
3.內層循環的循環體(打印幾點幾分) 執行了幾次?
外層循環次數*內層循環每遍執行的次數
= 24 * 60 = 1440
總結: 外層循環每執行一次,內層循環要執行完整的一遍(從內層循環的初始化表達式開始)
最后打印的最大時間是什么?
23點59分
*/
public class Demo03ForForClock {
public static void main(String[] args) {
for (int hour = 0; hour < 24; hour++) {//外層循環: 控制每天的24小時
for (int minute = 0; minute < 60; minute++) {//內層循環: 控制每小時的60分鐘
System.out.println(hour+"點"+minute+"分");
}
}
System.out.println("main....end....");
}
}
~~~
##### 圖解分析:
### 第三章 隨機數【重點】
##### 3.1 隨機數Random的介紹
~~~
1.概念: java.util包中有個類Random,就是專門用來產生隨機數字的
2.隨機數Random類的使用步驟:
java.util.Random類和java.util.Scanner類都屬于引用類型,使用步驟相同,都是3個步驟
(1)導包(找到我們要使用的類):
格式: import 包名.類名;
注意:
a.java.lang包中的類,不用導包,可以直接使用
b.當前類和要使用的類,處于同一個包中,不用導包
c.快捷鍵: alt + 回車
Random類的導包: import java.util.Random;
(2)創建對象
格式: 類名 對象名 = new 類名(...);
類名: class關鍵字后面的名字叫做類名
創建鍵盤錄入Scanner類的對象: Scanner sc = new Scanner(System.in);
注意: System.in目前是固定寫法,先記住
創建產生隨機數的Random類的對象: Random r = new Random();
注意: 右側()中什么都不用寫,目前是固定寫法,先記住
(3)使用:
r.nextInt(): 產生一個int范圍(正負21億)內的隨機數字 使用不多
r.nextInt(int類型整數數字n): 產生一個0(包含)到n(不包含n)之間的隨機整數數字
舉例:
r.nextInt(10): 產生一個0(包含)到10(不包含10)之間的隨機數字
[0,10): 從0(包含)開始到10(不包含)
等價于
[0,9]: 從0(包含)開始到9(包含)
3.練習:
(1)產生10個int范圍內的整數數字
(2)產生10個0到100之間(包含0,但是不包含100)的整數數字
(3)產生10個1到100之間(包含1,包含100)的整數數字
~~~
##### 3.2 Random類的使用
~~~
public class Demo01Random {
public static void main(String[] args) {
//創建產生隨機數字的Random類的對象
Random r = new Random();
//(1)產生10個int范圍內的整數數字
for (int i = 0; i < 10; i++) {
//產生1個int范圍內的整數數字
int num = r.nextInt();
System.out.println(num);
}
System.out.println("-----------");
//(2)產生10個0到100之間(包含0,但是不包含100)的整數數字
for (int i = 0; i < 10; i++) {
//while(true) {
//產生1個0到100之間(包含0,但是不包含100)的整數數字
int num = r.nextInt(100);//()中寫100,產生隨機數字的范圍0(包含0)到100(不包含)
System.out.println(num);
/*if (num == 100) {
break;
}*/
}
System.out.println("-----------");
//(3)產生5個1到5之間(包含1,包含5)的整數數字
/*
如果可以產生這些數字: 0,1,2,3,4 --->[0,4] --> [0,5) --> r.nextInt(5)
對這些數字執行加1: +1
加1后的結果: 1,2,3,4,5 --->[0,4] + 1 --> [0,5) + 1 --> r.nextInt(5) + 1
*/
for (int i = 0; i < 5; i++) {
//產生一個[0,5)之間的隨機數字
/*int num = r.nextInt(5);//可能性: 0,1,2,3,4
//再把num中的數字額外增加1
int num2 = num + 1;//可能性: 1,2,3,4,5
System.out.println(num2);*/
int num3 = r.nextInt(5) + 1;
System.out.println(num3);
}
System.out.println("----------------");
//(4)產生10個1到100之間(包含1,包含100)的整數數字
/*
[1,100] --> [0,99] + 1 --> [0,100) + 1 --> r.nextInt(100) + 1
*/
for (int i = 0; i < 10; i++) {
//產生1個1到100之間(包含1,包含100)的整數數字
int num = r.nextInt(100) + 1;
System.out.println(num);
}
}
}
~~~
~~~
/*
Random類的練習
1.產生10個0到100之間(包含0,但是不包含100)的整數數字
2.產生10個1到100之間(包含1,包含100)的整數數字
3.產生10個88到188之間(包含88,包含188)的整數數字
*/
public class Demo02Random {
public static void main(String[] args) {
//創建產生隨機數字的Random類的對象
Random r = new Random();
//1.產生10個0到100之間(包含0,但是不包含100)的整數數字
for (int i = 0; i < 10; i++) {
//產生1個0到100之間(包含0,但是不包含100)的整數數字
int num = r.nextInt(100);//()中寫100,產生的范圍: 0(包含)到100(不含100)
System.out.println(num);
}
System.out.println("-----------------");
//2.產生10個1到100之間(包含1,包含100)的整數數字
/*
如果可以產生: 0,1,2,3,... 99
額外增加1: +1
結果: 1,2,3,4,... 100
總結:
[1,100] --> [0,99] +1 --> [0,100) + 1 --> r.nextInt(100) + 1
*/
for (int i = 0; i < 10; i++) {
//產生1個1到100之間(包含1,包含100)的整數數字
int num = r.nextInt(100) + 1;
System.out.println(num);
}
System.out.println("-----------------");
//3.產生10個88到188之間(包含88,包含188)的整數數字
//[88,188] --> [0,100] + 88 --> [0,101) + 88
for (int i = 0; i < 10; i++) {
//產生1個88到188之間(包含88,包含188)的整數數字
int num = r.nextInt(101) + 88;
System.out.println(num);
}
System.out.println("-----------------");
//證明上面的公式,確實可以產生88和188的數字
while(true) {
int num = r.nextInt(101) + 88;
System.out.println(num);
if (num == 88 || num == 188) {
break;
}
}
}
}
~~~
##### 3.3 Random練習-猜數字
~~~
1.需求：程序自動生成一個1-100之間(包含1,包含100)的數字，使用程序實現猜出這個數字是多少？
2.效果：
如果猜的數字比真實數字大，提示你猜的數據大了
如果猜的數字比真實數字小，提示你猜的數據小了
如果猜的數字與真實數字相等，提示恭喜你猜中了
3.使用的知識點:
(1)使用Random類產生一個隨機數字(1.導包 2.創建對象 3.調用nextInt(...))
(2)使用Random類獲取鍵盤錄入的用戶猜測的數字(1.導包 2.創建對象 3.調用nextInt())
(3)用戶多少次可以猜對,不確定,循環次數不確定,使用while(true)
(4)使用if語句的第三種格式,比較兩個變量中數據值的大小關系
(5)如果猜對了,需要停止循環 break
4.實現步驟:
(1)創建產生隨機數字的Random類的對象
(2)使用Random類的對象產生一個1-100之間(包含1,包含100)的數字,保存到int變量guessNum中,以供用戶猜測
(3)創建鍵盤錄入Scanner類的對象
(4)用戶多少次可以猜對,次數是不確定的,循環次數不確定,使用while(true)或者for(;;) 推薦使用while(true)
//步驟(5)到(6)是一個循環過程,循環次數不確定,放入到while(true)中
(5)獲取鍵盤錄入的用戶猜測的整數數字,保存到int變量inputNum中
(6)使用if語句的第三種格式,比較用戶猜測的數字和產生的隨機數字的大小關系
a.如果 用戶猜測的數字 inputNum 大于 產生的隨機數字 guessNum : 提示 "你猜的數據大了"
b.如果 用戶猜測的數字 inputNum 小于 產生的隨機數字 guessNum : 提示 "你猜的數據小了"
c.如果 用戶猜測的數字 inputNum 等于 產生的隨機數字 guessNum : 提示 "恭喜你猜中了",并且結束循環
~~~
##### 圖解分析:
##### 實現代碼:
~~~
public class Demo03GuessNum {
public static void main(String[] args) {
//(1)創建產生隨機數字的Random類的對象
Random r = new Random();
//(2)使用Random類的對象產生一個1-100之間(包含1,包含100)的數字,保存到int變量guessNum中,以供用戶猜測
//[1,100] --> [0,99] + 1 --> [0,100) + 1 --> r.nextInt(100) + 1
int guessNum = r.nextInt(100) + 1;
//(3)創建鍵盤錄入Scanner類的對象
Scanner sc = new Scanner(System.in);
//(4)用戶多少次可以猜對,次數是不確定的,循環次數不確定,使用while(true)或者for(;;) 推薦使用while(true)
//步驟(5)到(6)是一個循環過程,循環次數不確定,放入到while(true)中
while (true) {
//(5)獲取鍵盤錄入的用戶猜測的整數數字,保存到int變量inputNum中
System.out.println("請輸入您猜測的數字(1-100之間的整數):");
int inputNum = sc.nextInt();
//(6)使用if語句的第三種格式,比較用戶猜測的數字和產生的隨機數字的大小關系
if(inputNum > guessNum) {
//a.如果 用戶猜測的數字 inputNum 大于 產生的隨機數字 guessNum
//提示 "你猜的數據大了"
System.out.println("你猜的數據大了");
} else if(inputNum < guessNum) {//b.如果 用戶猜測的數字 inputNum 小于 產生的隨機數字 guessNum
//提示 "你猜的數據小了"
System.out.println("你猜的數據小了");
} else {
//c.如果 用戶猜測的數字 inputNum 等于 產生的隨機數字 guessNum : 提示 "恭喜你猜中了"
System.out.println("恭喜你猜中了");
//并且結束循環
break;
}
}
}
}
~~~
##### 總結
~~~
能夠知道循環嵌套的執行流程
外層循環第一次: i的值是1 i<=2 --> 1<=2 --> true --> 執行外層循環的循環體(內層for循環)
內層循環:
j:1,2,3 --> j<=3 --> true 執行內層循環的循環體
j:4 --> j<=3 --> 4<=3 false 結束內層循環,執行外層循環的步進表達式i++,導致i的值是2
外層循環第二次: i的值是2 i<=2 --> 2<=2 --> true --> 執行外層循環的循環體(內層for循環)
內層循環:
j:1,2,3 --> j<=3 --> true 執行內層循環的循環體
j:4 --> j<=3 --> 4<=3 false 結束內層循環,執行外層循環的步進表達式i++,導致i的值是3
外層循環第三次: i的值是3 i<=2 --> 3<=2 --> false --> 結束外層for循環
執行外層for循環后面的其它語句
for(int i = 1;i<=2;i++) {//外層循環
for(int j = 1;j<=3;j++) {//內層循環
sout("Hello");
}
}
其它語句;
能夠知道break和continue的作用
1.break: 結束所在的循環(本次循環不再執行,而且剩余的所有次數的循環都不再執行)
2.continue: 只結束本次循環,提前進行下一次循環
能夠完成猜數字小游戲程序
//1.創建Random類的對象
Random r = new Random();
//2.產生一個[1,100]之間的隨機數字
int guessNum = r.nextInt(100) + 1;
//3.創建鍵盤錄入Scanner類的對象
Scanner sc = new Scanner(System.in);
//4.循環次數不確定,使用while(true)
while(true){
//5.獲取用戶鍵盤錄入的整數數字
sout("...");
int inputNum = sc.nextInt();
//6.進行比較
if(inputNum > guessNum) {
sout("...");
} else if(inputNum < guessNum) {
sout("...");
} else {
sout("恭喜您猜對了");
//結束while死循環
break;
}
}
~~~
