Java——流程控制语句

最新推荐文章于 2024-07-28 19:41:52 发布

cheer on seventeen

最新推荐文章于 2024-07-28 19:41:52 发布

阅读量890

点赞数 22

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_77967541/article/details/139202019

版权

顺序控制

顺序语句：程序从上到下逐行执行，中间没有任何判断和跳转。

        //正确形式 
		int number1 = 4;
		int number2 = number1 + 5;
		
		//错误形式
		int number2 = number1 + 5;
		int numbre1 = 4;

分支语句（if、else、switch）

if—else控制语句

单分支

基本语法：

if(条件表达式) {
			执行的代码块；
		}

说明：当条件表达式的执行结果为true时，才会执行后面的代码块，如果条件表达式结果为false，则不会执行后面的代码块。

        //输出当年龄大于等于十八的时候，输出已经成人
		//定义年龄变量
		int year = 20;
		//进行判断
		if(year >= 18) {
			System.out.println("已经成年");
		}

已经成年

双分支

基本格式：

        if(条件表达式) {
			语句块1；
		}else {
			语句块2；
		}

说明：当条件表达式为true时，程序则执行语句块1的语句，如果表达式为false，则执行语句2的语句。

        //输出当年龄大于等于十八的时候，输出已经成人，如果年龄小于十八，输出未成年
		//定义年龄变量
		int year = 15;
		//进行判断
		if(year >= 18) {
			System.out.println("已经成年");
		}else {
			System.out.println("未成年");
		}

未成年

多分支

基本格式：

        if(条件表达式1) {
			语句1；
		}else if(条件表达式2) {
			语句2；
		}else if(条件表达式3) {
			语句3；
		}
		.
		.
		.
	    }else if(条件表达式n) {
	    	语句n；
	    }else {
	    	语句n+1；
	    }

说明：首先程序先进行条件语句的判断，当条件表达式的结果为真时，就会执行对应的语句，如果所有的条件表达式都为false，则会执行最后所写的else后的语句，当然如果最后没有写else，则程序就会不会输出结果。

        //输出当年龄小于18则输出未成年，
		//当年龄大于等于18并且小于60，输出成年，
		//当年龄大于等于60则输出老年
		//定义年龄变量
		int year = 88;
		//进行判断
		if(year < 18) {
			System.out.println("未成年");
		}else if(year >=18 && year < 60){
			System.out.println("成年");
		}else if(year > 60){
			System.out.println("老年");
		}else {
			System.out.println("您输入错误");
		}

老年

switch控制语句

