一、死循环
- 一直循环的执行下去，如果没有干预不会停止下来
格式：
for( ; ; ) {
System.out.println("我爱中国！");
}
// 经典做法
while(true) {
System.out.println("我爱中国！");
}
do {
System.out.println("我爱中国！");
}while(true);
- 死循环在服务器上用的是比较多的
- 比如：
- 百度
- Google浏览器
- 等等
- 你随时随地都可以访问这些服务，其实就是一个死循环
- 比如：
package com.app.loop;
public class InfiniteLoopDemo8 {
public static void main(String[] args) {
// 目标：学会定义死循环
// for (int i = 0; ; i++) { // 不定义循环条件，不受限制，死循环
// System.out.println("我爱中国~~~~");
// }
// for ( ; ; ) { // 不定义初始化语句，不定义循环条件，不定义迭代语句。分号不能去掉，基本格式就是这样，语法规定
// System.out.println("我爱中国~~~~");
// }
// 经典写法，专业
// while (true) { // 将循环条件定义为true——>真，判断永远为true，死循环
// System.out.println("我爱中国~~~~");
// }
do {
System.out.println("我爱中国~~~~");
} while (true); // 将判断条件定义为true，判断永远为true，死循环
}
}
输出结果都是：
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
我爱中国~~~~
......
二、死循环案例：密码验证
- 需求：
- 系统密码是520，请用户不断的输入密码验证，验证不对提示密码错误，验证成功提示欢迎进入系统，并停止程序运行
- 分析：
- 使用while死循环，让用户不断输入密码
- 与密码比对：验证不成功提示密码错误，验证成功提示欢迎进入系统，并使用break结束当前循环的执行
package com.app.loop;
// 1.导入扫描器对象包
import java.util.Scanner;
public class InfiniteLoopTest9 {
public static void main(String[] args) {
// 目标：通过密码验证案例，更深入理解死循环的应用
/*
需求：
系统密码是520，请用户不断的输入密码验证，验证不对提示密码错误，验证成功提示欢迎进入系统，并停止程序运行
分析：
(1) 使用while死循环，让用户不断输入密码
(2) 与密码比对：验证不成功提示密码错误，验证成功提示欢迎进入系统，并使用break结束当前循环的执行
实现：
1.导入扫描器对象包
2.定义系统密码
3.创建扫描器对象，用于用户输入密码
4.定义while死循环，让用户不断输入密码验证
5.定义变量，用于接收用户输入的密码
6.if判断用户输入的密码 是否符合系统密码
7.验证成功，则提示密码正确，欢迎进入系统，使用break结束所在循环的执行
8.验证失败，提示密码错误，让用户继续输入密码
*/
// 2.定义系统密码
int systemPassword = 520;
// 3.创建扫描器对象，用于用户输入密码
Scanner sc = new Scanner(System.in);
// 4.定义while死循环，让用户不断输入密码验证
while (true) {
System.out.println("请您输入密码：");
// 5.定义变量，用于接收用户输入的密码
int password = sc.nextInt();
// 6.if判断用户输入的密码 是否符合系统密码
if (password == systemPassword) {
// 7.验证成功，则提示密码正确，欢迎进入系统
System.out.println("欢迎进入系统！");
break; // 使用break结束所在循环的执行
}else {
// 8.验证失败，提示密码错误，让用户继续输入密码
System.out.println("密码错误！");
}
}
}
}
请您输入密码：
34
密码错误！
请您输入密码：
54
密码错误！
请您输入密码：
5445
密码错误！
请您输入密码：
520
欢迎进入系统！
死循环总结
1、死循环可以怎么写？
写法1：
for( ; ; ) {
}
写法2：(经典写法，常用，专业)
while(true) {
}
写法3：
do {
}while(true);
三、嵌套循环
-
循环中又包含循环
for (int i = 0; i<3; i++) { for (int j = 0; j<5; j++) { System.out.println("Hello World"); } }
嵌套循环的特点
- 外部循环每循环一次，内部循环全部执行完一次
package com.app.loop;
public class NestedLoopDemo10 {
public static void main(String[] args) {
// 目标：学会使用嵌套循环，并理解其执行流程
// 场景：假如你的女朋友，因为你犯错生气了，罚你说5天，每天3句我爱你
// 不使用循环嵌套来解决这个来自女友的惩罚
// for (int i = 0; i < 5; i++) { // 说5天
// // 每天3句我爱你
// System.out.println("我爱你");
// System.out.println("我爱你");
// System.out.println("我爱你");
// System.out.println("------------------"); // 华丽的分割线，便于我们理解输出结果
// }
// 使用循环嵌套来解决这个来自女友的惩罚
for (int i = 1; i < 6; i++) { // 说5天
for (int j = 0; j < 3; j++) { // 每天3句我爱你
System.out.println("第"+ i + "天说" +"我爱你"); // 重复要说的话
}
System.out.println("------------------"); // 华丽的分割线，便于我们理解输出结果
}
/*
循环嵌套执行流程详解:
外部循环每循环一次，内部循环全部执行完一次
第一天（女朋友刚生完气）：i=1，i<6，符合，判断为true，进入到内部，此时i= 1+1 =2
第一次说：j=0，j<3，符合，为true，输出一句 第1天说我爱你，此时 j= 0+1 =1
第二次说：j=1，j<3，符合，为true，输出一句 第1天说我爱你，此时 j= 1+1 =2
第三次说：j=2，j<3，符合，为true，输出一句 第1天说我爱你，此时 j= 2+1 =3
第四次说：j=3，因此，不符合j<3，为false，结束今天的惩罚。
然后执行输出华丽的分割线
第二天（女朋友还没消气）：i=2，i<6，符合，判断为true，进入到内部，此时i= 2+1 =3
第一次说：j=0，j<3，符合，为true，输出一句 第2天说我爱你，此时 j= 0+1 =1
第二次说：j=1，j<3，符合，为true，输出一句 第2天说我爱你，此时 j= 1+1 =2
第三次说：j=2，j<3，符合，为true，输出一句 第2天说我爱你，此时 j= 2+1 =3
第四次说：j=3，因此，不符合j<3，为false，结束今天的惩罚。
然后执行输出华丽的分割线
第三天（女朋友还没消气）：i=3，i<6，符合，判断为true，进入到内部，此时i= 3+1 =4
第一次说：j=0，j<3，符合，为true，输出一句 第3天说我爱你，此时 j= 0+1 =1
第二次说：j=1，j<3，符合，为true，输出一句 第3天说我爱你，此时 j= 1+1 =2
第三次说：j=2，j<3，符合，为true，输出一句 第3天说我爱你，此时 j= 2+1 =3
第四次说：j=3，因此，不符合j<3，为false，结束今天的惩罚。
然后执行输出华丽的分割线
第四天（女朋友还没消气）：i=4，i<6，符合，判断为true，进入到内部，此时i= 4+1 =5
第一次说：j=0，j<3，符合，为true，输出一句 第4天说我爱你，此时 j= 0+1 =1
第二次说：j=1，j<3，符合，为true，输出一句 第4天说我爱你，此时 j= 1+1 =2
第三次说：j=2，j<3，符合，为true，输出一句 第4天说我爱你，此时 j= 2+1 =3
第四次说：j=3，因此，不符合j<3，为false，结束今天的惩罚。
然后执行输出华丽的分割线
第五天（女朋友还没消气）：i=5，i<6，符合，判断为true，进入到内部，此时i= 5+1 =6
第一次说：j=0，j<3，符合，为true，输出一句 第5天说我爱你，此时 j= 0+1 =1
第二次说：j=1，j<3，符合，为true，输出一句 第5天说我爱你，此时 j= 1+1 =2
第三次说：j=2，j<3，符合，为true，输出一句 第5天说我爱你，此时 j= 2+1 =3
第四次说：j=3，因此，不符合j<3，为false，结束今天的惩罚。
然后执行输出华丽的分割线
第六天（女朋友心情有好转）：i=6，因此不符合i<6，判断为false，结束来自女友的全部惩罚
*/
}
}
输出结果：
第1天说我爱你
第1天说我爱你
第1天说我爱你
------------------
第2天说我爱你
第2天说我爱你
第2天说我爱你
------------------
第3天说我爱你
第3天说我爱你
第3天说我爱你
------------------
第4天说我爱你
第4天说我爱你
第4天说我爱你
------------------
第5天说我爱你
第5天说我爱你
第5天说我爱你
------------------
四、嵌套循环案例：打印矩形
-
需求：
-
在控制台使用 * 打印出4行5列的矩形
输出效果： ***** ***** ***** *****
-
-
分析：
-
解法1：直接使用一个for循环实现，但只适用于列数少的情况下，不建议使用，显得不专业
for (int i = 0; i < 4; i++) { System.out.println("*****"); }输出结果： ***** ***** ***** ***** -
解法2：更专业，高级
- 1、先定义一个外部for循环，用于打印行数 4
- 2、再定义一个内部for循环，用于打印列数 5
- 3、在内部for循环中，重复执行 打印 * （将输出语句的 ln 去掉：目的是为了将循环输出的所有 * 打成一条长棍）
- 4、当内部for循环每次执行完一次后，加一个换行：目的是为了实现 4行 5列
package com.app.loop; public class NestedLoopTest11 { public static void main(String[] args) { // 目标：通过使用 * 打印矩形的案例，更深入理解循环嵌套的应用 /* 需求：在控制台使用 * 打印出4行5列的矩形 */ // 不使用循环嵌套来实现这个需求，但只适用于列数少的情况下 // for (int i = 0; i < 4; i++) { // System.out.println("*****"); // } // 使用循环嵌套来实现这个需求 for (int i = 0; i < 4; i++) { // 外部循环用于打印行数 4，竖形 for (int j = 0; j < 5; j++) { // 内部循环用于打印列数 5，横形 // 将 ln 去掉，表示不换行，不然就会每输出一个 * 就会换一行，变成竖形，我们需要的是横形 // 将 ln 去掉，目的是将循环输出的所有 * 打成一条平躺的长棍，正是我们需要的横形 System.out.print("*"); } // 这里打印换行的目的是为了实现 4行 5列：当内部for循环每打印完5个 * 后换一行 System.out.println(); } } }输出结果： ***** ***** ***** *****
-
五、跳转关键字
1、break
- 用于跳出并结束当前所在循环的执行
2、continue
- 用于跳出当前循环的当次执行，进入下一次循环
3、注意事项
-
break：只能用于结束所在循环，或者结束所在switch分支的执行
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f1DYR3IF-1655223858491)(C:\Users\吴先生\AppData\Roaming\Typora\typora-user-images\image-20220614162755852.png)]
-
continue：只能在循环中进行使用
package com.app.loop;
public class BreakAndContinueDemo12 {
public static void main(String[] args) {
// 目标：学会使用跳转关键字: break、continue
// 场景1：假如你女朋友因为你犯错生气了，罚你做5天家务，每天都是洗碗，但是三天后，她心软了，就原谅你了
/*
具体实现：
1.先定义一个for循环，定义初始化语句为：int i = 1; 定义循环条件为：i<6; (5天家务); 定义迭代语句 i++
2.每天重复一件事：洗碗
3.再使用if判断，是否做家务够3天了，够了，则表示女友心软了，原谅你了
4.使用break结束当前所在循环的执行
*/
// break：跳出并结束当前所在循环的执行
System.out.println("----------------------break的使用----------------------");
// 1.先定义一个for循环，定义初始化语句为：int i = 1; 定义循环条件为：i<6; (5天家务); 定义迭代语句 i++
for (int i = 1; i < 6; i++) {
// 2.每天重复一件事：洗碗
System.out.println("第" + i + "天快乐的洗碗~~~");
// 3.再使用if判断，是否做家务够3天了
if (i == 3) {
// 够了，则表示女友心软了，原谅你了
System.out.println("今天女友说原谅我了！可以结束快乐的洗碗了~");
// 4.使用break结束当前所在循环的执行
break;
}
}
// 场景2：假如你女朋友因为你犯错生气了，罚你做5天家务，每天都是洗碗，但到了第三天她心软了，原谅你了；但是依旧不解恨，继续洗第4、5天
/*
具体实现：
1.先定义一个for循环，定义初始化语句为：int i = 1; 定义循环条件为：i<6; (5天家务); 定义迭代语句 i++
2.每天重复一件事：洗碗
3.先if判断，是否做家务够3天了，够了，则表示女友心软了，原谅你了，但是依旧不解恨，使用continue立即跳出当次执行，进入下一次循环，继续让你洗第4、5天
*/
// continue：跳出当前循环的当次执行，进入下一次循环
System.out.println("----------------------continue的使用----------------------");
// 1.先定义一个for循环，定义初始化语句为：int i = 1; 定义循环条件为：i<6; (5天家务); 定义迭代语句 i++
for (int i = 1; i < 6; i++) {
// 3.先if判断，是否做家务够3天了，够了，则表示女友心软了，原谅你了，但是依旧不解恨，继续让你洗第4、5天
if (i == 3) {
// 够了，则表示女友心软了，原谅你了，但是依旧不解恨，使用continue跳出当次执行，进入下一次循环，继续让你洗第4、5天
System.out.println("今天女友说原谅我了！但好像没有完全解恨，看来我是要继续完成剩余两天的洗碗活了！");
continue; // 立即跳出当前循环的当次执行，进入下一次循环
}
// 2.每天重复一件事：洗碗
System.out.println("第" + i + "天快乐的洗碗~");
}
}
}
输出结果：
----------------------break的使用----------------------
第1天快乐的洗碗~~~
第2天快乐的洗碗~~~
第3天快乐的洗碗~~~
今天女友说原谅我了！可以结束快乐的洗碗了~
----------------------continue的使用----------------------
第1天快乐的洗碗~
第2天快乐的洗碗~
今天女友说原谅我了！但好像没有完全解恨，看来我是要继续完成剩余两天的洗碗活了！
第4天快乐的洗碗~
第5天快乐的洗碗~
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
