控制结构
程序流程控制介绍
在程序中，程序控制的流程控制决定程序如何执行，主要是三大流程控制语句
- 顺序控制
- 分支控制 if-else
- 循环控制
顺序控制
-
介绍
程序从上到下逐行地执行，中间没有任何判断和跳转
-
顺序控制举例和注意事项
Java中定义变量时采用合法的前向引用，如：
public class Test {
public static void main(String[] args) {
int num1 = 12;
int num2 = num1 + 2;
}
}
//错误的形式
public class Test {
public static void main(String[] args) {
int num2 = num1 + 2;//错误
int num1 = 12;
}
}
分支控制if-else
-
介绍
让程序有选择的执行 分支控制有三种
- 单分支 if
- 双分支 if-else
- 多分支 if-else if -else
-
单分支
-
基本语法
if(条件表达式){
执行代码块；（可以多条语句）
}
-
说明：当条件表达式为true时，就执行{}的代码。如果为false，就不执行。特别
说明，如果{}中只有一条语句。则可以不用{}，建议写上{}
案例
import java.util.Scanner;
public class If01 {
public static void main(String[] args) {
//演示单分支的使用 if的快速入门
//编写一个程序 可以输入人的年龄 如果大于18
//输出 你的年龄大于18，要对自己的行为负责，送入监狱
//思路
//创建一个Scanner对象
//定义 int age
//使用 if 判断
//定义一个Scanner对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入人的年龄");
//定义变量 age
int age =scanner.nextInt();
if (age > 18) {
System.out.println("你的年龄大于18，要对自己的行为负责，送入监狱");
}
System.out.println("程序继续......");
}
}
**单分支执行流程**
-
双分支
- 基本语法
if(条件表达式){
代码块1
}esle{
代码块2
}
说明：当条件表达式成立 即执行代码块1，否则执行代码块2 如果执行代码块只有一条语句 则{} 可以省略，否则 不能省略
案例：
import java.util.Scanner;
public class If02 {
public static void main(String[] args) {
//演示双分支的使用 if的快速入门
//编写一个程序 可以输入人的年龄 如果大于18
//输出 你的年龄大于18，要对自己的行为负责，送入监狱 否则输出 你的年龄不大，放过你
//思路
//创建一个Scanner对象
//定义 int age
//使用 if 判断
//定义一个Scanner对象
Scanner scanner = new Scanner(System.in);
System.out.println("输入你的年龄");
int age = scanner.nextInt();
if (age > 18){
System.out.println("你的年龄大于18，要对自己的行为负责，送入监狱");
} else { //双分支
System.out.println("你的年龄不大，放过你");
}
}
}
双分支流程图
- 单分支 和 双分支的练习题
public class IfExercise {
public static void main(String[] args) {
//IF的练习题
int x = 7;
int y = 4;
if (x > 5){
if (y > 5){
System.out.println( x +y);
}
System.out.println("韩顺平教育~");
}else {
System.out.println("x id" + x );
}
// 输出 韩顺平教育~
//编写程序，声明两个double型变量并赋值
//判断第一个数大于10.0 且第二个数小于20.0 打印两个数之和
double num1 = 15.5;
double num2 = 18.48;
if (num1 > 10.0 && num2 < 20.0 ){
System.out.println("两数之和"+(num1 + num2));
}
//定义两个变量int 判断二者之和 是否能被3整除又能被5整除 打印提示信息
//思路分析
//1.定义两个变量
//2 求和
//3 sum % 3 ，5 后 等于 0
//4 if esle
int num3 = 8;
int num4 = 7;
int sum = num3 + num4;
if (sum % 3 == 0 && sum % 5 ==0 ){
System.out.println("和可以被3又可以被5整除");
}else {
System.out.println("和可以被整除");
}
if (sum % 3 == 0 ){
if (sum % 5 == 0){
System.out.println(sum + "能被3整除又能被5整除");
}else {
System.out.println(sum + "能被3整除不能被5整除");
}
}else {
System.out.println(sum + "不能被3整除");
}
//判断一个年份是否为闰年 闰年的条件符合两者之一 ：
//1 年份能被4整除 但不能被100整除；
//2 能被400整除
//思路分析
//1 定义 int year 保存年
//2 年份能被4整除 但不能被100 整除 ， => year % 4 ==0 && year % != 0
// 3 能被400整除 = > year % 100 ==0
//代码实现
int year = 2023;
if ((year % 4 == 0 && year % 100 !=0) || year % 400 ==0){
System.out.println(year + "是闰年");
}else {
System.out.println(year + "不是闰年");
}
}
-
多分支
- 基本语法
if(条件表达式1){
执行代码块1；
}
else（条件表达式2）{
执行代码块2；
}
…
else{
执行代码块n；
}
多分支流程图
说明：
1.当条件表达式1成立时，即执行代码块1，
2.如果条件表达式1不成立，才去判断条件表达式2是否成立
3.如果条件表达式2成立，执行代码块2；
4.以此类推，如果所有的表达式都不成立
5.则执行else的代码块，注意，只能有一个执行入口
特别说明：（1）多分支可以没有else，如果所有的条件表达式都不成立， 则一个执行入口都没有 （2）如果有else，如果所有的条件表达式都不成立，则默认执行else代码块
import java.util.Scanner;
public class If03 {
public static void main(String[] args) {
/*
输入报国同志的信用分
如果
信用分为100 极好
(80-90] 优秀
[60-80] 一般
否则 不及格
请从键盘输入报国的信用分，并加以判断
假定信用分为int类型
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入报国同志的芝麻信用分:");
//请思考，如果输入的不是整数，而是hello..
//==》 这里我们会使用异常处理机制搞定
int score = myScanner.nextInt();
//先对输入的数据，进行一个范围的有效判断 1- 100 ，否则提示错误
if (score >= 1 && score <= 100){
if (score == 100){
System.out.println("极好");
}else if (score > 80 && score <= 99){ //信用分为(80,90]
System.out.println("优秀");
}else if (score >= 60 && score <= 80){
System.out.println("一般");
}else {
System.out.println("不合格");
}}
else {
System.out.println("你的输入有误,请重新输入");
}
boolean b = true;
if (b == false){
System.out.println("a");
}else if (b){
System.out.println("b");
}else if (!b){
System.out.println("c");
}else {
System.out.println("d");
}
//输出 b
boolean a = true;
if (a = false){
System.out.println("a");
}else if (a){
System.out.println("b");
}else if (!a){
System.out.println("c");
}else {
System.out.println("d");
}
//输出 c
}
}
-
嵌套分支
在一个分支架构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构成为内分支，外面的分支结构称为外分支，规范：不要超过3层 （可读性不好）
-
基本语法
if（）{
if（）{
//if-else
}else{
//if-else
}
}
-
import java.util.Scanner;
public class NestedIf {
public static void main(String[] args) {
//思路分析
//1. 创建Scanner对象
//2. 接收成绩
//3. if-else 大于8.0 进入决赛
//4. 接收性别 ，使用if-else 判断 进入男子组还是女子组
//创建Scanner对象
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，你被淘汰了~");
}
}
}
练习
import java.util.Scanner;
public class NestedIf02 {
public static void main(String[] args) {
//出票系统 根据淡旺季的月份和年龄，打印票价
// 4-10月 是旺季
// 成人 18-60 60 儿童 <18 半价 老人 > 60 1/3
//淡季
// 成人： 40
//其他：20
//思路分析
//创建一个Scanner对象
//输入 月份 使用 if-else 判断 双分支
//输入 年龄 使用if-else if -else 判断 多分支
//代码实现
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入月份");
int month = myScanner.nextInt();
if (month >= 4 && month <= 10){
System.out.println("请输入年龄");
int age = myScanner.nextInt();
if (age >= 18 && age <= 60) {
System.out.println("票价60");
}else if (age < 18){
System.out.println("票价30");
}else {
System.out.println("票价20");
}
}else {
System.out.println("请输入年龄");
int age = myScanner.nextInt();
if (age >= 18 && age <= 60 ){
System.out.println("票价40");
}else {
System.out.println("票价20");
}
}
}
}
switch分支结构
-
基本语法
switch（表达式）{
case 常量1：
语句块1；
break；
case 常量1：
语句块1；
break；
…
case 常量1：
语句块1；
break；
default；
default语句块；
break；
}
说明： 1. switch关键字 ，表示switch分支
2. 表达式 对应一个值 3. case 常量 1：当表达式的值等于常量1 就执行 语句块1 4. break 表示退出switch 5. 如果和case常量1匹配 就执行语句块1，如果没有匹配，就继续匹配case 常量2 6. 如果一个都没有匹配上，就执行default
switch流程图
import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport;import java.util.Scanner;public class Switch01 { public static void main(String[] args) { //请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d... //a 表示星期一， b表示星期二 ... // 根据用户输入显示相应的西悉尼，要求使用switch语句实现 //思路分析 //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; case 'd': System.out.println("星期四"); break; case 'e': System.out.println("星期五"); break; case 'f': System.out.println("星期六"); break; case 'g': System.out.println("星期天"); break; default: System.out.println("不存在，匹配不上"); } System.out.println("退出switch，继续执行程序"); }}
-
Switch的细节讨论
- 表达式数据类型，应和case后的常量一致，或者可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
- switch（表达式）中表达式的返回值必须是：（byte，short，int，char，enum（枚举），String）
double c =1.1;switch (c){ //错误 case 1.1: System.out.println("ok3"); break;}- case字句中的值必须是常量或常量表达式，而不是变量
- default字句是可选的，当没有匹配的case时，执行defualt
- break语句用来在执行一个case分支后使程序跳出switch语句块，如果没有写break，程序会顺序执行到底 除非遇到了break
char c = 'a'; switch (c){ case 'a': System.out.println("ok");// break; case 'b': System.out.println("ok2");// break; default: System.out.println("ok3"); }
public class SwitchDetail { public static void main(String[] args) { //演示switch的注意细节 // 表达式数据类型，应和case后的常量一致， // 或者可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int // char -> int -> long ->float -> double char c = 'a'; switch (c){ case 'a': System.out.println("ok"); break; case 'b': System.out.println("ok2"); break; default: System.out.println("ok3"); } //case字句中的值必须是常量或常量表达式，而不是变量 //break语句用来在执行一个case分支后使程序跳出switch语句块， // 如果没有写break，程序会顺序执行到底 }}
练习
import com.sun.corba.se.spi.ior.IdentifiableFactory;import java.util.Scanner;public class SwitchExercise { 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"); } //对学生成绩大于60分的，输出合格 低于60分的输出不合格 //提示 //思路分析 // 需要进行转换 取整 强转 (int)(成绩/60) double score1 = 88.5; if (score1 >=1 && score1 <= 100){ switch ((int)(score1/60)){ case 0: System.out.println("不及格"); break; case 1: System.out.println("及格"); break; }} else { System.out.println("输入的成绩在0-100"); } int score = myScanner.nextInt(); if (score>=1 && score <= 100){ if (score > 60){ System.out.println("合格"); }else { System.out.println("不合格"); } }else { System.out.println("输入有误"); } //根据指定的月份，打印该月份的季节。3、4、5 春节 6、7、8 夏季 // 9、10、11 秋季 1、2、12 冬季 使用穿透 //思路分析 //创建Scanner对象 //接收用户输入月份 int month //使用switch来匹配 使用穿透来比较简洁 System.out.println("输入月份"); int month = myScanner.nextInt(); 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 1: case 2: case 12: System.out.println("冬季"); break; default: System.out.println("你输入的月份不对1-12"); } }}
Switch和if的比较
- 如果判断的具体数值不多，而且符合byte short int char enum String 这6种类型，虽然两个语句都可以使用 建议使用switch
- 其他情况，对区间的判断，结果为boolean类型的判断，建议使用if，if的使用范围更广
for循环
让你的代码可以循环的执行
-
基本语法
for（循环变量初始化；循环条件；循环变量迭代）{
循环操作（可以多条语句）
}
老韩说明：
1. for关键字，表示循环控制2. for 有四要素 (1)循环变量初始化 (2) 循环条件 (3)循环操作 (4) 循环变量迭代3. 循环操作 这里可以有多条语句，也就是我们要循环执行的代码4. 如果 循环操作语句只有一条语句 可以省略{}，建议不要省略
public class For01 { public static void main(String[] args) { //打印十句 你好，韩顺平教育 for (int i = 1;i <= 10;i++){ System.out.println("你好，韩顺平教育" + i); } }}
- for循环执行流程
- for循环的注意事项和细节
- 循环条件时返回一个Boolean的表达式
- for（；循环条件；）中的初始化和变量迭代可以写在外面，但是两边的分号不能省略
- 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
- 使用内存分析法，分析以下输出
int count = 3; for (int k = 0,j=0; k < count;k++,j += 2){ System.out.println("k=" + k + "j=" + j); //k=0 <3 // k = 0 j=0 // 0 0 // k = 1 j = 2 // k =1 <3 //k = 1 j = 2 // 1 2 //k = 2 j =4 //k = 2 < 3 //k =2 j = 4 // 2 4 // k =3 j = 6 //k =3 !< 3 }
- for循环的编程思想
- 化繁为简
- 先死后活
public class ForExercise { public static void main(String[] args) { //打印1-100之间所有9的倍数的整数，统计个数 及总和 //老韩的两个编程思想（技巧） //1. 化繁为简 将复杂的需求，拆解成简单的需求，逐步完成 //2.先死后活 ：先考虑固定的值，然后转成可以灵活变化的值 //思路分析 //化繁为简 //完成输出 1-100的值 //在输出的过程中，进行过滤，只输出9的倍数 //统计个数 定义一个变量 int count =0 当条件满足时 count++ //总和 定义一个变量 int sum = 0 当条件满足时， sum += i int count = 0; int sum =0; for (int i = 1;i <= 100;i++){ if (i % 9 ==0) { count++; sum += i; System.out.println("i-"+i); } } System.out.println("count="+count); System.out.println("sum=" + sum); }}
While循环控制
-
基本语法
循环变量初始化；
while（循环条件）{
循环体；
循环变量迭代；
}
-
说明
- while循环也有四要素
- 只是四要素放的位置，不一样
-
while循环执行流程分析
public class While01 { public static void main(String[] args) { //演示while循环的使用 int i = 1;//循环变量初始化 while (i <= 10){//循环条件 System.out.println("你好，韩顺平教育"+ i); i++;//循环变量迭代 } System.out.println("退出while循环，继续执行"); }}
- 注意事项和细节
- 循环条件是返回一个布尔类型的表达式
- while循环先判断在执行
public class WhileExercise { public static void main(String[] args) { //打印1-100之间所有能被3整除的数 //化繁为简，先死后活 int i = 1; while (i <= 100){ if (i % 3 == 0){ System.out.println("i=" + i); } i++;//变量自增 } System.out.println("===================="); //打印40-200之间所有的偶数 //化繁为简，先死后活 int x = 40; while (x <= 200){ if (x % 2 ==0){ System.out.println("x=" + x); } x++; } }}
Do…While循环控制
-
基本语法
循环变量初始化
do {
循环体；
循环变量迭代；
}while（循环条件）；
-
说明
- do while 是关键字
- 也有循环四要素，只是位置不一样
- 先执行，在判断，也就是说，一定会至少执行一次
- 最后 有一个分号 ；
- while和do…while区别举例：要账
-
do…while循环执行流程
public class DoWhile { public static void main(String[] args) { //演示dowhile的使用 //输出十句韩顺平教育 int i= 1;//循环变量初始化 do { //循环体 System.out.println("你好，韩顺平教育" + i); i++;//循环变量迭代 }while (i <=10);//循环条件 System.out.println("退出do..while ，继续.."); }}
- 注意事项和细节说明
- 循环条件是返回一个布尔值的表达式
- do…while循环是先执行，再判断，一次至少执行一次
public class DoWhileExercise { public static void main(String[] args) { //打印1-100 int i = 1; do { System.out.println("i="+i); i++; }while (i <= 100); //计算1-100的和 int x = 1; int sum = 0; do { sum += x; x++; }while (x <= 100); System.out.println("sum=" + sum); //统计1-200之间能被5整除 但不能被3整除的个数 //化繁为简 //1、使用do while 输出 1- 200 //2、过滤 能被5整除 但不能被3整除 % //3、统计满足条件的个数 //先死后活 //范围的值 可以做成变量 //能被5整除 但不能被3整除 5 和 3 也可改为变量 int y = 1; int count = 0; do { if (y % 5 == 0 && y % 3 != 0){ System.out.println("y=" + y); count++; } y++; }while (y <= 200); System.out.println("count=" + count); // }}
import java.util.Scanner;public class DoWhileExercise02 { public static void main(String[] args) { //如果李三不还钱，则老韩将一直使出五连鞭 直到还钱 //化繁为简 //不停的问还钱吗 // 使用char answer 接收 定义一个Scanner对象 // 在do-while 的while中 判断 如果是 y 就不再循环 Scanner scanner = new Scanner(System.in); char answer = ' '; do { System.out.println("老韩使出5连鞭"); System.out.println("老韩问：还钱吗？y/n"); answer = scanner.next().charAt(0); System.out.println("它的回答是" + answer); }while (answer != 'y'); System.out.println("李三还欠钱了"); }}
多重循环控制（重点，难点）
- 介绍
- 将一个循环放在另一个循环体内，就形成了嵌套循环，其中，for，while，do while 均可以作为外层循环和内层循环。【建议一般使用两层，最多不超过三层，否则，代码的可读性很差】
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次的循环，开始下一次的循环
- 设外层循环次数为m次，内层为n次，则内层循环实际上需要执行m*n次
- 多重循环执行步骤分析
//i j
// 0 0 1 2
// 1 0 1 2
public class MulFor { public static void main(String[] args) { for (int i = 0; i < 2;i++){ for (int j =0; j < 3;j++){ System.out.println("i="+i+"j=" +j); } } }}
练习
import java.util.Scanner;public class MulForExercise01 { public static void main(String[] args) { //统计3个班的成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分 //【学生成绩从键盘输入】 //化繁为简 //1.先计算一个班的 5个学生的成绩 使用for // //2.创建一个Scanner对象 接收数据 //3.得到该班级的平均分 定义一个sum 把该班级5个学生的成绩累积 //4.嵌套循环再输出3个班级的成绩 平均分 //5.所有班级的平均分 //6.统计三个班级的及格人数 //定义一个变量 int count //可以优化 【可读性，结构】 //先死后活 // int x = 3; //班级个数 int y = 5; / double sum02 =0;//三个班级的总分 double avg02 =0; int count = 0; Scanner myScanner = new Scanner(System.in); for(int i = 1;i <= x;i++){ double sum01 = 0; double avg01 = 0; for (int j =1;j <= y;j++){ System.out.println("请输入第"+i+"班第"+j+"学生的成绩"); double score = myScanner.nextDouble(); //统计3个班级的及格人数 if (score >= 60){ count ++; } sum01 += score;//累积一个班级的总分 } //因为sum是5个学生的总成绩 avg01 = sum01 / y; System.out.println("第"+i+"班的平均成绩"+avg01); sum02 += sum01; } avg02 = sum02 / (x*y); System.out.println("所有班级的平均成绩"+avg02); //统计3个班级的及格人数 System.out.println("count="+count); }}
九九乘法表
空心金子塔
public class Stars { public static void main(String[] args) { //可以接收一个整数，表示层数（totalLevel），打印金字塔 //创建一个Scanner对象 /* * * * * * ********* */ //化繁为简 //1.先打印一个矩形 /* ****** ****** ****** ****** ****** */ //2.打印半个金字塔// * ** *** **** ***** //打印整个金子塔 /* * *** ***** ******* ********* */ //打印空心金字塔[最难想到的] /* * * * * * * * ********* */ //先死后活 int totalLevel = 10; for (int i = 1; i <= totalLevel;i++){// i表示层数 //在输出*之前还要输出空格 对应的空格 = 总层数-当前层 for (int x =1;x <= totalLevel-i;x++){ 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(""); } }}
空心菱形
public class Stars02 { public static void main(String[] args) { //打印一个空心的菱形 /* //1.打印一个矩形 ****** ****** ****** ****** ****** 2. 打印半边菱形 * 1 ** 2 *** 3 ** 4 * 5 3.打印半个菱形 * *** ***** ******* ********* ******* ***** *** * */ //打印上半部分 for (int i = 1;i <=5;i++){ for (int k =1 ;k<=5-i;k++) { System.out.print(" "); } for (int j=1;j<=2*i-1;j++){ System.out.print("*"); } System.out.println(""); } //打印下半部分 for (int i = 4 ; i >=1;i--){ for(int k=1 ;k<=5-i;k++){ System.out.print(" "); } for (int j =1;j<=2*i-1;j++){ System.out.print("*"); } System.out.println(""); } System.out.println("================="); for (int i = 1;i <=5;i++) { for (int k = 1; k <= 5 - i; k++) { System.out.print(" "); } for (int j = 1; j <= 2 * i - 1; j++) { if (j == 1 || j == 2 * i - 1) { System.out.print("*"); } else { System.out.print(" "); } } System.out.println(""); } for (int i = 4 ; i >=1;i--){ for(int k=1 ;k<=5-i;k++){ System.out.print(" "); } for (int j =1;j<=2*i-1;j++){ if (j ==1 || j== 2*i-1){ System.out.print("*"); }else { System.out.print(" "); } } System.out.println(""); } }}
跳转控制语句-break
-
需求
随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次
提示使用(int)(Math.random() * 100)+1
public class Random { public static void main(String[] args) { int count = 1; while (true){ //随机生成1-100的数 int random = (int)((Math.random()*100)+1); System.out.println("random=" +random); count++; //判断是否为97 if (random == 97){ break; } } System.out.println(count); }} -
基本介绍
- break语句用来终止某个语句块的执行，一般用在循环控制语句和switch语句中
-
基本语法
{
…
break;
…
}
-
执行流程图
public class Break01 { public static void main(String[] args) { for (int i = 0; i < 10 ; i++) { if (i == 3){ break; } System.out.println("i="+ i); } }}
- break语句的注意事项和细节
- break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
- 标签的基本使用
- break语句可以指定退出哪层
- label1是标签，由程序员指定
- break后指定哪个labl就退出哪里
- 在实际开发中，尽量不使用标签
- 如果没有指定break，默认退出最近的循环体
public class BreakDetail { public static void main(String[] args) { lable1: for (int j = 0;j < 4;j++){//外层for lable2: for (int i = 0; i < 10 ; i++) {//内层for if (i == 2){ break lable1;// break;//等价于 break label2 } System.out.println("i=" + i); } } }}
练习
public class BreakExercise { public static void main(String[] args) { //求1-100以内的和，当和大于20时输出当前数 //思路分析 // 循环 1-100 求和sum //当 sum > 20 记录当前数 int sum =0; int i = 1; //注意i的作用范围只在for循环里面 for (; i <=100 ; ) { sum += i; if (sum > 20){ System.out.println("i=" + i); break; } i++; } System.out.println("i=" + i); }}
练习二
import java.util.Scanner;public class BreakDetail02 { public static void main(String[] args) { //实现登录验证，有三次机会，如果用户名为"丁真"，密码”666“，提示登录成功 // 否则提示还有几次机会，请使用for+break完成 //思路分析 //1、创建Scanner 对象 接收用户输入 //2、定义两个String变量 //3、最多循环3次 如果满足条件就提前退出 Scanner myScanner = new Scanner(System.in); int count = 3; String username = ""; String password = ""; for (int i = 1;i <=3;i++){ System.out.println("输入用户名"); username= myScanner.next(); System.out.println("输入密码"); password= myScanner.next(); //比较输入的用户名和密码是否正确 //补充说明 字符串 内容是否相等 使用 equals 来比较 if (username.equals("丁真") && password.equals("666")){ System.out.println("登录成功"); break; } //减少登录次数 count--; System.out.println("还有"+count+"次机会"); } }}
跳转控制语句-Continue
-
基本介绍
- continue语句用于结束本次循环，继续执行下一次循环
- continue语句出现在多层嵌套循环语句中时，可以通过标签指定要跳过的是哪一层循环，这个和前面的标签色使用规则一样
-
基本语法
{
…
continue;
…
}
-
以while为例的执行流程分析
-
快速入门
public class Continue01 { public static void main(String[] args) { //代码 int i = 1; while (i <= 4){ i++; if (i == 2){ continue; } System.out.println("i=" + i); } }}
- 注意事项和细节
public class ContinueDetail { public static void main(String[] args) { lable1: for (int j = 0; j < 4 ; j++) { lable2: for (int i = 0; i < 10 ; i++) { if (i == 2) { //看看输出什么值，并分析 //continue ; //等价于 continue label2 continue lable2;//循环四次 输出0-1 3-9// continue lable1;//循环4次 输出4次0-1 } System.out.println("i=" + i); } } }}
跳转控制语句-return
- 介绍
- return使用在方法，表示退出所在的方法，在讲解方法的时候，会详细的介绍；注意return写在main方法，退出程序
public class Return01 { public static void main(String[] args) { for (int i = 1; i <=5 ; i++) { if (i==3){ System.out.println("韩顺平教育"+i);// break;// continue; return;//当return用在方法时，表示跳出方法，如果用在mian，表示退出程序 } System.out.println("Hello World"); } System.out.println("go on .."); }}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
