第6章-流程控制
概述
程序是通过一系列的语句的执行，来实现相应的业务
Java语言通过对遵守标准语法的程序语句的执行顺序进行控制，保证程序按照一定的逻辑运行
常见的程序执行流程分为
- 顺序结构，按照代码编写的顺序，一行一行的执行
- 选择结构，代码块根据条件执行，可能执行，也可能不执行
- 循环结构，代码块可按要求执行0~n次
顺序结构 
顺序结构
程序中的顺序语句将会按源代码编写的顺序，一行一行的被执行
生活场景：就如普罗大众的生活，很多都是按部就班的进行，一天的内容就是按顺序吃饭、睡觉、工作、打豆豆...
一般情况下，如果没有异常或意外，所有顺序语句的代码都会被执行
如下面这段代码，就是典型的顺序语句
package com.bjpowernode.demo;
/**
* 学生管理类
*/
public class StudentManagement {
/**
* 入口方法
*
* @param args 参数
*/
public static void main(String[] args) {
//定义变量
String signInRoom; //1
int seatNo; //2
//给变量赋初始值
signInRoom = "大阶梯教室1"; //3
seatNo = 15; //4
//输出变量值
System.out.println("签到教室：" + signInRoom); //5
System.out.println("座位号：" + seatNo); //6
}
}
选择结构
概述
- 程序在有些情况下，会根据一定的条件，决定执行部分源代码，不执行另外一部分源代码；这时，就需要使用选择结构
- 生活场景：
- 出门上班前，会看看天，如果下雨，带伞；如果不下雨，不带伞
- 带小孩坐高铁，小孩满12岁，买票；未满12岁，不买票
- 根据月份进行判断北半球所在季节
- 3、4、5月是春季
- 6、7、8月是夏季
- 9、10、11月是秋季
- 12、1、2月是冬季
- ...
- 选择语句主要分为两类
- if...else...语句
- switch...case...语句
if...else...语句
能够实现多种灵活条件的程序分支
条件可以是boolean类型字面量、表达式，如果是表达式，表达式的计算结果必须是boolean类型，如true、false、5>3、first>3&&first<second等
如果条件是某种范围，多个else if中要注意条件的覆盖范围，否则可能有些条件分支永远不会被执行
使用广泛
主要语法
- 方式1，单if方式
if (条件表达式) {
//如果条件表达式计算结果为true，则执行这里的代码
//代码块
}- 方式2，if...else...方式
if (条件表达式) {
//如果条件表达式计算结果为true，则执行这里的代码
//代码块
}else{
//如果条件表达式计算结果为false，则执行这里的代码
//代码块
}- 方式3，多路if...esle if...方式，规则
- 会按顺序进行条件表达式1、条件表达式2、条件表达式3...进行表达式计算
- 如果表达式计算结果为false，会进行下一个表达式的计算
- 直到其中一个表达式计算结果为true，则执行该代码块，后续的表达式不再进行计算
if (条件表达式1) {
//如果条件表达式1计算结果为true，则执行这里的代码
//代码块
} else if (条件表达式2){ //零个或多个else if块
//条件表达式2计算结果为true，则执行这里的代码
//代码块
} else if (条件表达式3 ){
//条件表达式3计算结果为true，则执行这里的代码
//代码块
}
//...还可以有更多的else if代码块- 方式4，多路if...else if...else方式，规则同方式3，只是如果所有表达式计算结果为false，则会执行else部分的代码块
if (条件表达式1) {
//条件表达式1计算结果为true，则执行这里的代码
//代码块
} else if (条件表达式2){ //零个或多个else if块
//条件表达式2计算结果为true，则执行这里的代码
//代码块
//...还可以有更多的else if代码块
} else {
//前面的多个条件表达式计算结果都为为false，则执行这里的代码
//代码块
}应用实例
实例1，方式1，单if方式
package com.bjpowernode.demo;
/**
* 方式1，单if方式
*/
public class IfDemo {
public static void main(String[] args) {
//定义变量
int weight = 50; //重量，分别尝试50、100、200
//描述并输出一个把大象装进冰箱的步骤
System.out.println("打开冰箱");
//只有大量的体重小于100时，才能装进去
if (weight < 100) {
System.out.println("把大象放进冰箱");
}
System.out.println("关闭冰箱");
}
}实例2，方式2，if...else..方式
package com.bjpowernode.demo;
/**
* 方式2，if...else..方式
*/
public class IfDemo {
public static void main(String[] args) {
//定义变量
int weight = 200; //重量，分别尝试50、100、200
//描述并输出一个把大象装进冰箱的步骤
System.out.println("打开冰箱");
//只有大量的体重小于100时，才能装进去；否则，提示错误信息
if (weight < 100) {
System.out.println("把大象放进冰箱");
}else{
System.out.println("警告：大象太重，装不下,大象太重，装不下,大象太重，装不下");
}
System.out.println("关闭冰箱");
}
}实例3，方式3，多路if...else if...方式
package com.bjpowernode.demo;
/**
* 方式3，多路if...else if...方式
*/
public class IfDemo {
public static void main(String[] args) {
//定义变量
int month = 2; //月份，分别尝试1、2、3、4、5、6、7、8、9、10、11、12
//描述并输出一个月份对应季节的逻辑
String season = "";
if (month >= 3 && month <= 5) {
season = "春季";
} else if (month >= 6 && month <= 8) {
season = "夏季";
} else if (month >= 9 && month <= 11) {
season = "秋季";
} else if (month == 12 || month == 1 || month == 2) {
season = "冬季";
}
//输出
System.out.println(month + "月是：" + season);
}
}实例4，方式4，多路if...else if...else方式
package com.bjpowernode.demo;
/**
* 方式4，多路if...else if...方式
*/
public class IfDemo {
public static void main(String[] args) {
//定义变量
int month = 13; //月份，分别尝试1、2、3、4、5、6、7、8、9、10、11、12、13
//描述并输出一个月份对应季节的逻辑
String season = "";
if (month >= 3 && month <= 5) {
season = "春季";
} else if (month >= 6 && month <= 8) {
season = "夏季";
} else if (month >= 9 && month <= 11) {
season = "秋季";
} else if (month == 12 || month == 1 || month == 2) {
season = "冬季";
}else{
season = "警告：月份不正确";
}
//输出
System.out.println(month + "月是：" + season);
}
}实例5，多路if...else if...情况下的范围覆盖问题；由于当某个表达式计算结果为true，后续的表达式不再计算的特点，所以当前面的范围覆盖或包含了后面表达式的范围时，会产生后面的else if代码块永远不被执行的情况
package com.bjpowernode.demo;
/**
* if...else...，条件表达式范围使用不合理，会引起bug演示
*/
public class IfDemo {
public static void main(String[] args) {
//定义变量
int age = 5; //年龄，分别尝试5、20、40
//描述并输出一个月份对应季节的逻辑
String result = "";
if (age < 60) {
result = "中年";
} else if (age < 30) { //不会被执行
result = "青年";
} else if (age < 18) { //不会被执行
result = "少年";
} else {
result = "老年";
}
//输出
System.out.println(age + "岁是：" + result);
}
}实例6，嵌套if...else...
package com.bjpowernode.demo;
/**
* if...else...，根据年龄、性别，来描述一个人
*/
public class IfDemo {
public static void main(String[] args) {
//定义变量
int age = 41; //年龄，分别尝试5、20、40
boolean isMale = false; //是否为男性
//拼接描述一个人的字符串
String result = "你是一个";
if (age < 18) {
result = result + "少年";
if(isMale == true){
result = result + "男性";
}else{
result = result + "女性";
}
} else if (age < 30) {
result = result + "青年";
if(isMale == true){
result = result + "男性";
}else{
result = result + "女性";
}
} else if (age < 60) {
result = result + "中年";
if(isMale == true){
result = result + "男性";
}else{
result = result + "女性";
}
} else {
result = result + "老年";
if(isMale == true){
result = result + "男性";
}else{
result = result + "女性";
}
}
//输出该字符串
System.out.println(result);
}
}
【练习】
1. 练习实例内容，完成代码编写；掌握4种if语句的使用、嵌套if...else...的使用，了解多种else if时，范围不合理会产生的问题
2. 编写程序，根据输入的整数，判断是否为3位整数，并输出判断结果；如789是3位整数，1234、12则不是3位整数
3. 编写程序，根据输入的校区（字符串，北京、上海、深圳等）、阶段（整数，共5个阶段），输出”在xx校区学习，简称x，学习到了第x阶段。”，使用嵌套if...else if...实现；如输入校区为北京、阶段为4，则输出”在北京校区学习，简称京，学习到了第五阶段。“
4. 【扩展】编写程序，判断输入整数是否为**水仙花数**（每个数位上的数字的 3次幂之和等于它本身，如：1^3 + 5^3+ 3^3 = 153，可查看百度百科），要求如下
1. 输入一个正整数
2. 判断其是否为三位数，如果不是，直接提示，如果是，再检查其是否为水仙花数，并分别提示，使用嵌套if...else...实现
switch...case...语句
一般用于实现某个变量值对比的多路分支
不支持像if...else...一样的范围条件
相比if...else...，使用相对要少
但，在有一些场景下，switch...case...代码更加直观
主要语法
switch(变量){
case 值1:
//如果变量值为值1，则执行这里的代码
//代码块
break;
case 值2:
//如果变量值为值2，则执行这里的代码
//代码块
break;
case ...:
...
break;
default:
//如果变量值都不为上面case列出的值，则执行这里的代码
//代码块
break;
}语法解释:
- switch有轮换的意思。针对switch里的变量，按顺序逐个去匹配所有case后面的值，若匹配则执行相关case下的代码块，则执行后面的代码块，直到碰到break语句为止
- switch中变量的类型只能是下列类型：char、byte、short、int、Character、Byte、Short、Integer、String、enum
- case 代表一种情形
- “：”冒号表示若符合此种情形，后面就是要执行的代码块
- break：有打破的意思，这里表示不再往下执行
- default：表示若变量与前面的多个case值比较都不相等，则会执行default后的代码块
应用实例
实例1，正常使用
package com.bjpowernode.demo;
/**
* Switch，正常使用
*/
public class SwitchDemo {
public static void main(String[] args) {
//定义变量
String stage = "高中"; //阶段，分别尝试小学、初中、高中、大学
//Switch语句
switch (stage){
case "小学":
System.out.println("正在小学进行学习...");
System.out.println("开始九年义务教育。");
break;
case "初中":
System.out.println("正在初中进行学习...");
break;
case "高中":
System.out.println("正在高中进行学习...");
System.out.println("为了高考，废寝忘食的学。");
System.out.println("好辛苦！！！");
break;
case "大学":
System.out.println("正在大学进行学习...");
System.out.println("没人管，好快活。");
break;
default:
System.out.println("没上过学的飘过！！！");
break;
}
}
}实例2，缺少break带来的问题；注意看下面的代码会输出什么？有什么问题？
package com.bjpowernode.demo;
/**
* Switch，缺少break带来的问题
*/
public class SwitchDemo {
public static void main(String[] args) {
//定义变量
String stage = "小学"; //阶段，分别尝试小学、初中、高中、大学
//Switch语句
switch (stage){
case "小学":
System.out.println("正在小学进行学习...");
System.out.println("开始九年义务教育。");
// break; //注释掉break
case "初中":
System.out.println("正在初中进行学习...");
// break; //注释掉break
case "高中":
System.out.println("正在高中进行学习...");
System.out.println("为了高考，废寝忘食的学。");
System.out.println("好辛苦！！！");
// break; //注释掉break
case "大学":
System.out.println("正在大学进行学习...");
System.out.println("没人管，好快活。");
// break; //注释掉break
default:
System.out.println("没上过学的飘过！！！");
// break;
}
}
}实例3，合理使用break
package com.bjpowernode.demo;
/**
* Switch，合理使用break
*/
public class SwitchDemo {
public static void main(String[] args) {
//定义变量
int month = 7; //月份，分别尝试1、2、3、4、5、6、7、8、9、10、11、12、13
//描述并输出一个月份对应季节的逻辑
String season = "";
switch (month) {
case 3:
case 4:
case 5:
season = "春季";
break;
case 6:
case 7:
case 8:
season = "夏季";
break;
case 9:
case 10:
case 11:
season = "秋季";
break;
case 12:
case 1:
case 2:
season = "冬季";
break;
default:
season = "警告：月份不正确";
break;
}
//输出
System.out.println(month + "月是：" + season);
}
}
if...else...语句和switch...case...语句对比
if...esle...中的条件表达式，可是值相等比较、范围、复杂表达式计算等，更加灵活、方便，应用也更广泛
switch...case...则主要只能做指定类型的值相等比较，能应用场景更窄，但效率更高
大部分的场景都使用if...else...
【练习】
- 练习实例内容，完成代码编写；掌握switch...case...的使用、熟悉缺少break会带来的问题
- 编写程序，模拟一次班级编程大赛，要求如下
- 接收输入的名次
- 根据名次进行奖励：第一名奖励100块，第二名奖励50块，第三名奖励20块，其他的没有奖励
- 输出输入的名次和对应奖金
- 分别使用if...else if...和switch...case...实现
- 编写程序，模拟大家每周的学习时间分配，根据输入的是星期几，分别输出今天是学习、自习、休息
- 编写程序，开发一个针对不同商家等级计算的外卖配送费的程序，要求如下
- 商家等级由用户输入，分别为：A、B、C、D、其他
- 所有等级商家的基础配送费为5元，
- 按照不同商家的等级，有附加配送费，附加配送费的规则如下
- A级商家：基础配送费+7元
- B级商家：基础配送费+5元
- C级商家：基础配送费+3元
- D级商家：基础配送费+1元
- 其他商家：基础配送费
- 输出用户输入商家的最终配送费，如：B级商家配送费为10元。（使用switch...case...语句实现）
循环结构
概述
- 程序在有些情况下，需要重复执行某一段代码块，重复执行的次数有固定的和非固定的
- 生活场景：
- 生活或单调、或丰富，但可能每天都是重复的节奏，吃饭、睡觉、打豆豆...；每一天，都是一个循环
- 晚饭后，在家附近的标准跑道跑几圈，是对每一圈400米的重复动作；每一圈，都是一个循环
- 时钟时的时针、分针、秒针周而复始的360度转圈圈，没有尽头；每一圈，都是一个重复一个循环
- 某IT男爱好王者荣耀，某个休息日，准备排位赛打到最强王者，下定决定，必须赢够10局，不然不放下手机；每一局就是一个循环，但循环多少次不知道，因为输的不算...
- ...
- 循环语句主要分为四种
- while
- do...while
- for
- foreach（关键字使用的是for)
语法构成
- 初始化语句：初始化工作，在循环开始前执行，针对循环条件中的变量赋初值
- 循环条件：boolean表达式，决定是否执行循环体；如果循环条件为false，则退出循环
- 循环体：循环条件为真时执行的代码块
- 迭代语句：每次循环结束后，控制循环条件的变量，在合适的时候把循环条件设置为假，保证循环可以结束，从而避免死循环
- 意外情况：当符合循环条件的循环执行过程中，但业务上有其他情况产生时，也可以退出循环
- 比如，晚上吃饱了，围着标准跑道跑10圈；那么
- 初始化语句，就是当前跑的圈数，且为0
- 循环条件，就是圈数小于10圈
- 迭代语句，则是在心里每次跑完一圈，当前跑的圈数加1
- 意外情况，下雨了，此时没跑到10圈，一般也不跑了
- 注意：循环结构一定要有退出条件，不然会导致死循环
while语句
主要用于按条件循环的场景
一般具体的循环的次数不固定，只要满足循环条件，一直进行
使用广泛
语法规则
初始化语句 1
while(循环条件 2){
循环体 3
迭代语句 4
}语法解释:
- 执行顺序：1 --> 2 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2（如果循环条件为false）->结束循环
- 循环条件：可以是boolean类型的字面量或变量、返回boolean类型的表达式
应用实例
实例1，正常使用
package com.bjpowernode.demo;
/**
* While，正常使用，10圈示例
*/
public class WhileDemo {
public static void main(String[] args) {
//【初始化语句】,初始为1
int currentLaps = 1;
//While循环语句
while (currentLaps <= 10) { //【循环条件】
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
//【迭代语句】，改变循环条件中变量的值
currentLaps++;
}
}
}实例2，被动死循环，一般为bug
package com.bjpowernode.demo;
/**
* While，死循环，被动死循环，一般为bug
*/
public class WhileDemo {
public static void main(String[] args) {
//【初始化语句】，跑10圈
int currentLaps = 1;
//While循环语句
while (currentLaps <= 10) { //【循环条件】
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
//【迭代语句】，改变循环条件中变量的值
// currentLaps++; //迭代语句注释掉，循环条件会一直为真
}
}
}实例3，主动死循环，一般为业务需要，应用场景不多
package com.bjpowernode.demo;
/**
* While，死循环，主动死循环
*/
public class WhileDemo {
public static void main(String[] args) {
//While循环语句
while (true) { //【循环条件】,使用boolean字面量，可以没有初始化语句
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("我在躺赢...不要打搅我...");
}
}
}
do...while语句
与while语句类似，也主要用于按条件循环的场景
一般具体的循环的次数不固定，只要满足循环条件，一直进行
区别于while语句，do...while语句循环体至少执行1次
使用相对while来说比较少
语法规则
初始化语句 1
do {
循环体 3;
迭代语句 4;
}while(循环条件 2);语法解释:
- 执行顺序：1 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2（如果循环条件为false）->结束循环
- 循环条件：可以是boolean类型的字面量或变量、返回boolean类型的表达式
应用实例
实例1，正常使用
package com.bjpowernode.demo;
/**
* do..while，正常使用，10圈示例
*/
public class WhileDemo {
public static void main(String[] args) {
//【初始化语句】，跑10圈,初始为1
int currentLaps = 1;
//While循环语句
do {
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
//【迭代语句】，改变循环条件中变量的值
currentLaps++;
} while (currentLaps <= 10); //【循环条件】
}
}
while语句和do...while语句对比
- while语句的循环体可能执行0~n次；do...while语句可能执行1~n次
【练习】
- 练习实例内容，完成代码编写；掌握while语句、do...while语句的使用
- 编写程序，从1开始计数到100，逢7的倍数输出这个倍数的数字，一共输出5个，使用while循环实现
- 编写程序，要求如下：
- 通过Scanner持续接收用户输入，接收多个用户信息，每次接收一个用户信息，包括姓名、性别、年龄，并在输入完成后的下一行输出上述用户信息
- 当用户输入的性别不为''男''和''女“，或者年龄小于0时，退出接收用户输入（优先尝试do...while循环）
for语句
主要用于固定开始数值、结束数值，且步调固定的重复代码块执行场景
一般具体的循环的次数固定
使用广泛
语法规则
for(初始化语句 1 ;循环条件 2 ;迭代语句 4) {
循环体 3 ;
}语法解释:
- 执行顺序：1 --> 2 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2（如果循环条件为false）->结束循环
- 循环条件：一般是与初始化语句变量相关的，返回boolean类型的表达式
应用实例
实例1，正常使用
package com.bjpowernode.demo;
/**
* for，正常使用，10圈示例
*/
public class ForDemo {
public static void main(String[] args) {
//括号中按顺序包含了【初始化语句】、【循环条件】、【迭代语句】
for(int currentLaps=1;currentLaps<=10;currentLaps++){
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
}
}
}实例2 ，正常使用，步调不为1
package com.bjpowernode.demo;
/**
* for，正常使用，步调不为1，10圈示例
*/
public class ForDemo {
public static void main(String[] args) {
//括号中按顺序包含了【初始化语句】、【循环条件】、【迭代语句】
//迭代语句中，步调为2，只输出奇数圈的内容
for(int currentLaps=1;currentLaps<=10;currentLaps+=2){
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
}
}
}实例3，被动死循环，一般为bug
package com.bjpowernode.demo;
/**
* for，死循环，被动死循环，一般为bug
*/
public class ForDemo {
public static void main(String[] args) {
//括号中按顺序包含了【初始化语句】、【循环条件】、【迭代语句】
//迭代语句中++写成了--，产生死循环
for(int currentLaps=1;currentLaps<=10;currentLaps--){
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
}
}
}实例4，主动死循环，一般为业务需要，应用场景不多
package com.bjpowernode.demo;
/**
* for，死循环，主动死循环
*/
public class ForDemo {
public static void main(String[] args) {
//括号中按顺序包含了【初始化语句】、【循环条件】、【迭代语句】
//初始化语句、循环条件、迭代语句都没有，即死循环
for(;;){
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("我在躺赢...不要打搅我...");
}
}
}实例5，初始化语句、循环条件、迭代语句中变量的可访问性
package com.bjpowernode.demo;
/**
* for，初始化语句、循环条件、迭代语句中变量的可访问性
*/
public class ForDemo {
public static void main(String[] args) {
//初始化语句，定义在for语句外部，保证在外部对变量的可访问性
int currentLaps = 1;
//括号中按顺序包含了【循环条件】、【迭代语句】
for(;currentLaps<=10;currentLaps++){
//【循环体】，可以是很多行代码，或对其他方法的调用
System.out.println("当前是第" + currentLaps + "圈。");
}
//访问改变后的循环条件中的变量
System.out.println("最终跑了"+currentLaps+"圈！");
}
}实例6，嵌套循环
package com.bjpowernode.demo;
/**
* for，嵌套循环，跑10圈，每一圈做15个俯卧撑
*/
public class ForDemo {
public static void main(String[] args) {
//外层循环，跑圈
for (int currentLaps = 1; currentLaps <= 10; currentLaps++) {
System.out.println("当前是第" + currentLaps + "圈:");
//内存循环，做俯卧撑
for (int currentPushup = 1; currentPushup <= 15; currentPushup++) {
System.out.println("-----第" + currentPushup + "个俯卧撑-----");
}
}
}
}实例7，遍历数组，汇总double类型数组的值
package com.bjpowernode.demo;
/**
* for，遍历数组，汇总double类型数组的值
*/
public class ForDemo {
public static void main(String[] args) {
//定义被汇总的数组
double[] data = {25.33, 44.99, 77.22, 1.59, 128.76, 46.59};
//定义汇总变量
double total = 0;
//使用for循环汇总，并使用了数组的length属性
for (int index = 0; index < data.length; index++) {
total += data[index];
}
//输出汇总结果
System.out.println("数组汇总值为：" + total);
}
}
【练习】
提问
- for循环能嵌套，while和do...while循环可以吗？他们相互之间是否可以嵌套呢？
练习实例内容，完成代码编写；掌握for语句的使用
编写程序，输出1~100之间的偶数，使用for语句实现
编写程序，使用for循环输出z~a共26个字母
编写程序，输出2000年~2200之间的闰年（四年一闰，百年不闰，四百年再闰）
编写程序，定义一个double类型的数组，并给数组每个元素赋值一个double数值；然后，使用for循环找出其中的最大值和最小值，并输出
foreach语句
与for语句类似
多用于循环遍历数组、集合、Map的数据，遍历集合、Map系列在后面讲解
一般具体的循环的次数固定，由遍历的数组、集合、Map的长度决定，多用于不关注下标的遍历
使用广泛
主要语法
for(数据类型 变量 : 数组或者集合) {
//循环体
}语法解释:
- 数据类型：可以是8种基本数据类型、引用数据类型，注意要与数组或集合中单个元素的类型要保持一致
应用实例
实例1，正常使用，遍历数组，汇总double类型数组的值
package com.bjpowernode.demo;
/**
* foreach，正常使用，遍历数组，汇总double类型数组的值
*/
public class ForeachDemo {
public static void main(String[] args) {
//被汇总的数组
double[] datas = {25.33, 44.99, 77.22, 1.59, 128.76, 46.59};
//汇总变量
double total = 0;
//使用for循环汇总，并使用了数组的length属性
for (double current : datas) {
total += current;
}
System.out.println("数组汇总值为：" + total);
}
}
【练习】
- 练习实例内容，完成代码编写；掌握foreach的使用
- 编写程序，要求如下
- 定义一个float类型的数组datas，并给数组每个元素赋值一个float数值
- 使用foreach循环找出其中的最大值和最小值，并输出
- 【扩展】编写程序，要求输入一个长字符串，使用foreach遍历按每个字符输出（回顾一下字符串的toCharArray方法）；比如输入的字符串为"他是一个ABC。"，则用字符的形式输出"他-是-一-个-A-B-C-。-"
break
主要用于switch...case...语句和所有循环语句
用于循环语句时，体现的是“意外情况”逻辑，不再管循环条件是否满足，直接退出循环
应用实例
应用实例1，while循环中使用break；持续接收用户输入字符串，直到接收到end为止
package com.bjpowernode.demo;
import java.util.Scanner;
/**
* break，while循环中使用break；持续接收用户输入字符串，直到接收到end为止
*/
public class BreakDemo {
public static void main(String[] args) {
//定义Scanner对象，使用System.in做构造参数
Scanner scanner = new Scanner(System.in);
String input = "";
//死循环
while(true){
//提示
System.out.print("请输入指令：");
//接收输入
input = scanner.next();
//【意外情况】如果为end，则使用break退出循环
if(input.equals("end")){
break;
}
}
System.out.println("循环结束。");
}
}应用实例2，for循环中使用break；找出1~100中的能被10整除的数，找到5个为止
package com.bjpowernode.demo;
import java.util.Scanner;
/**
* break，for循环中使用break；找出1~100中的能被10整除的数，找到5个为止
*/
public class BreakDemo {
public static void main(String[] args) {
//找到的个数，初始值为0
int itemCount = 1;
//for循环，从1~100循环100次
for (int index = 1; index <= 100; index++) {
//如果为10的倍数，输出并将个数加1
if (index % 10 == 0) {
System.out.println(index);
itemCount++;
}
//【意外情况】，如果个数超过5个，退出循环
if (itemCount > 5) {
break;
}
}
}
}应用实例3，嵌套循环中，中止外层循环；控制俯卧撑个数不能超过100个，防止猝死
package com.bjpowernode.demo;
/**
* break，嵌套循环中，中上外层循环；控制俯卧撑个数，防止猝死
*/
public class BreakDemo {
public static void main(String[] args) {
//累计俯卧撑个数变量
int pushupCount = 0;
//外层循环，跑圈
outer: for (int currentLaps = 1; currentLaps <= 10; currentLaps++) {
System.out.println("当前是第" + currentLaps + "圈:");
//内存循环，做俯卧撑
for (int currentPushup = 1; currentPushup <= 15; currentPushup++) {
System.out.println("-----第" + currentPushup + "个俯卧撑-----");
//【意外情况】，如果俯卧撑超过100个，则中上俯卧撑和跑步，防止猝死
if(pushupCount>100){
break outer;
}
//累计俯卧撑个数加1
pushupCount++;
}
}
}
}
【练习】
- 练习实例内容，完成代码编写；掌握break的使用
- 【扩展】编写程序，通过Scanner持续接收输入多个用户信息，接收的用户信息包括姓名、性别、年龄，并在一行输出上述输入的用户信息；当用户输入的性别不为''男''或''女'，或者年龄小于0时，退出程序，退出逻辑使用break实现
continue
用于所有循环语句
与break类似，体现的是“意外情况”，不过此意外情况，只结束当前轮循环后面的代码，继续下轮循环
应用实例
应用实例1，for循环中使用continue；输出1~100之间的数，忽略尾数是4的数字
package com.bjpowernode.demo;
/**
* continue，for循环中使用continue；输出1~100之间的数，忽略尾数是4的数字
*/
public class ContinueDemo {
public static void main(String[] args) {
for (int index = 1; index <= 100; index++) {
//如果尾数是4，跳过本轮后续的输出语句
if (index % 10 == 4) {
continue;
}
//输出
System.out.println("当前数字：" + index);
}
}
}
【练习】
- 练习实例内容，完成代码编写；掌握continue的使用
- 【扩展】编写程序，要求如下：
- 通过Scanner持续接收输入多个有效姓名，存放于字符串数组中，暂定为3个
- 有效姓名规则：只有输入的姓名长度小于等于4的姓名才是有效姓名，保存到字符串数组，其他忽略
- 输出这3个有效的姓名
- 注意：使用continue实现
代码调试
在实际的程序代码编写过程中，运行代码时，总会出现执行逻辑与需求逻辑不一致的情况，俗称bug
此时，需要借助IDEA的调试工具跟踪代码，并分析代码过程中执行的路径、变量的值，来找出bug
使用步骤
设置断点，在IDEA源代码的行号后，单击鼠标，会添加一个红色的圆圈，即添加了一个断点，程序执行时，会在此中断；如果需要取消，再次点击即可；可设置多个断点
以调试模式运行程序，在入口类上右键，选择"Debug ''类名.main()''"，即可开启程序的调试模式运行
程序将会执行到设置的断点处，然后中止，等待继承执行
此时，可以单步一行代码一行代码执行，跟踪逻辑；同时，还能实时查看实时的变量内容
还可以查看并消除所有断点
应用实例
实例1，通过调试，找出下面代码存在的Bug
package com.bjpowernode.demo;
import java.util.Scanner;
/**
* Bug示例，进行加1、然后阶乘运算
*/
public class BugDemo {
public static void main(String[] args) {
//定义标准输入流
Scanner scanner = new Scanner(System.in);
//初始值
int initData = 3;
System.out.println("初始值：" + initData);
//第一步，加1
System.out.print("是否加1？");
boolean isAdd = scanner.nextBoolean();
if (isAdd = true) {
initData += 1;
}
//第二步，阶乘
int result = 1;
for (int index = initData; index >= 0; index--) {
result *= index;
}
//输出
System.out.println(initData + "的阶乘为：" + result);
}
}
【练习】
- 练习上述演示内容，熟悉如何调试代码
实战和作业
编写程序，从键盘接收一个整数，判断是“正数”还是“负数”
编写程序，模拟一个打车价格工具，规则如下
- 起步价8元（3公里内）
- 超过3公里但不超过5公里部分，每公里1.2元
- 超过5公里部分，每公里1.5元
用户输入公里数，输出本次打车价格
编写程序，输出如下图的矩形*号，注意矩形每边的的星号根据用户输入一个整数动态确定；如输入10，就输出下图10*10的矩形星号
【扩展】编写程序，输出2~100的素数，每行输出5个；注意：素数是大于1的自然数，且除了被1和自身整除，不能被其他数整除
编写程序，接收用户输入一个整数，输出这个整数的阶乘；如输入5，则输出5的阶乘n!（即5*4*3*2*1的结果）
【扩展】编写程序，输出如下图的数据，注意行数根据输入动态确定
【扩展】编写程序，接收用户输入一个整数，根据这个整数，输出如下图的*号三角形；如输入9或10，输出下面5行*号三角形图，共5行，每行*号数量分别为1、3、5、7、9个
【扩展】编写程序，输出如下图的九九乘法表
【扩展】猜数字游戏：
- 预先设置一个100以内的被猜整数；如39
- 在程序中，持续接收用户输入，进行猜数字
- 当用户输入的整数没猜中，需要进行提示；如果猜的整数大于被猜整数，提示“你猜错了，输入的xx太大了”；如果猜的整数小于被猜整数，提示“你猜错了，输入的xx太小了”；然后继续猜
- 直到用户猜中，提示“恭喜你，猜中了...”，然后退出程序
注意：上述作业参考“附件和工具”下本章下的实战和作业代码中的flow项目