1. ⭐️程序流程控制介绍⭐️
📚在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的,主要有三大流程控制语句。
☕️顺序控制
☕️分支控制
☕️循环控制
2. ⭐️顺序控制⭐️
3. ⭐️分支控制 if-else⭐️
📚分支控制 if-else 介绍
让程序有选择的的执行,分支控制有三种
☕️ 单分支 if
☕️ 双分支 if-else
☕️ 多分支 if-else if -…-else
📚单分支
基本语法:
if(条件表达式){
执行代码块;(可以有多条语句)
}
📚说明:当条件表达式为ture时，就会执行{}的代码。如果为false ,就不执行。特别说明，如果中只有一条语句，则可以不用{}(建议写上{})。
📚案例：
编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"你年龄大于18,要对自己的行为负责,送入监狱”。
📚答案：
import java.util.Scanner;//导入
public class If01 {
//编写一个 main 方法
public static void main(String[] args) {
//编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁, //则输出 "你年龄大于 18,要对自己的行为负责,送入监狱"
//
//思路分析
//1. 接收输入的年龄, 应该定义一个 Scanner 对象
//2. 把年龄保存到一个变量 int age
//3. 使用 if 判断，输出对应信息
//应该定义一个 Scanner 对象
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年龄");
//把年龄保存到一个变量 int age
int age = myScanner.nextInt();
//使用 if 判断，输出对应信息
if(age > 18) {
System.out.println("你年龄大于 18,要对自己的行为负责,送入监狱");
}
System.out.println("程序继续...");
}
}
📚双分支
基本语法:
if(条件表达式){
执行代码块1;
}
else {
执行代码块2;
}
说明:当条件表达式成立，即执行代码块1，否则执行代码块2.如果执行代码块只有一条语句，则可以省略，否则，不能省略。
📚案例：
编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"你年龄大于18,要对自己的行为负责,送入监狱"。否则，输出"你的年龄不大这次放过你了"。
📚答案：
import java.util.Scanner;//导入
public class If02 {
//编写一个 main 方法
public static void main(String[] args) {
//编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁, //则输出 "你年龄大于 18,要对
//自己的行为负责, 送入监狱"。否则 ,输出"你的年龄不大这次放过你了."
//
//思路分析
//1. 接收输入的年龄, 应该定义一个 Scanner 对象
//2. 把年龄保存到一个变量 int age
//3. 使用 if-else 判断，输出对应信息
//应该定义一个 Scanner 对象
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年龄");
//把年龄保存到一个变量 int age
int age = myScanner.nextInt();
//使用 if-else 判断，输出对应信息
if(age > 18) {
System.out.println("你年龄大于 18,要对自己的行为负责,送入监狱");
} else {//双分支
System.out.println("你的年龄不大这次放过你了");
}
System.out.println("程序继续...");
}
}
📚练习：
判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被 4 整除，但不能被 100 整除；(2)能被 400整除。
📚答案：
public class 判断闰年 {
public static void main(String[] args) {
//判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
//(1)年份能被 4 整除，但不能被 100 整除；(2)能被 400 整除
//
//思路分析
//1. 定义 int year 保存年
//2. 年份能被 4 整除，但不能被 100 整除, // => year % 4 == 0 && year % 100 != 0
//3. 能被 400 整除 => year % 400 == 0
//4. 上面的 2 和 3 是 或的关系
//代码实现
int year = 2028;
if( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ) {
System.out.println(year + " 是 闰年");
} else {
System.out.println(year + " 不是 闰年");
}
}
}
📚多分支
📚多分支的流程图(重要!)
📚案例：
输入保国同志的芝麻信用分：
如果：
- 信用分为 100 分时，输出 信用极好；
- 信用分为(80，99]时，输出 信用优秀；
- 信用分为[60,80]时，输出 信用一般；
- 其它情况 ，输出 信用 不及格
- 请从键盘输入保国的芝麻信用分，并加以判断
📚答案：
import java.util.Scanner;
public class If03 {
//编写一个 main 方法
public static void main(String[] args) {
/*
输入保国同志的芝麻信用分：
如果：
信用分为 100 分时，输出 信用极好；
信用分为(80，99]时，输出 信用优秀；
信用分为[60,80]时，输出 信用一般；
其它情况 ，输出 信用 不及格
请从键盘输入保国的芝麻信用分，并加以判断
假定信用分数为 int
*/
Scanner myScanner = new Scanner(System.in);
//接收用户输入
System.out.println("请输入信用分(1-100):");
//请思考：如果小伙伴输入的不是整数，而是 hello.. //==>这里我们后面可以使用异常处理机制搞定
int grade = myScanner.nextInt();
//先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误
if(grade >=1 && grade <= 100) {
//因为有 4 种情况，所以使用多分支
if(grade == 100) {
System.out.println("信用极好");
} else if (grade > 80 && grade <= 99) { //信用分为(80，99]时，输出 信用优秀；
System.out.println("信用优秀");
} else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时，输出 信用一般
System.out.println("信用一般");
} else {//其它情况 ，输出 信用 不及格
System.out.println("信用不及格");
}
} else {
System.out.println("信用分需要在 1-100,请重新输入:)");
}
}
}
📚嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议: 不要超过 3 层（可读性不好）。
📚案例:
参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。
📚答案：
import java.util.Scanner;
public class NestedIf {
//编写一个 main 方法
public static void main(String[] args) {
//思路分析
//1. 创建 Scanner 对象，接收用户输入
//2. 接收 成绩保存到 double score
//3. 使用 if-else 判断 如果初赛成绩大于 8.0 进入决赛，否则提示淘汰
//4. 如果进入到 决赛，再接收 char gender, 使用 if-else 输出信息
//代码实现 => 思路 --> java 代码
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入该歌手的成绩");
double score = myScanner.nextDouble();
if( score > 8.0 ) {
System.out.println("请输入性别");
char gender = myScanner.next().charAt(0);
if( gender == '男' ) {
System.out.println("进入男子组");
} else if(gender == '女') {
System.out.println("进入女子组");
} else {
System.out.println("你的性别有误，不能参加决赛~");
}
} else {
System.out.println("sorry ,你被淘汰了~");
}
}
}
4. ⭐️switch 分支结构⭐️
📚案例：
请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g,a 表示星期一，b 表示星期二 …
根据用户的输入显示相应的信息.要求使用 switch 语句完成。
import java.util.Scanner;
public class Switch01 {
//编写一个 main 方法
public static void main(String[] args) {
/*
思路分析
1. 接收一个字符 , 创建 Scanner 对象
2. 使用 switch 来完成匹配,并输出对应信息
代码
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个字符(a-g)");
char c1 = myScanner.next().charAt(0);//
//在 java 中，只要是有值返回，就是一个表达式
switch(c1) {
case 'a' :
System.out.println("今天星期一,猴子穿新衣");
break;
case 'b' :
System.out.println("今天星期二,猴子当小二");
break;
case 'c' :
System.out.println("今天星期三,猴子爬雪山..");
break;
//.....
default:
System.out.println("你输入的字符不正确，没有匹配的");
}
System.out.println("退出了 switch ,继续执行程序");
}
}
switch 注意事项和细节讨论
switch 和 if 的比较
📚如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。
📚 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广。
5. ⭐️for 循环控制⭐️
📚说明：
- for 关键字，表示循环控制
- for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
- 循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
- 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略
📚注意事项和细节说明
- 循环条件是返回一个布尔值的表达式
- for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
- 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
📚练习:
打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和.[化繁为简,先死后活]
📚答案：
public class ForExercise {
//编写一个 main 方法
public static void main(String[] args) {
//1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成 编程 = 思想 --练习-> 代码
//2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值
//
//思路分析
//打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和
//化繁为简
//(1) 完成 输出 1-100 的值
//(2) 在输出的过程中，进行过滤，只输出 9 的倍数 i % 9 ==0
//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
//先死后活
//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量
//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;
int count = 0; //统计 9 的倍数个数 变量
int sum = 0; //总和
int start = 10;
int end = 200;
int t = 5; // 倍数
for(int i = start; i <= end; i++) {
if( i % t == 0) {
System.out.println("i=" + i);
count++;
sum += i;//累积
}
}
System.out.println("count=" + count);
System.out.println("sum=" + sum);
}
}
6. ⭐️while 循环控制⭐️
📚基本语法
循环变量初始;
while(循环条件){
循环体(语句);
循环变量迭代;
}
1. while循环也有四要素
2. 只是四要素放的位置和for不一样。
📚流程图
📚 注意事项和细节说明
- 循环条件是返回一个布尔值的表达式
- while 循环是先判断再执行语句
7. ⭐️do…while 循环控制⭐️
📚流程图
📚 注意事项和细节说明
- 循环条件是返回一个布尔值的表达式
- do…while 循环是先执行，再判断， 因此它至少执行一次
📚练习：
统计 1—200 之间能被 5 整除但不能被 3 整除的个数。
📚答案：
public class DoWhileExercise {
//编写一个 main 方法
public static void main(String[] args) {
//统计 1---200 之间能被 5 整除但不能被 3 整除的 个数
//化繁为简
//(1) 使用 do-while 输出 1-200
//(2) 过滤 能被 5 整除但不能被 3 整除的数 %
//(3) 统计满足条件的个数 int count = 0;
//先死后活
//(1) 范围的值 1-200 你可以做出变量
//(2) 能被 5 整除但不能被 3 整除的 , 5 和 3 可以改成变量
int i = 1;
int count = 0; //统计满足条件的个数
do {
if( i % 5 == 0 && i % 3 != 0 ) {
System.out.println("i=" + i);
count++;
}
i++;
}while(i <= 200);
System.out.println("count=" + count);
}
}
8. ⭐️多重循环控制⭐️
📚 介绍
☕️将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。
【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
☕️实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，看案例]。
☕️ 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。
📚练习：
统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。统计三个班及格人数，每个班有 5 名同学。
📚答案：
import java.util.Scanner;
public class MulForExercise {
//编写一个 main 方法
public static void main(String[] args) {
//统计 3 个班成绩情况，每个班有 5 名同学，
//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
//统计三个班及格人数，每个班有 5 名同学。
//
//思路分析:
//化繁为简
//(1) 先计算一个班 , 5 个学生的成绩和平均分 , 使用 for
//1.1 创建 Scanner 对象然后，接收用户输入
//1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级 5 个学生的成绩累积
//(2) 统计 3 个班(每个班 5 个学生) 平均分
//(3) 所有班级的平均分
//3.1 定义一个变量，double totalScore 累积所有学生的成绩
//3.2 当多重循环结束后，totalScore / (3 * 5)
//(4) 统计三个班及格人数
//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
//4.2 如果 >= 60 passNum++
//(5) 可以优化[效率，可读性, 结构]
//创建 Scanner 对象
Scanner myScanner = new Scanner(System.in);
double totalScore = 0; //累积所有学生的成绩
int passNum = 0;//累积 及格人数
int classNum = 3; //班级个数
int stuNum = 5;//学生个数
for( int i = 1; i <= classNum; i++) {//i 表示班级
double sum = 0; //一个班级的总分
for( int j = 1; j <= stuNum; j++) {//j 表示学生
System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");
double score = myScanner.nextDouble();
//当有一个学生成绩>=60, passNum++
if(score >= 60) {
passNum++;
}
sum += score; //累积
System.out.println("成绩为" + score);
}
//因为 sum 是 5 个学生的总成绩
System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum));
//把 sum 累积到 totalScore
totalScore += sum;
}
System.out.println("三个班总分="+ totalScore
+ " 平均分=" + totalScore / (classNum*stuNum));
System.out.println("及格人数=" + passNum);
}
}
📚 应用实例：经典的打印金字塔
public class Stars {
//编写一个 main 方法
public static void main(String[] args) {
/*
********
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
*****
2. 打印半个金字塔
* //第 1 层 有 1 个*
** //第 2 层 有 2 个*
*** //第 3 层 有 3 个*
**** //第 4 层 有 4 个*
***** //第 5 层 有 5 个*
3. 打印整个金字塔
* //第 1 层 有 1 个* 2 * 1 -1 有 4=(总层数-1)个空格
*** //第 2 层 有 3 个* 2 * 2 -1 有 3=(总层数-2)个空格
***** //第 3 层 有 5 个* 2 * 3 -1 有 2=(总层数-3)个空格
******* //第 4 层 有 7 个* 2 * 4 -1 有 1=(总层数-4)个空格
********* //第 5 层 有 9 个* 2 * 5 -1 有 0=(总层数-5)个空格
4. 打印空心的金字塔 [最难的]
* //第 1 层 有 1 个* 当前行的第一个位置是*,最后一个位置也是*
* * //第 2 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
* * //第 3 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
* * //第 4 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
********* //第 5 层 有 9 个* 全部输出*
先死后活
5 层数做成变量 int totalLevel = 5;
//技术到位，就可以很快的把代码写出
*/
int totalLevel = 5; //层数
for(int i = 1; i <= totalLevel; i++) { //i 表示层数
//在输出*之前，还有输出 对应空格 = 总层数-当前层
for(int k = 1; k <= totalLevel - i; k++ ) {
System.out.print(" ");
}
//控制打印每层的*个数
for(int j = 1;j <= 2 * i - 1;j++) {
//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
if(j == 1 || j == 2 * i - 1 || i == totalLevel) {
System.out.print("*");
} else { //其他情况输出空格
System.out.print(" ");
}
}
//每打印完一层的*后，就换行 println 本身会换行
System.out.println("");
}
}
}
879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
