Java程序控制结构

已于 2022-10-01 20:56:40 修改
阅读量445 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 jvm
于 2022-09-08 22:36:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65508929/article/details/126773612
版权

目录

程序流程控制介绍

  • 在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句

1）顺序控制

2）分支控制

3）循环控制

顺序控制

  • 程序从上到下逐行地执行，中间没有任何判断和跳转

顺序控制举例和注意事项：

  • Java中定义变量时采用合法的前向引用

public class Test {

int num1 = 12;

int num2 = num1 + 2;

}

错误形式：

public class Test {

int num2 = num1 + 2;//error

int num1 = 12;

}

流程图：

img

分支控制 if-else

基本介绍

  • 让程序有选择地执行，分支控制有三种

1）单分支 if

2）双分支 if-else

3）多分支 if-else if -…-else

单分支

基本语法：

if (条件表达式) {

执行代码块;（可以有多余语句）

}

  • 说明：当条件表达式为 true 时，就会执行 { } 的代码。如果为false，就不执行
  • 另外，如果 { } 中只有一条语句，则可以不用 { } ，但最好还是用上
//if 的快速入门
import java.util.Scanner;//导入包
public class If01 {
	public static void main(String[] args) {
		//需求：编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁,
		//则输出 "你年龄大于 18,要对自己的行为负责,送入监狱"
		
		//思路分析
		//1. 接受输入的年龄，应该定义一个Scanner的对象
		//2. 把年龄保存到一个变量 int age
		//3. if 判断，输出对于信息
		
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		int age = scanner.nextInt();
		if (age > 18) {
			System.out.println("你年龄大于 18,要对自己的行为负责,送入监狱");
		}
		System.out.println("程序继续....");
	}
}

img

  • 单分支对应的流程图

img

双分支

基本语法：

if (条件表达式) {

执行代码块1;

} else {

执行代码块2;

}

  • 说明：当条件表达式成立，即执行代码块1，否则执行代码块2，如果执行代码块，只有一条语句，则 { } 可以省略，否则，不能省略
//if-else 的快速入门
import java.util.Scanner;//导入包
public class If02 {
	public static void main(String[] args) {
		//需求：编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁, 
		则输出 "你年龄大于 18,要对自己的行为负责, 送入监狱"。
		///否则 ,输出"你的年龄不大这次放过你了""
		
		//思路分析
		//1. 接受输入的年龄，应该定义一个Scanner的对象
		//2. 把年龄保存到一个变量 int age
		//3. if 判断，输出对于信息
		
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		int age = scanner.nextInt();
		if (age > 18) {
			System.out.println("你年龄大于 18,要对自己的行为负责,送入监狱");
		} else {//双分支
			System.out.println("你的年龄不大这次放过你了");
		}
		System.out.println("程序继续....");
	}
}

img

  • 双分支对应的流程图

img

多分支

基本语法：

if (条件表达式) {

执行代码块1;

} else if (条件表达式2) {

执行代码块2;

}

…

else {

执行代码块n;

}

  • 说明：（1）多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有（2）如果有else，如果所有的条件表达式都不成立，则默认执行else代码块
  1. 当条件表达式1成立时，即执行代码块1
  2. 如果表达式1不成立，才去判断表达式2是否成立
  3. 如果表达式2成立，就执行代码块2
  4. 以此类推，如果所有的表达式都不成立
  5. 则执行 else 代码块，注意，只能有一个执行入口
  • 多分支的流程图（重要!）

img

//多分支的课堂练习
import java.util.Scanner;
public class If03 {
	public static void main(String[] args) {
		/*输入保国同志的芝麻信用分： 
		如果： 
		信用分为 100 分时，输出 信用极好； 
		信用分为(80，99]时，输出 信用优秀； 
		信用分为[60,80]时，输出 信用一般； 
		其它情况 ，输出 信用 不及格 
		请从键盘输入保国的芝麻信用分，并加以判断 
		假定信用分数为 int */
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入保国同志的芝麻信用分(1-100)");
		int score = myScanner.nextInt();
		//先对输入的信用分，进行一个范围的有效判断 1-100，否则提示输入错误
		if (score >= 1 && score <= 100) {
			if (score == 100) {
				System.out.println("信用极好");
			} else if (score > 80 && score <= 99) {
				System.out.println("信用优秀");
			} else if (score >= 60 && score <= 80) {
				System.out.println("信用一般");
			} else {
				System.out.println("信用不及格");
			}
		} else {
			System.out.println("信用分需要在1-100，请重新输入！");
		}
	}
}