基本语法：

        switch(表达式) {
		case 常量1:
			语句块1；
			break；
		case 常量2:
			语句块2；
			break；
		case 常量3:
			语句块3；
			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，如果没有default，就会退出。

注意：

1.表达式数据类型，应和case后的常量类型一致，或者是可以自动转换可以相互比较的类型。

2.switch（表达式）中的表达式的返回值为必须是（byte、int、short、char、String、enum（枚举））

        double number = 1.1;
		//错误，表达式不能为double
		switch(number) {
		//错误
		case 1.1:
			System.out.println("1.1");
			break;
		}

3.case子句中的值必须为常量，不可以是变量

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

        int c = 88;
 		switch(c) {
		case 1:
			System.out.println("1");
			break;
		case 2:
			System.out.println("2");
			break;
		case 3:
			System.out.println("3");
			break;
		case 4:
			System.out.println("4");
			break;
		default:
			System.out.println("没有找到相应结果");
            break;	
		}

没有找到相应结果

5.break语句用来执行完一个case分支后使用程序跳出switch语句块，如果没有写break，程序会一直执行到switch结尾。

        int c = 2;
		switch(c) {
		case 1:
			System.out.println("1");
			break;
		case 2:
			System.out.println("2");
			
		case 3:
			System.out.println("3");
			
		case 4:
			System.out.println("4");
			break;
		default:
			System.out.println("没有找到相应结果");	
			break;
		}

2
3
4

if—else语句和switch语句相比较

1.如果判断的具体类型数值不多，而且符合（byte、int、short、char、String、enum（枚举））着6种类型，虽然两个语句都可以使用，建议switch。

2.其他情况，对区间判断，对结果为boolean类型判断，使用if。

循环语句（for、while、do while，多重循环）

for

基本格式：

for(循环变量初始化;循环条件;循环迭代) {
			循环语句块；
		}

说明：

1.for关键字，表示循环控制；

2.for有四要素：循环变量初始化、循环条件、循环语句、循环迭代

注意：

1.循环条件是返回的一个布尔值的表达式

2.for（；循环判断条件；）中的初始化和迭代变量可以写在其他地方，但是两边分号不能省略。

        int a = 0 ;
		for(;a<5;) {
			System.out.println(a);
			a++;
		}
		//上下两种方式相同
		for(int j = 0; j < 5; j++) {
			System.out.println(j);
		}

3.循环初始值可以有很多条初始化语句，但要求类型一致，并且中间用逗号隔开。循环迭代也可以有多个迭代语句，中间用逗号隔开。

while

基本格式：

        循环变量初始化；
		while(循环条件) {
			循环语句块；
			循环迭代条件；
		}

说明：while也有四要素，与for的位置不同，但是四要素相同。

        int i = 0;
		while(i < 5) {
			System.out.println(i);
			i++;
		}

do while

基本格式：

        循环初始化；
		do {
			循环体；
			循环迭代；
		}while(循环条件);

说明：

1.do while 是关键字。

2.先执行，在判断，也就是会说明循环体一定至少执行一次。

注意：

1.循环条件是返回一个布尔值的表达式。

2.do while 循环是先循环一次循环体，在进行判断。至少执行一次。

        int h = 0;
		do {
			System.out.println(h);
			h++;
		}while(h < 5);

举例：

        Scanner myScanner = new Scanner(System.in);
		char answer = ' ';
		
		do {
			
			System.out.println("使用暴力美学");
			System.out.println("还钱吗？");
			answer = myScanner.next().charAt(0);
			System.out.println("他的回答是：" + answer);
						
		}while(answer != 'y');

使用暴力美学
还钱吗？
f
他的回答是：f
使用暴力美学
还钱吗？
y
他的回答是：y

多重循环

1.将一个循环放在另外一个循环体内，就形成了嵌套循环，其中for/whike/do while

均可以作为外层循环或者是内层循环。

2.实质上，嵌套循环就是把内层循环当做外层循环的循环体，只有当内层循环的结果为false时，才会完全跳出内层循环，才可以结束外层循环的当次循环，进行下一次循环。

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

案例：

        for(int i = 0;i < 2; i++) {
			for(int j =0; j < 3; j++) {
				System.out.println("i="+i+" "+"j="+j );
			}
		}
		//我们来分析一下
		//首先是我们的i=0，符合条件进入循环，当我们来到了内层循环，j=0，符合条件，然后进行循环，输 
          出i=0 j=0
		//然后当j=0执行后，进行j++，j=1；然后我们发现j=1；也符合条件，进行循环，我们可以得出i=0 
          j=1
		//然后我们再次执行j++，j=2，然后也符合条件，进行循环，得出i=0 j =2
		//然后我们进行j++，j=3，我们发现不符合循环条件，因此结束内层循环，开始外层的下一次循环
		//我们先执行i++，然后i=1，然后再次进入内层循环，注意，这时我们要重新进行内层的循环，所以之 
          前的j=3，执行完初始化j=0
		//然后依次进行

i=0 j=0
i=0 j=1
i=0 j=2
i=1 j=0
i=1 j=1
i=1 j=2

//计算三个班级的，每个班级有5名学生，的平均成绩和三个班加起来的平均成绩（学生的成绩均由控制台输入），最后统计学生的及格数
		//化繁为简
		//首先我们要先简单来看，先输入一个班级的学生的成绩和计算出来一个班级的平均成绩
		//使用Scanner来实现控制台输入
		//当我们得到了一个班级学生的所有成绩之后，我们要计算班级的平均成绩
		//当我们得出一个班级的情况之后，我们可以再次用for循环来实现三个班级的成绩输入与计算，将之前的循环嵌套进去
		//我们通过嵌套循环就得到了三个班级的成绩和平均成绩，三个班级的平均成绩加起来除以班级个数我们就可以得到了所有的平均成绩
		//然后我们去统计及格学生的人数，我们知道成绩大于等于60为及格，所以我们使用if语句，在我们输入每一个学生成绩时就进行一次判断
		
		//先死后活
		//我们知道从题目中知道有三个班级，每个班级有5名学生，那么如果是10个班级，每个班级有20名学生呢，所以我们可以去定义班级的个数，和每个班级学生的个数
		//当我们定义了班级和学生，我们就可以根据实际需要，进行改变班级和学生的人数
		
		Scanner myScanner = new Scanner(System.in);
		//定义班级个数
		int NumberClass = 3;
		//定义每个班级人数
		int students = 5;
		//定义总平均和
		double GrandAverage = 0;
		//定义平均
		double Average = 0;
		//定义学生及格人数
		int count = 0;
		
		for(int j = 1; j <= NumberClass; j++) {
			//定义一个班级的总和
			double sum = 0;
			
			for(int i = 1; i <= students; i++) {
				System.out.println("请输入第"+j+"个班级第"+i+"个学生的成绩：");
				double score = myScanner.nextDouble();
				System.out.println("第"+i+"个学生的成绩为："+score);
				//判断学生是否及格
				if(score >= 60) {
					count++;
				}
				//sum = sum + score;
				sum += score;	
			}
			Average = sum/students;
			System.out.println("第"+j+"个班级的总成绩="+sum+" "+"第"+j+"个班级的平均成绩="+Average);
			GrandAverage += Average;
		}
		System.out.println("三个班级的总平均成绩为："+GrandAverage/NumberClass);
		System.out.println("学生总的及格人数："+count);

请输入第1个班级第1个学生的成绩：
50
第1个学生的成绩为：50.0
请输入第1个班级第2个学生的成绩：
50
第2个学生的成绩为：50.0
请输入第1个班级第3个学生的成绩：
50
第3个学生的成绩为：50.0
请输入第1个班级第4个学生的成绩：
50
第4个学生的成绩为：50.0
请输入第1个班级第5个学生的成绩：
50
第5个学生的成绩为：50.0
第1个班级的总成绩=250.0 第1个班级的平均成绩=50.0
请输入第2个班级第1个学生的成绩：
60
第1个学生的成绩为：60.0
请输入第2个班级第2个学生的成绩：
60
第2个学生的成绩为：60.0
请输入第2个班级第3个学生的成绩：
60
第3个学生的成绩为：60.0
请输入第2个班级第4个学生的成绩：
60
第4个学生的成绩为：60.0
请输入第2个班级第5个学生的成绩：
60
第5个学生的成绩为：60.0
第2个班级的总成绩=300.0 第2个班级的平均成绩=60.0
请输入第3个班级第1个学生的成绩：
40
第1个学生的成绩为：40.0
请输入第3个班级第2个学生的成绩：
40
第2个学生的成绩为：40.0
请输入第3个班级第3个学生的成绩：
40
第3个学生的成绩为：40.0
请输入第3个班级第4个学生的成绩：
40
第4个学生的成绩为：40.0
请输入第3个班级第5个学生的成绩：
40
第5个学生的成绩为：40.0
第3个班级的总成绩=200.0 第3个班级的平均成绩=40.0
三个班级的总平均成绩为：50.0
学生总的及格人数：5

break

基本语法：

break语句用于终止某个语句块的执行，一般使用在switch或者是循环当中。

for(int i = 1; i < 5; i++) {
			if(i == 3) {
				break;
			}
			System.out.println("i="+i);
		}

i=1
i=2

注意：

1.break语句出现在多层嵌套语句块当中时，我们可以使用标签指明要终止的是哪一层的语句块。

2.标签的使用：（1）break语句可以指定退出哪层。（2）label1，由程序员指定。（3）break后指定到哪个label就退出到哪里。（4）在实际开发中不建议使用标签。（5）如果没有指定break，默认退出最近的循环体。

        label1:
		for(int i = 1; i< 5; i++) {
		label2:
			for(int j = 0; j < 3; j++) {
				if( j == 2 ) {
					break;//等价于：break label2;
					//break label1;
				}
				System.out.println("j="+j);
			}
		}

j=0
j=1
j=0
j=1
j=0
j=1
j=0
j=1

        label1:
		for(int i = 1; i< 5; i++) {
		label2:
			for(int j = 0; j < 3; j++) {
				if( j == 2 ) {
					//break;//等价于：break label2;
					break label1;
				}
				System.out.println("j="+j);
			}
		}

j=0
j=1

例题：

//写一个登录功能，只有当用户名和密码都正确才可以登录成功，用户登录的次数只有三次
		
		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) && "123456".equals(passwd)) {
				System.out.println("登录成功");
				break;
			}
			//登录剩余次数：
			chance--;
			System.out.println("输入有误，您还剩余"+chance+"次登录次数");
			
		}

