# 【循环跳转、循环嵌套、随机数】
##### 今日复习指南
~~~
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;
}
}
~~~