img

嵌套分支

  • 在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的机构成为内层分支外面的分支结构称为外层分支（另外最好不要超过3层，因可读性不好）

基本语法：

if () {

​ if () {

​ //if-else…

} else {

​ //if-else

​ }

}

//应用案例
import java.util.Scanner;
public class NestedIf {
	public static void main(String[] args) {
		//参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。
		//并且根据性别提示进入男子组或女子组。
		//输入成绩和性别，进行判断和输出信息。
		//[NestedIf.java] 
		//提示: double score; char gender; 
		//接收字符: char gender = scanner.next().charAt(0)
    	//scanner.next()表示的是接收到字符串
        //scanner.next().charAt(0)是接受到字符串的第一个字符
        
		//思路分析
		//1. 创建Scanner对象，接受用户输入
		//2. 接受成绩保存到 double score中
		//3. 使用 if-else 判断如果初赛成绩大于8.0进入决赛，否则提示淘汰
		//4. 如果进入到 决赛，再接受一个char gender，再使用if-else 输出信息
		
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入该歌手的成绩");
		double score = scanner.nextDouble();
		if (score > 8.0) {
			System.out.println("请输入性别");
			char gender = scanner.next().charAt(0);
			if (gender == '男') {
				System.out.println("进入男子组决赛");
			} else if (gender == '女') {
				System.out.println("进入女子组决赛");
			} else {
				System.out.println("你的性别有误，不能参加决赛");
			}
		} else {
			System.out.println("Sorry，你被淘汰了");
		}
	}
}

img

switch分支结构、

基本介绍

基本语法：

switch (表达式) {

case 常量1:

语句块1;

break;

case 常量2:

语句块2;

break;

…

case 常量n:

语句块n;

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流程图

img

switch注意事项和细节讨论

  1. 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//1. 表达式数据类型，应和case后的常量类型一致
		//或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
		char c = 'a';
		switch (c) {
			case 'a' :
				System.out.println("ok1");
				break;
			case "hello" ://error
				System.out.println("ok2");
				break;
			default :
				System.out.println("ok3");
		}
	}
}

img

//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//1. 表达式数据类型，应和case后的常量类型一致
		//或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
		char c = 'a';
		switch (c) {
			case 'a' :
				System.out.println("ok1");
				break;
			case 20 ://ok
				System.out.println("ok2");
				break;
			default :
				System.out.println("ok3");
		}
	}
}

img

//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//1. 表达式数据类型，应和case后的常量类型一致
		//或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
		String c = "a";
		switch (c) {
			case "a" :
				System.out.println("ok1");
				break;
			case "20" ://ok
				System.out.println("ok2");
				break;
			default :
				System.out.println("ok3");
		}
	}
}

img

//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//1. 表达式数据类型，应和case后的常量类型一致
		//或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
		String c = "a";
		switch (c) {
			case "a" :
				System.out.println("ok1");
				break;
            case 20 ://error
				System.out.println("ok2");
				break;
			default :
				System.out.println("ok3");
		}
	}
}

img

  1. switch(表达式)中表达式的返回值必须是：(byte、short、int、char、enum[枚举]、String)
//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		2. switch(表达式)中表达式的返回值必须是：（byte、short、int、char、enum[枚举]、String）
		double c1 = 1.1;//error
		switch (c1) {
			case 1.1 :
				System.out.println("ok1");
				break;
			case 2.1 :
				System.out.println("ok2");
				break;
			default :
				System.out.println("ok3");
		}
	}
}

img

  1. case子句中的值必须是常量，而不能使变量
//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//3. case子句中的值必须是常量或者常量表达式，不能是变量	
		char c = 'a';
		char c2 = 'c';
		switch (c) {
			case 'a' :
				System.out.println("ok1");
				break;
			case c2 :
				System.out.println("ok2");
				break;
			default :
				System.out.println("ok3");
		}	System.out.println("ok3");
	}
}

img

  1. default子句是可选的，当没有匹配的case时，执行default

  2. break语句用来在执行完一个case分支后使程序跳出switch语句块，如果没有break，程序会顺序执行到switch结尾，除非遇到break