请输入用户名：
小明
请输入密码：
123
输入有误，您还剩余2次登录次数
请输入用户名：
小明
请输入密码：
123456
登录成功

continue

基本格式：

1.continue语句用于结束本次循环，继续执行下一次循环。

2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环。

例如：

        label1:
		for(int j = 0; j < 4; j++) {
			label2:
			for(int i = 0; i < 3; i++) {
				if(i == 1) {
					continue;//等同于 continue label2;
				}
				System.out.println("i="+i);
			}
		}

i=0
i=2
i=0
i=2
i=0
i=2
i=0
i=2

        label1:
		for(int j = 0; j < 4; j++) {
			label2:
			for(int i = 0; i < 3; i++) {
				if(i == 1) {
					//continue;//等同于 continue label2;\
					continue label1;
				}
				System.out.println("i="+i);
			}
		}

i=0
i=0
i=0
i=0

return

使用方法：

return，表示跳出所在的地方，如果return写在main方法，表示退出程序。如果写在其他的方法中，表示跳出该方法。

for(int i = 1; i <5; i++) {
			if(i == 2) {
				return;
			}
			System.out.println("i="+i);
		}

i=1

如有错误，还望指正。

cheer on seventeen

关注

22
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java——流程控制语句

顺序语句：程序从上到下逐行执行，中间没有任何判断和跳转。
复制链接

扫一扫