目录
程序控制结构
程序流程控制介绍
顺序控制介绍
顺序控制举例和注意事项
分支控制if-else
分支控制if-else介绍
单分支
双分支
单分支和双分支练习题
多分支基本语法
多分支的流程图
案例演示
嵌套分支
基本介绍
基本语法
应用案例
switch分支结构
基本语法
解读switch
switch分支流程图
快速入门
switch注意事项和细节讨论
switch练习
switch和if的比较
for循环控制
基本介绍
基本语法
说明
for循环执行流程分析
注意事项和细节说明
for循环练习
while循环控制
基本语法
说明
while循环执行流程分析编辑
演示
注意事项和细节说明
while循环练习题
do..while循环控制
基本语法
说明:
do...while循环执行流程分析编辑
演示
注意事项和细节说明
do..while循环练习题
多重循环控制（难点!重点!)
介绍
案例
应用实例：
1、统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
2、统计三个班及格人数,每个班有5名同学。
经典的打印金字塔
跳转控制语句-break
随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次；
思路分析
基本介绍
基本语法
break示意图
break快速入门
break注意事项和细节说明
解读
break练习题
跳转控制语句-continue
continue基本介绍
continue基本语法
continue示意图
continue快速入门
continue细节案例分析和说明
跳转控制语句-return
return介绍
程序控制结构
顺序控制
分支控制(if ,else, switch)
循环控制(for, while , dowhile,多重循环)
break
continue
return
程序流程控制介绍
在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌的，主要有三大流程控制语句。
1、顺序控制
2、分支控制
3、循环控制
顺序控制介绍
程序从上到下逐行地执行，中间没有任何判断和跳车转。
顺序控制举例和注意事项
Java中定义成员变量时采用合法的前向引用。如：
1
2
3
4
5
6
7
8
9
10public class Test{ int num1 = 12; int num2 = num1 + 2; } //错误形式: public class Test{ int num2 = num1 + 2;//错误 int num1 = 12; }
分支控制if-else
分支控制if-else介绍
让程序有选择的的执行,分支控制有三种
1、单分支
2、双分支
3、多分支
单分支
基本语法
if(条件表达式){
执行代码块;(可以有多条语句.)
}
说明：当条件表达式为ture时，就会执行{ }的代码。如果为false，就不执行。
特别说明：如果中只有一条语句，则可以不用{ }建议写上{ }
双分支
基本语法
1
2
3
4
5if(条件表达式){ 执行代码块1;} else { 执行代码块2; }
说明：当条件表达式成立，即执行代码块1，否则执行代码块2。
如果执行代码块只有一条语句，则可以省略，否则，不能省略。
单分支和双分支练习题
1、编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个
数小于20.0，打印两数之和。
2、定义两个变量int,判断二者的和，是否能被3又能被5整除，打印提示信息
3、判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整
除，但不能被100整除;(2)能被400整除
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50//单分支和双分支练习 public class IfExercise { //编写一个main方法 public static void main(String[] args) { //编写程序，声明2个double型变量并赋值。 //判断第一个数大于10.0，且第2个数小于20.0，打印两数之和 //思路分析 double d1 = 34.5; double d2 = 2.6; if (d1 > 10.0 && d2 < 20.0) { System.out.println("连个数的和=" + (d1 + d2)); } //定义两个变量int,判断二者的和， // 是否能被3又能被5整除，打印提示信息 // //思路分析 //1.定义两个变量int num1, num2 //2.定义一个变量int sum = num1 + num2; //3.sum % 3 ,5后等于0说明可以整除 //4.使用if - else来提示对应信息 //走代码 int num1 = 10; int num2 = 1; int sum = num1 + num2; if (sum % 3 == 0 && sum % 5 == 0) { System.out.println(sum + "可以被3又能被5整除"); } else { System.out.println(sum + "不能被3又能被5整除.."); } //判断一个年份是否是闰年，闰年的条件是符合下面二者之一： //(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 = 2024; if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) { System.out.println(year + "是 闰年"); } else { System.out.println(year + "不是 闰年"); } } }
运行结果
多分支基本语法
1
2
3
4
5
6
7
8
9if(条件表达式1){ 执行代码块1;} else if(条件表达式2){ 执行代码块2; } ...... else{ 执行代码块n; }
特别说明：
(1)多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
(2)如果有else ，如果所有的条件表达式都不成立，则默认执行else代码块
多分支的流程图
说明：
1、当条件表达式1成立时，即执行代码块1
2、如果表达式1不成立，才去判断表达式2是否成立
3、如果表达式2成立，就执行代码块2
4、以此类推,如果所有的表达式都不成立
5、则执行else的代码块，注意，只能有一个执行入口。
案例演示
输入保国同志的芝麻信用分
如果：
1、信用分为100分时，输出信用极好;
2、信用分为(80，99]时，输出信用优秀;
3、信用分为[60,80]时，输出信用一般;
4、其它情况，输出信用不及格
5、请从键盘输入保国的芝麻信用分，并加以判断
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34import java.util.Scanner; //单分支和双分支练习 public class IfExercise { //编写一个main方法 public static void main(String[] args) { // 输入保国同志的芝麻信用分 // 如果： // 1、信用分为100分时，输出信用极好; // 2、信用分为(80，99]时，输出信用优秀; // 3、信用分为[60,80]时，输出信用一般; // 4、其它情况，输出信用不及格 // 5、请从键盘输入保国的芝麻信用分，并加以判断 Scanner myScanner = new Scanner(System.in); //接收用户输入 System.out.println("请输入信用分(1-100)："); int grade = myScanner.nextInt(); //先对输入的信用分，进行一个范围的有效判断 1-100，否则提示输入错误 if (grade >= 1 && grade <= 100) { //因为有4种情况，所以使用多分支 if (grade == 100) { System.out.println("信用极好"); } else if (grade > 80 && grade <= 99) { System.out.println("信用优秀"); } else if (grade > 60 && grade <= 80) { System.out.println("信用一般"); } else { System.out.println("信用不及格"); } }else { System.out.println("输入错误!!!!!!"); } } }
运行结果
嵌套分支
基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议：不要超过3层(可读性不好)
基本语法
1
2
3
4
5
6
7if( ){ if( ){ //if-else.... }else{ //if-else } }
应用案例
参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。
提示：double score; char gender;
接收字符：char gender = scanner.next).charAt(O)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34import java.util.Scanner; public class NestedIf { //编写一个main方法 public static void main(String[] args) { // 参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。 // 并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。 // 提示：double score; char gender; // 接收字符：char gender = scanner.next).charAt(O) //思路分析 //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 ,你被淘汰了~"); } } }
运行结果
switch分支结构
基本语法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15switch(表达式){ case常量1: 语句块1; break; case常量2: 语句块2; break;… case常量n: 语句块n; break; default: default语句块; break; }
解读switch
1、switch关键字，表示swtich分支
2、表达式对应一个值
3、case常量1:当表达式的值等于常量1，就执行语句块1
4、break;表示退出swtich
5、如果和case常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case常量2
6、如果一个都没有匹配上，执行default
switch分支流程图
快速入门
案例
1、请编写一个程序，该程序可以接收一个字符，比如：a，b，c，d，e，f，g
2、a表示星期一，b表示星期二...
3、根据用户的输入显示相依的信息.要求使用switch语句完成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import java.util.Scanner; public class Switch { //编写一个main方法 public static void main(String[] args) { // 1、请编写一个程序，该程序可以接收一个字符，比如：a，b，c，d，e，f，g // 2、a表示星期一，b表示星期二... // 3、根据用户的输入显示相依的信息.要求使用switch语句完成 //思路分析 //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("请输入一个字符(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注意事项和细节讨论
1、表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
2、switch(表达式)中表达式的返回值必须是：(byte，short，int，char，enum，String)
1
2
3
4
5
6
7double c = 1.1; switch(c){//错误 case 1.1 ://错误 System.out.print1n( "ok3"); break; }
3、case子句中的值必须是常量，而不能是变量
4、default子句是可选的，当没有匹配的case时，执行default
5、break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾
switch练习
1、使用switch 把小写类型的char型转为大写(键盘输入)。只转换a，b，c，d，e。其它的输出"other"。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import java.util.Scanner; public class SwitchExercise { //编写一个main方法 public static void main(String[] args) { // 使用switch 把小写类型的char型转为大写(键盘输入)。 // 只转换a，b，c，d，e。其它的输出"other"。 //创建Scanner对象 Scanner myScanner = new Scanner(System.in); System.out.println("请输入a-e"); char c1 = myScanner.next().charAt(0); switch (c1) { case 'a': System.out.println("A"); break; case 'b': System.out.println("B"); break; case 'c': System.out.println("C"); break; case 'd': System.out.println("D"); break; case 'e': System.out.println("E"); break; default: System.out.println("other"); } } }
运行结果
2、对学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。(注：输入的成绩不能大于100)，提示成绩/60
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34import java.util.Scanner; public class SwitchExercise { //编写一个main方法 public static void main(String[] args) { //创建Scanner对象 Scanner myScanner = new Scanner(System.in); System.out.println("请输入成绩："); //对学生成绩大于60分的,输出"合格"。低于60分的, //输出"不合格"。(注:输入的成绩不能大于100)，提示成绩/60 // 思路分析 //1.这道题，可以使用分支来完成,但是要求使用switch //2.这里我们需要进行一个转换,编程思路∶ // 如果成绩在[60,100] , (int)(成绩/60）=1 // 如果成绩在[0,60) , (int)(成绩/60)=0 //代码实现 double score = myScanner.nextDouble(); //使用if-else 保证输入的成绩有有效的0-100 if (score >= 0 && score <= 100) { switch ((int) (score / 60)) { case 0: System.out.println("不合格"); break; case 1: System.out.println("合格"); break; // default: // System.out.println("输入有误"); } } else { System.out.println("输入成绩在0-100"); } } }
运行结果
3、根据用于指定月份，打印该月份所属的季节。3，4，5春季6，7，8夏季9，10，11秋季12，1，2冬季[提示使用穿透]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import java.util.Scanner; public class SwitchExercise { //编写一个main方法 public static void main(String[] args) { //创建Scanner对象 Scanner myScanner = new Scanner(System.in); System.out.println("请输入月份"); int month = myScanner.nextInt(); //使用if-else 保证输入的成绩有有效的0-12 if (month >= 0 && month <= 12) { switch (month) { case 3: case 4: case 5: System.out.println("春天"); break; case 6: case 7: case 8: System.out.println("夏天"); break; case 9: case 10: case 11: System.out.println("秋天"); break; case 12: case 1: case 2: System.out.println("冬天"); break; default: System.out.println("输入有误"); } } else { System.out.println("输入成绩在0-12"); } } }
运行结果
switch和if的比较
1、如果判断的具体数值不多，而且符合byte、short、int、char、enum[枚举]、String这6种类型。虽然两个语句都可以使用，建议使用swtich语句。
2、其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广
for循环控制
基本介绍
让代码可以循环执行
基本语法
1
2
3for(循环变量初始化;循环条件;循环变量迭代){ 循环操作(可以多条语句); }
说明
1、for关键字，表示循环控制
2、for有四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3、循环操作，这里可以有多条语句，也就是我们要循环执行的代码
4、如果循环操作(语句)只有一条语句，可以省略建议不要省略
for循环执行流程分析
1
2
3
4
5
6
7
8public class ForTest { //编写一个main方法 public static void main(String[] args) { for (int i = 1; i <= 10; i++) { System.out.println("hello world!!!" + i); } } }
运行结果
注意事项和细节说明
1、循环条件是返回一个布尔值的表达式
2、for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
3、循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
4、使用内存分析法，分析输出下面代码输出什么?
1
2
3
4
5
6
7
8
9public class ForDetail { //编写一个main方法 public static void main(String[] args) { int count = 3; for (int i = 0, j = 0; i <= count; i++, j += 2) { System.out.println("i=" + i + "j=" + j); } } }
运行结果
for循环练习
1、打印1~100之间所有是9的倍数的整数，统计个数及总和。[化繁为简,先死后活]
2、完成下面的表达式输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28public class ForExercise { //编写一个main方法 public static void main(String[] args) { //打印1~100之间所有是9的倍数的整数，统计个数 及总和·[化繁为简,先死后活] //老韩的两个编程思想(技巧) //1、化繁为简：即将复杂的需求，拆解成简单的需求，逐步完成 //2、先死后活：先考虑固定的值，然后转成可以灵活变化的值 // //思路分析 //打印1~100之间所有是9的倍数的整数，统计个数及总和 // 化繁为简 //(1）完成输出1-100的值 int count = 0;//统计9的倍数个数 变量 int sum = 0;//总和 int start = 0; int end = 100; int t = 9;//倍数 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); } }
运行结果
1
2
3
4
5
6
7
8
9
10public class ForExercise { //编写一个main方法 public static void main(String[] args) { //完成下面表达式的输出 int num = 5; for (int i = 0; i <= num; i++) { System.out.println(i + "+" + (num - i) + "=" + num); } } }
运行结果
while循环控制
基本语法
1
2
3
4
5
6循环变量初始化; while(循环条件){ 循环体(语句); 循环变量迭代; }
说明
1、 while循环也有四要素
2、只是四要素放的位置，不一样。
while循环执行流程分析
演示
1
2
3
4
5
6
7
8
9
10
11
12
13public class While { //编写一个main方法 public static void main(String[] args) { //输出10句hello world int i = 1;//循环变量初始化 int t = 4; while (i <= t) {//循环条件 System.out.println("hello world" + i); i++;//循环变量迭代 } System.out.println("退出while ,继续.."); } }
运行结果
注意事项和细节说明
1、循环条件是返回一个布尔值的表达式
2、while循环是先判断再执行语句
while循环练习题
1、打印1—100之间所有能被33整除的数[使用while]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class WhileExercise { //编写一个main方法 public static void main(String[] args) { int i = 1;//循环变量初始化 int t = 100; int n = 33; while (i <= t) {//循环条件 if (i % n == 0) { System.out.println("能被33整除的有" + i); } i++;//循环变量迭代 } System.out.println("退出while ,继续.."); } }
运行结果
2、打印40—200之间所有的偶数[使用while]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class WhileExercise { //编写一个main方法 public static void main(String[] args) { int start = 40; int end = 200; while (start <= end) {//循环条件 if (start % 2 == 0) { System.out.println("偶数为" + start); } start++;//循环变量迭代 } System.out.println("退出while ,继续.."); } }
运行结果
do..while循环控制
基本语法
1
2
3
4
5循环变量初始化; do{ 循环体(语句); 循环变量迭代; }while(循环条件);
说明:
1、do while是关键字
1、也有循环四要素，只是位置不一样
2、先执行，再判断，也就是说，一定会执行一次
3、最后有一个分号;
4、while和do..while区别举例:要账
do...while循环执行流程分析
演示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class DoWhile { //编写一个main方法 public static void main(String[] args) { int i = 1; do { //循环执行语句 System.out.println("hello world~~~" + i); //循环变量迭代 i++; } while (i <= 10); System.out.println("退出do...while ,继续.."); System.out.println("i=" + i); } }
运行结果
注意事项和细节说明
1、循环条件是返回一个布尔值的表达式
2、do..while循环是先执行，再判断，因此它至少执行一次
do..while循环练习题
1、打印1—100
2、计算1—100的和
3、统计1—200之间能被5整除但不能被3整除的个数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class DoWhileExercise { //编写一个main方法 public static void main(String[] args) { //统计1—200之间能被5整除但不能被3整除的个数 int i = 1; int sum = 0; int a = 5; int b = 3; int num = 200; do { if (i % a == 0 && i % b != 0) { //循环执行语句 System.out.println("i=" + i); sum++; } i++;//循环变量迭代 } while (i <= num); System.out.println("sum=" + sum); } }
运行结果
4、如果李三不还钱，则将一直使出五连鞭，直到李三说还钱为止
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import java.util.Scanner; public class DoWhileExercise { //编写一个main方法 public static void main(String[] args) { //如果李三不还钱，则将一直使出五连鞭，直到李三说还钱为止 //[System.out.println("问:还钱吗?y/n")]do...while .. Scanner myScanner = new Scanner(System.in); char answer = ' '; do { //循环执行语句 System.out.println("使出五连鞭"); System.out.println("问:还钱吗?y/n"); answer = myScanner.next().charAt(0); System.out.println("他的回答是" + answer); } while (answer != 'y'); System.out.println("李三还钱了"); } }
运行结果
多重循环控制（难点!重点!)
介绍
1、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do..while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层.否则，代码的可读性很差】
2、实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[案例]。
3、设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次
案例
1
2
3
4
5
6
7
8
9
10
11public class DoWhileExercise { //编写一个main方法 public static void main(String[] args) { // for (int i = 0; i < 2; i++) {//第一层循环2 for (int j = 0; j < 3; j++) {//第二层循环3 System.out.println("i =" + i + "j=" + j);//2*3=6 } } } }
运行结果
应用实例：
1、统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
2、统计三个班及格人数,每个班有5名同学。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49import java.util.Scanner; public class MulForExercise { //编写一个main方法 public static void main(String[] args) { //统计3个班成绩情况，每个班有5名同学， // 求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。 //统计三个班级及格人数，每个班有5名同学 // //思路分析 //化繁为简 //(1) 先计算一个班，5个学生的成绩和平均分，使用for //1.1 创建 Scanner 对象然后，接收用户输入 //1.2 得到该班级的平均分，定义一个 double 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; for (int i = 1; i <= 3; i++) { double sum = 0;//一个班级的总分 for (int j = 1; j <= 5; 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 / 5)); totalScore += sum; } System.out.println("三个班总分=" + totalScore + "平均分=" + (totalScore / 15)); System.out.println("及格人数=" + passNum); } }
运行结果
3、打印出九九乘法表
经典的打印金字塔
使用for循环完成下面的案例
请编写一个程序，可以接收一个整数，表示层数(totalLevel)，打印出金字塔。
[化繁为简，先死后活]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61public 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 = 10;//层数 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(" "); } } //每打印完一层的*后，就换行 System.out.println(""); } } }
运行结果
跳转控制语句-break
看需求
随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次；
提示使用(int) (Math.random()*100)+1
思路分析
循环，但是循环的次数不知道，-> break ,当某个条件满足时，终止循环通过该需求可以说明其它流程控制的必要性，比如break
基本介绍
break语句用于终止某个语句块的执行，一般使用在switch或者循环[for , while , do-while]中
基本语法
1
2
3
4{ ...... break; ...... }
break示意图
break快速入门
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class BreakTest { //编写一个main方法 public static void main(String[] args) { //测试代码 for (int i = 0; i < 10; i++) { if (i == 3) { break; } System.out.println("i=" + i); } System.out.println("退出for循环，继续执行.."); // ...... } }
运行结果
break注意事项和细节说明
1、break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块
2、标签的基本使用
1
2
3
4
5
6
7
8
9label1: { ...... label2: { ...... label3: { ...... break; ...... } } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class BreakDetail { //编写一个main方法 public static void main(String[] args) { abc1: for (int j = 0; j < 4; j++) {//外层for abc2: for (int i = 0; i < 10; i++) {//内层for if (i == 2) { // break;//等价break abc2 break abc1; } System.out.println("i =" + i); } } } }
运行结果
解读
(1) break语句可以指定退出哪层
(2) label1是标签，名字由程序员指定
(3)break后指定到哪个label 就退出到哪里
(4)在实际的开发中，老韩尽量不要使用标签
(5)如果没有指定break,默认退出最近的循环体
break练习题
1、1-100以内的数求和,求出当和第一次大于20的当前数【for + break】
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24public class BreakExercise { //编写一个main方法 public static void main(String[] args) { //1-100以内的数求和,求出当和第一次大于20的当前数【for + break】 //思路分析 //1.循环 1-100，求和 sum //2.当 sum > 20 时，记录下当前的数，然后break //3.在for循环外部，定义变量n，把当前i赋给n //注意i的作用范围 for{} int sum = 0;//累计求和 int n = 0; for (int i = 1; i <= 100; i++) { sum += i;//累计 if (sum > 20) { System.out.println("和>20的时候 当前数i=" + i); n = i; break; } } System.out.println("当前数=" + n); } }
运行结果
2、实现登录验证，有3次机会，如果用户名为"丁真"，密码"666"提示登录成功，否则提示还有几次机会,请使用for+ break完成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36import java.util.Scanner; public class BreakExercise { //编写一个main方法 public static void main(String[] args) { //实现登录验证，有3次机会，如果用户名为"丁真"，密码"666"提示登录成功， //否则提示还有几次机会,请使用for+ break完成 //思路分析 //1.创建Scanner对象接收用户输入 //2.定义String name; String passwd; //3.最多循环3次[登录3次]，如果 满足条件就提前退出 //4.定义一个变量 int chance 记录还有几次登录机会 Scanner myScanner = new Scanner(System.in); String name = ""; String passwd = ""; int chance = 3;//登录一次，就减少一次 for (int i = 1; i <= 3; i++) { System.out.println("请输入名字"); name = myScanner.next(); System.out.println("请输入密码"); passwd = myScanner.next(); //比较输入的名字和密码是否正确 //补充说明字符串的内容 比较 使用的 方法 equals if ("丁真".equals(name) && "666".equals(passwd)) { System.out.println("恭喜你，登陆成功~~~"); break; } //登录的机会就会减少一次 chance--; System.out.println("你还有" + chance + "次登录机会"); } } }
运行结果
跳转控制语句-continue
continue基本介绍
1、continue语句用于结束本次循环，继续执行下一次循环。
2、continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样。
continue基本语法
1
2
3
4{ ...... continue; ...... }
continue示意图
continue快速入门
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class Continue { //编写一个main方法 public static void main(String[] args) { //代码 int i = 1; while (i <= 4) { i++; if (i == 2) { continue; } System.out.println("i=" + i); } } }
运行结果
continue细节案例分析和说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class ContinueDetail { //编写一个main方法 public static void main(String[] args) { label1: for (int j = 0; j < 4; j++) { label2: for (int i = 0; i < 10; i++) { if (i == 2) { //看看分别输出什么值,并分析 continue;// 等价于 continue label2 //continue label1;//输出 2次[0,1] } System.out.println("i = " + i); } } } }
运行结果
跳转控制语句-return
return介绍
return使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果return写在main方法，退出程序..
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class Return { //编写一个main方法 public static void main(String[] args) { for (int i = 1; i <= 5; i++) { if (i == 3) { System.out.println("Hello~~~" + i); //break; //continue; return;//当return用在方法时，表示跳出方法，如果使用在main,表示退出程序 } System.out.println("Hello World !!!"); } System.out.println("go on.."); } }
运行结果
最后
以上就是内向砖头最近收集整理的关于Java笔记007-程序控制结构/if-else/switch/for/while/do-while/多重循环控制(break/continue/return)程序控制结构分支控制if-elseswitch分支结构switch和if的比较for循环控制while循环控制do..while循环控制多重循环控制（难点!重点!)的全部内容，更多相关Java笔记007-程序控制结构/if-else/switch/for/while/do-while/多重循环控制(break/continue/return)程序控制结构分支控制if-elseswitch分支结构switch和if内容请搜索靠谱客的其他文章。
发表评论 取消回复