//Switch细节
public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//5. break语句用来在执行完一个case分支后使程序跳出switch语句块
		//如果没有写break，程序会顺序执行到switch结尾，除非遇到break语句
		char c = 'a';
		char c2 = 'c';
		switch (c) {
			case 'a' :
				System.out.println("ok1");
				//break;
			case 'b' :
				System.out.println("ok2");
				//break;
			default :
				System.out.println("ok3");
		}
	}
}

img

switch和if的比较

  1. 如果判断的具体数值不多，而且符号 byte、short、int、char、enum[枚举]、String 这6种类型，虽然两个语句都可以使用，建议使用switch语句
  2. 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

for循环控制

基本介绍

  • 让你的代码可以循环的执行

基本语法：

for (循环变量初始化; 循环条件; 循环变量迭代) {

​ 循环操作(可以多条语句);

}

说明：

  1. for 关键字，表示循环控制
  2. for 有四要素：（1）循环变量初始化 （2）循环条件 （3）循环操作 （4）循环变量迭代
  3. 循环操作，这块可以有多条语句，也就是我们要循环执行的代码
  4. 如果 循环操作(语句) 只有这么一条语句，是可以省略 {} 的，但是建议不要省略

for循环执行流程分析

public class For01 {
	//编写一个main函数
	public static void main(String[] args) {
		//需求：打印10句：“你好，Zan教育”
		//for的写法
		for (int i = 1; i <= 10; i++) {
			System.out.println("你好，Zan教育" + i);
		}
		//System.out.println("你好，Zan教育" + i);//error
	}
}

img

  • for循环执行流程图

img

for循环注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. for (; 循环条件 ;)种的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略
  3. 补充：for (; 😉; //表示一个死循环
//演示for的使用细节
public class ForDetail {
	//编写一个main函数
	public static void main(String[] args) {
		//for(;循环判断条件;) 
		//中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
		使用for循环控制
		int i = 1;//循环变量初始化
		for ( ; i <= 10; ) {
			System.out.println("hello，Zan教育" + i);
			i++;
		}
		System.out.println("你好，Zan教育" + i);//ok - i = 11
	}
}

img

  1. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
//演示for的使用细节
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);
		}
	}
}

img

for循环练习题

//for 练习
public class ForExercise {
	//编写一个main函数
	public static void main(String[] args) {
		//打印1-100之间所有是9的倍数的整数，统计个数及综合[化繁为简]
		//1. 化繁为简：即将复杂的需求拆解成简单的需求，逐步完成
		//2. 先死后活：先考虑固定的值，然后转成可以灵活变化的值
		//思路分析
		//（1）完成 输出 1-100的值
		//（2）在输出的过程中，进行过度，只输出9的倍数
		//（3）统计个数 定义一个变量，int count = 0；当条件满足时，count++
		//（4）求出总和，定义一个变量 int sum = 0，当条件满足时 sum += i;
		//
		//先死后活
		//（1）为了适应更好的需求，把范围的开始的值和结束的值，做成变量
		//（2）还可以更进一步，9 倍数也做成变量 int t = 9;
		int count = 0;//统计个数
		int sum = 0;//表示总和
		int start = 1;
		int end = 100;
		int t = 9;//倍数
		for (int i = start; i <= end; i++) {
			if (i % t == 0) {
				count++;
				sum += i;
				System.out.println(i);
			}
		}
		System.out.println("count = " + count);
		System.out.println("sum = " + sum);
	}
}

img

while循环控制

基本介绍

基本语法：

while (循环条件) {

​ 循环体(语句);

​ 循环变量迭代;

}

1）while 循环也是有四要素的

2）只是四要素的位置和for不一样

//while 循环的案例
public class While01 {
	//编写一个main函数
	public static void main(String[] args) {
		//输出10句，你好，Zan
		int i = 1;//循环变量初始化
		while (i <= 10) {//循环条件
			System.out.println("你好，Zan" + i);//执行语句
			i++;//循环变量迭代
		}
		System.out.println("退出while，继续...");
	}
}

img

while循环执行流程分析

img

while循环注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. while 循环是先判断再执行语句

while循环练习题

