目录
1、统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次；
程序控制结构
顺序控制
分支控制(if ,else, switch)
循环控制(for, while , dowhile,多重循环)
break
continue
return
程序流程控制介绍
在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌的，主要有三大流程控制语句。
1、顺序控制
2、分支控制
3、循环控制
顺序控制介绍
程序从上到下逐行地执行，中间没有任何判断和跳车转。
顺序控制举例和注意事项
Java中定义成员变量时采用合法的前向引用。如：
public 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，就不执行。
特别说明：如果中只有一条语句，则可以不用{ }建议写上{ }
双分支
基本语法
if(条件表达式){
执行代码块1;}
else {
执行代码块2;
}说明：当条件表达式成立，即执行代码块1，否则执行代码块2。
如果执行代码块只有一条语句，则可以省略，否则，不能省略。
单分支和双分支练习题
1、编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个
数小于20.0，打印两数之和。
2、定义两个变量int,判断二者的和，是否能被3又能被5整除，打印提示信息
3、判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整
除，但不能被100整除;(2)能被400整除
//单分支和双分支练习
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 + "不是 闰年");
}
}
}运行结果
多分支基本语法
if(条件表达式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、请从键盘输入保国的芝麻信用分，并加以判断
import 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层(可读性不好)
基本语法
if( ){
if( ){
//if-else....
}else{
//if-else
}
}应用案例
参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。
提示：double score; char gender;
接收字符：char gender = scanner.next).charAt(O)
import 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分支结构
基本语法
switch(表达式){
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语句完成
import 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)
double 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"。
import 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
import 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冬季[提示使用穿透]
import 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循环控制
基本介绍
让代码可以循环执行
基本语法
for(循环变量初始化;循环条件;循环变量迭代){
循环操作(可以多条语句);
}说明
1、for关键字，表示循环控制
2、for有四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3、循环操作，这里可以有多条语句，也就是我们要循环执行的代码
4、如果循环操作(语句)只有一条语句，可以省略建议不要省略
for循环执行流程分析
public 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、使用内存分析法，分析输出下面代码输出什么?
public 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、完成下面的表达式输出
public 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);
}
}运行结果
public 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循环控制
基本语法
循环变量初始化;
while(循环条件){
循环体(语句);
循环变量迭代;
}说明
1、 while循环也有四要素
2、只是四要素放的位置，不一样。
while循环执行流程分析
演示
public 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]
public 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]
public 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循环控制
基本语法
循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);说明:
1、do while是关键字
1、也有循环四要素，只是位置不一样
2、先执行，再判断，也就是说，一定会执行一次
3、最后有一个分号;
4、while和do..while区别举例:要账
do...while循环执行流程分析
演示
public 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整除的个数
public 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、如果李三不还钱，则将一直使出五连鞭，直到李三说还钱为止
import 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次
案例
public 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名同学。
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 得到该班级的平均分，定义一个 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)，打印出金字塔。
[化繁为简，先死后活]
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 = 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]中
基本语法
{ ......
break;
......
}break示意图
break快速入门
public 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、标签的基本使用
label1: { ......
label2: { ......
label3: { ......
break;
......
}
}
}
public 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】
public 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完成
import 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基本语法
{ ......
continue;
......
}continue示意图
continue快速入门
public 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细节案例分析和说明
public 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方法，退出程序..
public 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..");
}
}运行结果
342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