//while 循环的练习
public class WhileExercise {
	//编写一个main函数
	public static void main(String[] args) {
		//1) 打印 1—100 之间所有能被 3 整除的数 [使用 while, 老师评讲 ] 
		int i = 1;
		while (i <= 100) {
			if (i % 3 == 0) {
				System.out.println(i);
			}
			i++;
		}
    	
		//2) 打印 40—200 之间所有的偶数 [使用 while, 课后练习]
		int j = 40;
		while (j <= 200) {
			if (j % 2 == 0) {
				System.out.println(j);
			}
			j++;
		}
	}
}

do…while循环控制

基本介绍

基本语法：

循环变量初始化：

do {

​ 循环体(语句);

​ 循环变量迭代;

} while (循环条件);

说明：

  1. do…while 是关键字
  2. do…while也有循环四要素，只是位置不一样
  3. 先执行，再判断，也就是说，一定会至少执行一次
  4. 注意while最后是有个分号的
//do while 循环的案例
public class DoWhile {
	//编写一个main函数
	public static void main(String[] args) {
		//输出10句，你好，Zan
		int i = 1;//循环变量初始化
		do {
			//循环执行语句
			System.out.println("你好，Zan" + i);
			//循环条件迭代
			i++;
		} while (i <= 10);
		System.out.println("退出do while");
	}
}

do…while循环执行流程分析

img

do…while循环注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. do…while 循环是先执行，再判断，因此它至少执行一次

do…while循环练习题

//do while 循环的练习
public class DoWhileExercise01 {
	//编写一个main函数
	public static void main(String[] args) {
		//1) 打印 1—100 [学生做] 
		// int i = 1;
		// do {
		// 	System.out.println(i);
		// 	i++;
		// } while (i <= 100);

		//2) 计算 1—100 的和 [学生做] 		
		// int j = 1;
		// int sum = 0;
		// do {
		// 	sum += j;
		// 	j++;
		// } while (j <= 100);
		// System.out.println(sum);
		
		//3) 统计 1---200 之间能被 5 整除但不能被 3 整除的个数
		int z = 1;
		int count = 0;
		do {
			if (z % 5 == 0 && z % 3 != 0) {
				count++;
				System.out.println(z);
			}
			z++;
		} while (z <= 200);
		System.out.println(count);		
	}
}
  • 还钱案例：
//do while 循环的练习
import java.util.Scanner;
public class DoWhileExercise02 {
	//编写一个main函数
	public static void main(String[] args) {
		//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止 
		//[System.out.println("老韩问：还钱吗？y/n")]
		//
		//化繁为简
		//（1）不停的问：还钱吗？
		//（2）使用char answer 接受 - 定义一个Scanner对象
		//（3）在do-while 种 判断，如果y则不再循环
		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);
			if (answer == 'n') {
			}
		} while (answer != 'y');//判断条件狠关键
		System.out.println("李三还钱了");
	}
}

多重循环控制

基本介绍

1）将一个循环放在另一个循环体内，就形成了嵌套循环，其中，for，while，do…while均可以作为外层循环和内层循环【建议一般使用两层，最多不要超过3层，否则，代码的可读性很差】

2）实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环

public class MulFor {
	//编写一个main函数
	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); 
			} 
		}
	}
}

img

3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次

img

多重循环控制练习题

import java.util.Scanner;
public class MulForExercise {
	//编写一个main函数
	public static void main(String[] args) {
		//1) 统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。 
		//思路分析
		//化繁为简
		//（1）先计算一个班，5个学生的成绩
		//1.1 创建 Scanner 对象然后接受用户输入
		//1.2 得到该班级的平均分，定义一个double sum ，把该班级5个学生的成绩累计
		//（2）统计3个班（每个班5个学生）平均分
		//（3）所有班级的平均分
		//3.1 定义一个变量，double totalScore 累计所有学生的成绩
		//3.2 多重循环结束后，totalScore / (3 * 5)
		// (4) 统计三个班及格人数，每个班有 5 名同学。
		//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++) {
			double sum = 0; //一个班级的总分
			for (int j = 1; j <= stuNum; j++) {
				System.out.println("请输入第" + i + "个班的第" + j + "个学生的成绩");
				double score = myScanner.nextDouble();
				//当有一个学生成绩>=60 passNum++
				if (score >= 60) {
					passNum++;
				}
				sum += score;
				System.out.println("成绩为" + score);
			}
			System.out.println("平均分为" + (sum / stuNum));
			//把sum累积到totalScore
			totalScore += sum;
		}
		System.out.println("三个班总分=" + totalScore + " 平均分为" + (totalScore / (classNum*stuNum)));
		System.out.println("累计及格的人数=" + passNum);
	}
}
  • 经典的打印金字塔

img

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(" ");
				}
			}
			//每打印一层*后。就换行 println
			System.out.println("");
		}	
	}
}

跳转控制语句-break

基本介绍

  • break语句用于终止某个语句块的执行，一般使用再 switch 或者循环[for、while、do-while]中

基本语法：

{

​ …

​ break;

​ …

}

public class Break01 {
	//编写一个main函数
	public static void main(String[] args) {
		
		for (int i = 0; i < 10; i++) {
			if (i == 3) {
				break;
			}
			System.out.println(i);
		}
		System.out.println("退出for循环");
	}
}

以while使用break的流程图

img

break使用的注意事项和细节说明

  1. break语句出现在多层嵌套的语句块中，可以通过标签来执行要终止的是哪一层语句块
  2. 标签的基本使用

label1: { …

label2: { …

label3: { …

​ break;

​ …

​ }

​ }

​ }

说明：

  1. break 语句可以指定退出哪层
  2. label1 是标签，名字由程序员指定（即任意名字都可以）
  3. break 后指到哪个label，就退出到哪个label
  4. 在实际的开发中，尽量不要使用标签（因为会影响代码的可读性）
  5. 如果没有指定的break，会默认退出最近的循环体
public class BreakDetail {
	//编写一个main函数
	public static void main(String[] args) {
        1. 第一种break label1
		label1:
		for (int j = 0; j < 4; j++) {
		label2:
			for (int i = 0; i < 10; i++) {
				if (i == 3) {
					break label1;
				}
				System.out.println(i);
			}
		}
		
		System.out.println("退出for循环");

        2. 第二种break 即 break ；label2
		label1:
		for (int j = 0; j < 4; j++) {
		label2:
			for (int i = 0; i < 10; i++) {
				if (i == 3) {
					break ;//等价于break label2
				}
				System.out.println(i);
			}
		}
		
		System.out.println("退出for循环"); 
		
	}
}

img

img

break练习题

import java.util.Scanner;
public class BreakExercise02 {
	//编写一个main函数
	public static void main(String[] args) {
		//实现登录验证，有 3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，
		//请使用 for+break 完成 BreakExercise02.java
		
		//思路分析
		//1. 创建Scanner对象接受用户输入
		//2. 定义 String name；String passwd：保存用户名和密码
		//3. 最多循环3次[登录3次]，如果满足条件就提前退出
		//4. 定义一个变量 int chance 记录还有几次登录机会
		Scanner myScanner = new Scanner(System.in);
		int chance = 3;
		String name = "";
		String passwd = "";
		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 +"次登录机会");
		}
	}
}
  • 补充：字符串对齐需要用到equals

img

有两种写法：

  1. name.equals(“丁真”);
  2. “丁真”.equals(name);（推荐这种）

原因：方法一的name可能会是空指针，导致报错

跳转控制语句-continue

基本介绍

  • continue 语句用于结束本次循环，继续执行下一次循环
  • continue 语句出现在多层嵌套的循环语句体中时，可以通过标签来指明要跳过的是哪一层循环，这个和前面的break的标签的使用的规则一样

基本语法：

{ …………

​ continue

} …………

以while使用continue的流程图

img

continue细节案例分析和说明

public class ContinueDetail {
	//编写一个main函数
	public static void main(String[] args) {
		label1: 
		for(int j = 0; j < 2; j++) { 
		label2: 
			for(int i = 0; i < 10; i++) {
				if(i == 2) { 
				//看看分别输出什么值，并分析 
					//continue ; //等价于 continue lable2 - 输出2次 0 1 3 4 5 6 7 8 9 
					//continue label2; //输出2次 0 1 3 4 5 6 7 8 9 - 跟continue一致
					continue label1; //输出2次 0 1
				}
				System.out.println("i = " + i); 
			} 
		}
	}
}

跳转控制语句-return

return 使用在方法，表示跳出所在的方法，即如果return写在main方法内，则会跳出main程序

public class Return01 {
	//编写一个main函数
	public static void main(String[] args) {
		for (int i = 1; i <= 5; i++) {
			if (i == 3) {
				System.out.println("老韩教育" + i);
				1. return;//当return用在方法时，表示跳出方法，如果用在main里面，就是退出main方法
				2. break;
			}
			System.out.println("Hello World!");
		}
		System.out.println("go on...");
	}
}

img

itzzan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java提供的4种基本控制语句结构_JAVA-基础-控制结构
weixin_36011776的博客
02-16 888
一、控制结构控制结构是控制程序如何运行的特殊的语句结构。控制结构分为 顺序控制结构 分支控制结构 循环控制结构。二、顺序控制结构除了分支控制结构 和 循环控制结构之外的语句都是按照顺序控制结构运行的。即，语句由上到下，由左到右依次执行。三、分支控制结构1.if判断i. if语句if可以实现判断，通过判断的结构决定是否执行某段代码。基本结构：执行逻辑图：ii. if..else..语句基本结构：执行...
Java 程序的控制结构
Withadream的博客
11-27 477
Java 程序的控制结构
Java流程控制结构
xunmengyinjia的博客
09-26 1158
（4）循环结构：循环结构是根据判断条件来重复性地执行某段代码。Java提供了while语句、do-while语句、for语句来实现循环。（3）选择结构：选择结构是根据条件判断的结果来选择执行不同的代码。选择结构可以细分为单分支结构、双分支结构和多分支结构。Java提供了if控制语句和switch语句来实现选择结构。（2）顺序结构：顺序结构是指程序从上向下依次执行每条语句的结构，中间没有任何的判断和跳转。（1）在Java中有3种流程控制结构：顺序结构、选择结构、循环结构。
Java的三种控制结构
“愤斗”小四
08-07 6956
1.顺序结构        按照顺序一句一句执行顺序结构是最简单的算法结构 public class SequenceTest { public static void main(String[] args) { // TODO Auto-generated method stub int num1 = 9; System.out.println(num1); int nu...
java流程控制语句结构_Java语句与流程控制结构（一）
weixin_39905624的博客
02-25 99
流程控制语句结构流程语句控制结构分为:1.顺序结构： 按顺序执行2.分支结构：选择一个分支执行3.循环结构：重复执行某个语句一. 顺序结构执行过程：从上往下执行1. 输入/输出语句1.1 输出语句System.out.println("我是一条输出语句");# 输出变量int a = 1;System.out.println(a);1.2 输入语句步骤:准备Scanner类型变量提示输入内容接...
Java程序控制结构 第五章代码
最新发布
09-18
Java程序控制结构是编程语言中的基础，用于指导程序的执行流程。在第五章中，我们通常会学习到条件语句（if-else）、循环结构（for、while、do-while）、选择结构（switch-case）以及跳转语句（break、continue）。...
Java流程控制顺序结构原理解析
08-25
Java流程控制 顺序结构是 Java 编程语言中最基本的流程控制结构之一。它按照代码的编写顺序，从上往下依次执行语句，这种结构非常简单易懂，但却是 Java 编程语言中最基本的流程控制结构。 在 Java 中，顺序结构是...
java 学习笔记(入门篇)_程序流程控制结构和方法
09-05
Java编程语言中的程序流程控制结构是构建程序逻辑的基础，主要包括顺序结构、选择结构、循环结构以及异常处理结构。这些结构决定了程序中语句的执行顺序和方式。 1. **顺序结构**：这是最基本的结构，程序中的语句...
JAVA程序设计课件-Java程序结构.pptx
12-01
以下是对Java程序结构的详细解释，这对于理解和编写Java程序至关重要。 1. **项目（Project）** 项目是开发过程中的一个组织单位，它通常包含了多个相关的源代码文件、资源文件以及配置文件。在Java中，一个项目...
java程序设计例题全集
04-21
从标签“java程序设计”我们可以推断，这些示例将围绕Java语言的核心概念展开，如类、对象、方法、变量、数据类型、控制结构（如if-else，for，while循环）、继承、接口、异常处理等。这些都是学习Java时必须掌握的...
JAVA的基本控制结构
qq_61897054的博客
02-14 2264
JAVA的基本控制结构 在Java语言中有三种基本控制结构： 顺序结构 选择结构 循环结构 顺序结构 顺序结构是JAVA语言的基本结构，也是最简单的算法结构。程序按照从上到下的顺序一行一行的执行，中间没有任何判断和跳转。 例如： Scanner scanner = new Scanner(System.in); System.out.println("请输入要输出的值"); String str=scanner.nextLine(); Sy
Java程序结构设计
SuperMan程序人生（关注微信公众号）
06-20 1455
程序的结构设计 程序的结构包含有下面三种 ⑴ 顺序结构 ⑵ 选择结构 ⑶ 循环结构 （1）顺序结构 顺序结构程序就是按书写顺序执行的语句构成的程序段。就是傻瓜式的从上到下依次执行代码语句。 如图： （2）选择结构 根据输入数据和中间结果的不同情况需要选择不同的语句组执行。 Java语言中的选择结构提供了...
【Java】]Java的三大控制结构
热门推荐
君君的博客
03-05 1万+
前面我们已经对基本数据类型，引用数据类型以及运算符等做了详细的介绍，那我们接下来学习一下Java基础语法。     走遍天下的三大控制结构我们大家还记得吗？无论我们学习什么专业，无论我们学习什么语言，都会遵循着三大控制结构，今天我们就说一下Java的三大控制结构。  一、顺序        总觉得顺序这一方面没什么可说的，一个程序，从main方法开始，一步一步的执行，都有自己的顺序，因此一个
六、Java程序控制结构
Alfred_tfk的博客
11-14 712
文章目录程序控制结构一、程序流程控制介绍二、顺序控制三、分支控制 if-else1. 分支控制 if-else 介绍2. 单分支四、双分支1.双分支2. 多分支3. 多分支的流程图(重要!)五、嵌套分支1. 基本介绍2. 基本语法六、switch 分支结构1. 基本语法2. 流程图3. 快速入门4. switch 注意事项和细节讨论5. switch 和 if 的比较七、for 循环控制(!!!)1. 看一个实际需求2. 基本语法3. for 循环执行流程分析![在这里插入图片描述](https://img
Java中基本程序控制结构
xq8866
06-24 632
  Java中基本程序控制结构   1、Java中基本程序控制结构分为三种即：顺序结构、分支结构、循环结构。 （1）顺序结构不必多说，就是从上至下依次执行。 （2）分支结构语句有：if语句、switch语句，还有条件运算符（ ? : ）。 （3）循环结构语句有三种即：for、while、do-while。其他可以实现循环的有：复合赋值运算符（+=、 -=等）、递归调用方法。   ...
java流程控制结构_JAVA-语言基础-流程控制的三种结构
weixin_29437577的博客
02-16 698
1、 流程控制：代码运行顺序，共三种：顺序结构+分支结构+判断结构2、 顺序结构：从上到下，从左到右依次执行【和C语言不同，需要注意，如int i = 5;i+=i-=i*=5; C的结果为0，而JAVA的结果为-15】3、 分支结构：1) 判断结构：A) if( boolean ){代码块 }B) if(boolean){ 代码块1}else{ 代码块2 ...
JAVA流程控制的三种结构
weixin_44160104的博客
07-12 1430
小白的第一篇试水博客！ impact java的流程控制 顺序结构：程序进入主方法后从上到下依次执行代码； 选择结构：if switch 循环结构：while do-while for 选择结构 if if单分支 /** 语法结构： if(表达式.boolean值){ 执行语句; } 执行顺序： 如果表达式的boolean值为true执行对应的语句； 如何boolea...
Java学习总结——程序控制结构
原来是松松呀~
01-22 717
柒——程序执行方向 一、程序逻辑 结构化程序设计（Structured programming）是一种经典的编程模式，在1960年开始发展，其思想最早是由荷兰著名计算机科学家 E.W. Dijkstra 提出的，他设计了一套规则，使程序设计具有合理的结构，用以保证程序的正确性。这套规则要求程序设计者按照一定的结构形式来设计和编写程序，而不是“天马行空”地根据程序员的意愿来编写。早期的程序员广泛...
java程序控制结构实验原理
04-23
Java程序控制结构实验原理主要包括以下几个方面： 1. 条件语句（if语句、switch语句）的掌握与应用； 2. 循环语句（while循环、do-while循环、for循环）的掌握与应用； 3. 循环控制语句（break语句、continue语句）的掌握与应用； 4. 函数的掌握与应用； 5. 数组的掌握与应用。 在实验中，首先需要理解各种控制结构的语法和用法，然后通过编写程序来熟练掌握。同时，还需要注意程序的效率、可读性和易维护性，避免出现死循环等常见错误。通过多次实验与练习，能够加深对Java程序控制结构的理解与应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

itzzan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值