lesson5 - Java控制结构

已于 2024-05-17 21:49:57 修改
阅读量1k 收藏 12
点赞数 9
分类专栏： Java学习路线 文章标签： java 开发语言 sublime text
于 2024-05-15 19:28:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Codefengfeng/article/details/138916487
版权

文章目录


  Java控制结构包含顺序控制、分支控制、循环控制。

1. 顺序控制

知识点概述：
  顺序控制就是程序从上到下逐行执行，中间没有任何判断和跳转。
在这里插入图片描述

（顺序控制原理图）

代码验证：

class Test{
	public static void main(String[] args){
		int num1 = 12;
	    int num2 = num1 + 12;
	}
}

2. 分支控制

2.1 单分支

知识点概述：
  1. 单分支的基本语法为：

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

  上述语句的作用是，当条件表达式为true时执行代码块中的内容，否则就不执行。
  2. 单分支的流程图为：
在这里插入图片描述
代码验证：

import java.util.Scanner; 
class SingleBranch{
	public static void main(String[] args){
		// 程序功能，输入人的年龄，若大于18岁则输出“同志你的年龄大于18！” 
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入你的年龄：");
		int age = myScanner.nextInt();
		if(age>18){
			System.out.println("同志你的年龄大于18！");
		}
	}
}

2.2 双分支

  功能概述：
  1. 双分支的基本语法为：

if(条件表达式){
			代码块1;
}
else{
	代码块2;
}

  上述语句的作用是，当条件表达式为true时执行代码块1中的内容，否则执行代码块2中的内容。
  2. 双分支的流程图为：
在这里插入图片描述
代码验证：

import java.util.Scanner; 
class DoubleBranch{
	public static void main(String[] args){
		// 程序功能，输入人的年龄，若大于18岁则输出“同志你的年龄大于18！” 
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入你的年龄：");
		int age = myScanner.nextInt();
		if(age>18){
			System.out.println("同志你的年龄大于18！");
		}
		else{
			System.out.println("同志你的年龄小于18！");
		}
	}
}

课堂练习：

class DoubleBranch{
	public static void main(String[] args){
		// 程序功能：判断一个年份是否为闰年。闰年需满足下面两个条件中的一个
		// (1)年份能被4整除，但是不能被100整除；(2)年份能被400整除 
		int year = 100;
		if( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ){
			System.out.println(year+"是闰年");
		}
		else{
			System.out.println(year+"不是闰年");
		}
	}
}

2.3 多分支

知识点概述：
  1. 多分支结构的基本语法为：

if(条件表达式1){
			代码块1;
		}
		else if(条件表达式2){
	代码块2;
}
...
else{
	退出代码块;
}

  上述语句的具体执行过程为：先判断条件表达式1是否成立，若成立则执行代码块1并退出，若不成立则去判断条件表达式2是否成立；若条件表达式2成立，则执行代码块2并退出，若不成立则去判断条件表达式3是否成立；依次类推，一直到条件表达式n。如果条件表示式n也不成立，则执行else的代码块退出。
  2. 多分支的流程图为：
在这里插入图片描述
使用细节：
  1. 多分支的可以没有else ；如果有else , 则是前面所有条件表达式都不成立时，才会执行else语句；
  2. 多分支中，程序只要找到一个出口后，就会马上跳出分支结构，其他的判断不会再执行；
代码验证：

class MultiBranch{
	public static void main(String[] args){

		// 验证多分支结构执行完一个出口后就不再执行其他判断
		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
	}
}

课堂练习：

import java.util.Scanner; 
class MultiBranch{
	public static void main(String[] args){
	// 程序： 要求输入保国同志的芝麻信用分，判断它属于哪个等级
	// 		  信用分为100时，输出极好；
	// 		  信用分为(80,99]时，输出信用优秀；
	// 		  信用分为(60,80]时，输出信用一般；
	// 		  其他分数时，输出信用分不及格
	// 		  要求从键盘输入信用分,并且如果输入的分数不在1-100之内就报错
	Scanner myScanner = new Scanner(System.in);
	System.out.println("请输入您的信用分：");
	int creditScore = myScanner.nextInt();
	if(creditScore >= 1 && creditScore <= 100){
		if(creditScore == 100){
			System.out.println("信用分极好");
		}
		else if(creditScore > 80 && (creditScore <= 99)){
			System.out.println("信用分优秀");
		}
		else if((creditScore >= 60) && (creditScore <= 80)){
			System.out.println("信用分一般");
		}else{
			System.out.println("信用分不及格");
		}
	}else{
		System.out.println("信用分需要在1-100，请重新输入!");
	}
	
	}
}

2.4 分支嵌套

知识点概述：
  1. 分支嵌套就是在一个分支结构中又嵌套了另一个分支结构，即外分支里又包含了一层内分支。 规范：分支嵌套不要超3层， 因为嵌套层数过多后程序可读性极差；
  2. 分支嵌套的基本语法为：

if(){     //第一层
	if(){   //第二层
		if-else...  // 第三层
	}else{
	...
	}
}else{
	...
}

代码验证：

import java.util.Scanner; 
class NestedBranch{
	public static void main(String[] args){

	// 程序功能： 输入歌手的成绩和性别，判断该歌手的后续比赛走向
	// 		     1.输入歌手初赛成绩，若初赛成绩大于8.0，可以进入复赛，否则提示淘汰；
	// 		     2.输入该歌手的性别，根据性别判断进入男子组还是女子组
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入该歌手的初赛成绩：");
		double score = myScanner.nextDouble();
		if(score > 8.0){
			System.out.println("您已顺利进入复赛！");
			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("抱歉，您已被淘汰");
		}
	}
}

课堂练习：

import java.util.Scanner; 
class NestedBranch{
	public static void main(String[] args){

	// 程序功能： 设计一个出票系统，根据当前时间（淡季还是旺季）、人的年龄（成年人、儿童）打印票价
	// 		     1.旺季： 4-10月份
	//					 老人(>60岁)，20元
	//					 成人(18-60岁)，60元；
	//					 儿童(<18岁)，30元
	//		     2.淡季： 其他月份
	// 		     		 成人：40元
	// 		     		 其他：20元
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入当前月份：");
		int month = myScanner.nextInt();
		if(month >=4 && month <= 10){
			System.out.println("请输入您的年龄：");
			double age = myScanner.nextDouble();
			if(age > 60){
				System.out.println("票价为20元");
			}
			else if(age >=18 && age <= 60){
				System.out.println("票价为60元");
			}else{
				System.out.println("票价为30元");
			}
		}else{
			System.out.println("请输入您的年龄：");
			double age = myScanner.nextDouble();
			if(age >=18 && age <= 60){
				System.out.println("票价为40元");
			}else{
				System.out.println("票价为20元");	
			}
		}
	}
}

2.5 switch分支

知识点概述：
  1. switch语句的基本语法为：

switch(表达式){
   		case 常量1:
		语句块1;
		break;
		case 常量1:
		语句块2;
		break;
		...
		case 常量n:
		语句块n;
		break;
		default:
		default语句块;   
		break;
}

  上述语句的含义为：程序首先计算switch关键字后的表达式，如果表达式的值等于常量1，就执行语句块1，然后执行break;语句退出switch；否则继续执行后面的语句，依次类推；如果所有常量值都没有匹配上，则执行default语句块然后退出switch。
  2. switch语句的流程图为：
在这里插入图片描述
上面的流程图中，要注意的是，如果，某个语句块后面没有写break语句，执行完这个语句块后就会直接执行下一个语句块，这个称为 穿透原理。

使用细节：
  1. 表达式的数据类型要么和case后的常量类型一致，要么可以自动转换成可相互比较的类型；
  2. 表达式的返回值必须是byte, short, int, char, enum, String中的一种
  3. case后跟的必须是常量，不能是变量
  4. default语句可有可无，没有时程序也不会报错；
  5. break语句用来执行完一个case分支后跳出switch语句块，如果一句break语句都没有，则程序会顺序执行到switch结尾。（具体可参考上面的switch流程图）
代码验证：

class SwitchBranch{
	public static void main(String[] args){

	    // 测试1. 表达式的值与case后常量类型一致
		char c = 'a';
		switch(c){
			case 'a':          // 表达式与常量的数据类型完全相同
				System.out.println("ok1");
				break;
			case 20:           // 表达式与常量的数据类型虽然不同，但是char可以自动转int，所以编译时也不会出错
				System.out.println("ok2");
				break;
			case "hello":      // char无法与string做比较，因此会报错
				System.out.println("ok3");
				break;
			default:
				break;
		}

		// 测试2. 表达式的返回值必须是byte,short,int,char,enum,String中的一种
		double c = 1.21;
		switch(c){                        //表达式c的值为double，会报错
			case 1.21:          
				System.out.println("ok1");
				break;
			default:
				break;
		}

		String d = "1.21";
		switch(d){                        //表达式c的值为String，编译通过
			case "1.21":          
				System.out.println("ok1");
				break;
			default:
				break;
		}	

		// 测试3. case后必须紧跟常量，而不能用变量
		char c = 'a';
		char c2 = 'c'
		switch(c){
			case 'a':          
				System.out.println("ok1");
				break;
			case c2:          // 此处会报错，因为c2是个变量   
				System.out.println("ok2");
				break;				
			default:
				break;

		}

		// 测试4. default语句可有可无，没有时程序也不会报错
		char c = 'a';
		switch(c){
			case 'a':          // 表达式与常量的数据类型完全相同
				System.out.println("ok1");
				break;
			case 20:           // 表达式与常量的数据类型虽然不同，但是char可以自动转int，所以编译时也不会出错
				System.out.println("ok2");
				break;
			case "hello":      // char无法与string做比较，因此会报错
				System.out.println("ok3");
				break;
		}

		// 测试5. break语句用来执行完一个case分支后跳出switch语句块，如果一句break语句都没有，则程序会顺序执行到switch结尾。
	    char c = 'a';
		switch(c){
			case 'a':          
				System.out.println("ok1");
			case 'b':           
				System.out.println("ok2");	
			case 'c':           
				System.out.println("ok3");			
			default:
				System.out.println("ok4");	  // 程序输出ok1 ok2 ok3 ok4
		}
	
	}
}

课堂练习：

class SwitchBranch{
	public static void main(String[] args){
 
	// 程序1要求： 程序可以接受一个字符，显示出这个字符对应的日期
	// 		     a对应周一，b对应周二，c对应周三，d对应周四，e对应周五，f对应周六，g对应周天
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入字符：");
		char char1 = myScanner.next().charAt(0);
		switch(char1){
			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("输入格式不正确！");
				break;				
		}
		System.out.println("switch语句已执行结束！");

	// 程序2要求： 对学生成绩大于60分的，输出合格；对学生成绩低于60分的，输出不合格
		double score = 1;
		int encoding = (int) (score/60)	;    // 亮点：对问题进行了编码
		if(score<=100){
			switch(encoding){
				case 0:
					System.out.println("成绩不合格");
					break;
				case 1:
					System.out.println("成绩合格");
					break;
			}
		}else{
			System.out.println("输入格式不正确！");
		}  

	// 程序3要求： 输入月份，打印该月份所属的季节；
	//            3 4 5为春季； 6 7 8为夏季； 9 10 11为秋季； 12 1 2为冬季

		Scanner myScanner = new Scanner(System.in);
		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 12:
			case 1:
			case 2:
				System.out.println("这是冬季");
				break;
			default:
				System.out.println("输入格式有误！");      //使用了穿透原理，把相同的情况写到一起
		}


	}
}

2.6 if-else与switch的比较

知识点概述：
  1. 对值进行判断，且表达式的值为byte, short, int, char, enum, String中的一种，用switch更好；
  2. 对区间进行判断，结果为boolean型，用if-else更好

3. 循环控制

3.1 for循环

功能解释：
  1. for循环的基本语法为：

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

  循环变量初始化、循环条件、循环变量迭代、循环语句是for循环的四要素。
  2. for循环的流程图为：
在这里插入图片描述
使用细节：
  1. 循环条件返回的是一个布尔值
  2. for循环语句中，循环变量初始化和循环变量迭代可以写到其他地方，但注意分号;不能省略；
  3. 循环变量初始化、循环变量迭代都可以有多条语句，不同语句间用逗号隔开。使用多条语句时，要求各循环变量的类型一样；
  4. for循环是先判断再执行语句。
代码验证：

class ForLoop{
	public static void main(String[] args){

	// 1. for循环语法演示
		for(int i = 1 ; i <= 10 ; i++)
		{
			System.out.println("你好"+i);
		}

	// 2. 循环变量初始化和循环变量迭代放到其他位置
		int i = 1 ;                        // 效果与上面的for循环相同       
		for( ; i <= 10 ; )
		{
			System.out.println("你好"+i);
			i++ ;
		}
  	// 3. 循环变量初始化、循环变量迭代都可以有多条语句
		int count = 3;
		for(int i = 0, j = 0 ; i < count ; i++ , j += 2){
			System.out.println( "i=" + i + "j=" + j);
		}

	}
}

课堂练习：

class ForLoop{
	public static void main(String[] args){
	// 练习1： 打印1-100之间所有9的倍数，统计个数及其总和
		int count = 0;
		int sum = 0;
		for(int i = 1 ; i <= 100 ; i++)
		{
			if(i % 9 == 0)
			{
				count++;
				sum = sum + i;
				System.out.println(i);
			}

		}
		System.out.println("9的倍数数量为: " + count + "总和为：" + sum);
	// 练习2： 打印以下输出
	//         0 + 5 = 5
    //         1 + 4 = 5
	//         2 + 3 = 5
	//         3 + 2 = 5
	//         4 + 1 = 5
	//         5 + 0 = 5
	for(int i = 0 ; i <= 5 ; i++)
	{
		System.out.println(i + "+" + (5-i) + "=" + "5");
	}	

	}
}

3.2 while循环

知识点概述：
  1. while循环的基本语法为：

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

  while循环的四要素也是循环变量初始化、循环条件、循环变量迭代、循环语句，只不过跟for循环放的位置不同。
  2. while循环的流程图为：
在这里插入图片描述
使用细节：
  1. 循环条件是一个返回布尔值的表达式；
  2. while循环是先判断再执行语句
代码验证：

class WhileLoop{
	public static void main(String[] args){

		int i = 1;
		while( i <= 10){
			System.out.println("你好"+i);
			i++ ;			
		}
	}
}

课堂练习：

class WhileLoop{
	public static void main(String[] args){
	// 1. 打印40-200之间所有的偶数
		int i = 40;
		while( i <= 200){
			if(i % 2 == 0) System.out.println(i);
			i++;
						
		}
	}
}

3.3 do-while循环

知识点概述：
  1. do-while循环的基本语法为：

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

  2. do-while的流程图为：
在这里插入图片描述
使用说明：
  1. do-while循环条件是一个返回布尔值的表达式；
  2. do-while是先执行再判断，也就是说程序无论如何一定会执行一次；
  3. 程序的最后，在while后面有个分号;不能掉。
代码验证：

class do_WhileLoop{
	public static void main(String[] args){

		int i = 1;
		do{
			c
			i++;
		}
		while( i <= 10);
	}
}

课堂练习：

class do_WhileLoop{
	public static void main(String[] args){
	//  程序要求： 计算1-100的和
		int i = 1;
		int sum = 0;
		do{
			sum = sum + i ;
			i++;
		}
		while( i <= 100);
		System.out.println(sum);
	}
}

3.4 多重循环

知识点概述：
  1. 将一个循环放进另一个循环内，形成循环的嵌套。for循环、while循环、do-while循环均可以作为内层循环和外层循环。建议循环的嵌套不要超过3层，否则代码可读性很差；
  2. 内层循环执行完所有案例时，才会结束外层的当次循环；
  3. 若外层循环的次数为m次，外层循环的次数为n次，则整个循环体一共会执行m*n次。
代码验证：

class MultiLoop{
	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);
			}
		}
	}
}

课堂练习：

class MultiLoop{
	public static void main(String[] args){
	// 程序1要求： 从键盘输入3个班级的成绩，每个班有5个人；
	//			  统计每个班的平均分，以及3个班合起来的平均分

		Scanner myScanner = new Scanner(System.in);
		double sum = 0;       // 总分
		int num_pass = 0 ;    // 及格人数
		for(int i = 1 ; i <= 3 ; i++){         // 第一层是班级
			System.out.println("这是" + i + "班正在统计成绩： " );
			double sum_temp = 0;
			for(int j = 1 ; j <= 5 ; j++){     // 第二层是班级里的每个人
				System.out.println("请输入该学生的成绩： ");
				double score = myScanner.nextDouble();
				sum_temp = sum_temp + score;
				sum = sum + score ;
				if(score >= 60) num_pass++;
			}
			double average_temp = sum_temp/5;
			System.out.println(i + "班的平均成绩为：" + average_temp);

		}
		double average = sum / 15 ;
		System.out.println("总平均成绩为：" + average);
		System.out.println("及格人数为：" + num_pass);


	// 程序2要求： 初级：  输出一个用*组成的实心金字塔
	//			  进阶1： 输出一个用*组成的空心金字塔
	//            进阶2： 输出一个用*组成的空心菱形
	//            *            *                  *
	//	         ***          * *                * *
	//	        *****        *   *              *   *
	//	       *******      *     *            *     *
	//                                          *   *
	//                                           * *
	//                                            *
	//  初级版： 实心金字塔
	//  在输出每层金字塔时，关键点有两个：	一是开始输出*的位置num1，二是输出*的数量num2, 三是每层一共要输出的字符数量num3
	//  设总层数N, 当前层数n ， 分析可知num1 = N+1-n , num2 = 1+2*(n-1) , num3 = 1+2*(N-1)
		Scanner myScanner = new Scanner(System.in);
		System.out.println("您想输出一个几层的实心金字塔？");
		int N = myScanner.nextInt();
		for(int n = 1 ; n <= N ; n++){   // 控制层数
			int num1 = N+1-n;
			int num2 = 1+2*(n-1);
			int num3 = 1+2*(N-1);
			for(int i = 1 ; i <= num3 ; i++){   // 控制当前层的输出
				if(i >= num1 && i <= num1 + num2 - 1 )
				{
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
			}
			System.out.println("\n");
		}

	//  进阶1： 空心金字塔
	//  空心金字塔的关键点跟实心金字塔相同，只不过是把中间挖空了，只留开始和终止位置输出*
		Scanner myScanner = new Scanner(System.in);
		System.out.println("您想输出一个几层的空心金字塔？");
		int N = myScanner.nextInt();
		for(int n = 1 ; n <= N ; n++){   // 控制层数
			int num1 = N+1-n;
			int num2 = 1+2*(n-1);
			int num3 = 1+2*(N-1);
			for(int i = 1 ; i <= num3 ; i++){   // 控制当前层的输出
				if(i == num1 || i == num1 + num2 - 1 )
				{
					System.out.print("*");
				}else{
					System.out.print(" "); 
				}
			}
			System.out.println("\n");

		}

	//  进阶2： 菱形
	//  表面上看，菱形似乎只是两个空心金字塔的简单叠加，但其实事情并没有如此简单，因为在菱形的后半段，
	//	相当于是在输出一个倒立的空心金字塔，编码规则已经发生改变。因此需要先思考如何输出倒立的空心金字塔
	//  2-1: 倒立的空心金字塔编码
	//	     假设要输出的倒立金字塔总层数为N_s，当前层数为n_s ， 
	//	     则在每一层时，开始输出*的位置num1_s = n_s ， 输出的*数量为num2_s = 1 + 2 *(N_s - n_s) 
	//	     然后要考虑将这里的 N_s、 n_s 跟菱形中的N、 s对应起来, 对应关系为
	//	     N_s = N/2 + 1; n_s = n - N/2;
	//  2-2: 前半段是正立的空心金字塔，编码规则与前面很相似, 但也需要重新编码
	//		 假设要输出的正立金字塔总层数为N_t，当前层数为n_t ，
	//		 N_t = N/2+1; n_t = n ;
	//       num1 = N_t+1-n_t , num2 = 1+2*(n_t-1) , num3 = 1+2*(N_t-1)
		Scanner myScanner = new Scanner(System.in);
		System.out.println("您想输出一个几层的空心菱形？");
		int N = myScanner.nextInt();
		for(int n = 1 ; n <= N ; n++){   // 控制层数

			if(n <= (N/2+1) ){           // 前半段正立金字塔
				int num1 = (N/2+1)+1-n;
				int num2 = 1+2*(n-1);
				int num3 = 1+2*((N/2+1)-1);
				for(int i = 1 ; i <= num3 ; i++){   // 控制当前层的输出
					if(i == num1 || i == num1 + num2 - 1 )
					{
						System.out.print("*");
					}else{
						System.out.print(" "); 
					}
				}
				System.out.println("\n");
			}else{                        // 后半段倒立金字塔
				int num1_s = n - N/2;;
				int num2_s = 1 + 2 *(N/2 + 1 - (n - N/2)) ;
				int num3 = 1+2*(N-1);
				for(int i = 1 ; i <= num3 ; i++){   // 控制当前层的输出
					if(i == num1_s || i == num1_s + num2_s - 1 )
					{
						System.out.print("*");
					}else{
						System.out.print(" "); 
					}
				}
				System.out.println("\n");
			}
		}


	}
}

在这里插入图片描述

（金字塔问题输出展示）

3.5 break\continue\return

知识点概述：
  1. break语句用于跳出某个循环/语句块，常放在switch或循环中。语法格式为：

 							break;

  2. continue语句用于结束本次循环，然后继续执行下一次循环。语法格式为：

 						  continue;

  3. return语句用于跳出所在方法，这里会结合后面讲方法时具体说明。return如果放在main方法中，会退出程序。

使用细节：
  1. break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块；如果没有指定break，默认退出最近的循环体；在实际开发中尽量不要使用标签。下面的break label2就用于退出第2层循环

label1:{  ...
label2:     {  ...
label3:          {  ...
					 break label2;
                   ...
                }
           }
}

  2. continue语句也可以像break语句一样，配合标签使用，指明要终止的是哪一层循环。

label1:{  ...
label2:     {  ...
label3:          {  ...
					 continue label2;
                   ...
                }
           }
}

代码验证：

class breakTest{
	public static void main(String[] args){


	// 1. break语句基本功能-->结束整层循环
		for(int i = 1 ; i <= 10 ; i++){
			if(i== 5){
				break;
			}
			System.out.println(i);    // 输出 1 2 3 4 
		}

    // 2. break配合标签使用
	// 2-1. break语句未指定标签时，相当于退出就近的一层循环
label1:	for(int i = 0 ; i < 4 ; i++){
label2:		for(int j = 0 ; j < 5 ; j++){
				if(j == 2)
				{
					break;       // 这里相当于break label2;   
				}
				System.out.println(j);
			}
		}                        // 程序最终输出4个0 1
		
	// 2-2. break指定标签时，就会退出相应的循环
label1:	for(int i = 0 ; i < 4 ; i++){
label2:			for(int j = 0 ; j < 5 ; j++){
				if(j == 2)
				{
					break label1;          
				}
				System.out.println(j);
			}
		}                        // 程序只会输出1个0 1
	}
}

class continueTest{
	public static void main(String[] args){

		// 1.continue基本功能--> 结束本次循环
		for(int i = 1 ; i <= 10 ; i++){
			if(i== 5){
				continue;
			}
			System.out.println(i);    // 输出 1 2 3 4 6 7 8 9 10
		}


		// 2. continue配合标签使用
		// 2-1. continue语句未指定标签时，相当于退出就近的一层循环
label1:	for(int i = 0 ; i < 4 ; i++){
label2:		for(int j = 0 ; j < 5 ; j++){
				if(j == 2)
				{
					continue;       // 这里相当于continue label2;   
				}
				System.out.println(j);
			}
		}                          // 程序最终输出4个0 1 3 4

		// 2-2. continue指定标签时，就会退出相应的循环
label1:	for(int i = 0 ; i < 4 ; i++){
label2:		for(int j = 0 ; j < 5 ; j++){
				if(j == 2)
				{
					continue label1;       // 这里相当于continue label2;   
				}
				System.out.println(j);
			}
		}                          // 程序最终输出4个0 1 

	
	}

}

class break_continue_return_Compare{
	public static void main(String[] args){

		// 下面这段代码用于比较break , continue 和retrun的区别
		//  使用break时，   会输出 0 1 程序结束！
		//  使用continue时，会输出 0 1 3 4 5 程序结束
		//  使用return时，  会输出 0 1    (return放在main方法中，所以会让main方法结束) 
		//              
		for(int i = 0 ; i <= 5 ; i++){
			if(i == 2){
				break;    // continue , return
			}
			System.out.println(i);
		}
		System.out.println("程序结束！");


	}

}

课堂练习：

class breakTest{
	public static void main(String[] args){

	// 程序要求： 用户登录测试。一共有3次输入机会，如果输入的用户名为“丁真”、密码为“666”则提示登录成功；否则提示还有几次机会
		Scanner myScanner = new Scanner(System.in);
		for(int i = 1 ; i <= 3 ; i++ ){
			System.out.println("请输入用户名：");
			String admin = myScanner.next();
			System.out.println("请输入密码：");
			String password = myScanner.next();	
			boolean b1 = admin.equals("丁真");
			boolean b2 = password.equals("666");
			if(b1 && b2){
				System.out.println("登录成功！");
				break;
			}else{
				System.out.println("还有"+(3-i)+"次登录机会");
			}		
		} 

	}
}

本章小测

class chapterTest1{
	public static void main(String[] args){

	// 程序1要求： 某人有现金100000元，每经过一次路口都需要缴费，缴费规则如下：
	//	          当现金>50000时，每次交%5
	//	          当现金<=5000时，每次交1000
	//	          问可以经过多少次路口?   (要求用while-break)
		double money = 100000;
		int count = 0;
		while(money >= 0){
			if(money > 50000){
				money = money * (1 - 0.05);
			}else{
				if(money - 1000 < 0){
					break;
				}
				money = money - 1000;
			}
			count = count + 1;
		}
		System.out.println("一共可以过路口" + count + "次");
		System.out.println("最后还剩" + money + "元");

	}
}

class chapterTest2{
	public static void main(String[] args){

	// 程序2要求： 测试一个整数是否为水仙花数
	//	          水仙花数是指一个3位数的各个位数立方和等于其本身，例如 153 = 1^3 + 5^3 + 3^3 
	//	          当现金<=5000时，每次交1000
	//	          问可以经过多少次路口?   (要求用while-break)
		int num = 153;
		int hd = num / 100; 
		int td = (num - (100*hd))/10;
		int sd = num - 100 * hd - 10 * td ;
		if(num == hd*hd*hd+td*td*td+sd*sd*sd ){
			System.out.println("这个数是水仙花数");
		}else{
			System.out.println("这个数不是水仙花数");
		}
		
	}
}
Codefengfeng
关注
  • 9
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
网易云课堂微专业--Java高级开发工程师
xiao99985的博客
06-24 606
获取
lesson03-01 Java类基础知识--Java类结构.ppt
09-22
Java类基础知识--Java类结构
Lesson3-Java语言基础
rushberry的博客
03-22 78
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考以上就是对Java语言基础部分的第一部分。后续是流程控制、字符串、数组、类和对象、包装类、数字处理类…的学习。
Java Lesson 3 控制结构
tonyl7的博客
03-19 176
【代码】Java Lesson 3 控制结构。
lesson4-Linux进程控制
LYC_462857656的博客
09-23 403
持续更新
南邮-Java期末考试复习要点
小白的Soda的博客
09-09 1052
文章目录第二章2-3 short 和 char 的取值范围有何不同2-8 分析基本数据类型与引用数据类型的主要特点，说明这两种变量的差别2-16怎样将数值类型的数据转换成字符串？采用下列语句是否可行2-18怎样比较两个字符？怎样比较两个字符串？有几种比较字符串的方法？思考题第三章第一题：阅读下述代码第二题：理解抽象类设计和多态第三题：类设计（有一定难度，请仔细思考）1、用户要求设计一个算术运算类 BasicIntOpera，支持 int 类型数据的加法和减法操作，并返回 int 类型的计算结果。2、用户要求
狂神说-Java网络编程
shenxinde的博客
03-14 430
1、概述 计算机网络： 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程的目的： 无线电台。传播交流信息。数据交换。通信 想要达到这个效果需要什么： 1.如何准确地定位网络上的一台主机 192.168.16.124：端口，定位到这个计算机上的某个资源 2.找到了这个主机，如何传输数据呢？ Javaweb：网页编程 B/S 网络编程：TCP/IP C/S
第三周-Java基础
qq_44458489的博客
03-08 391
类和对象
java 流程控制--狂神说
qq_43203246的博客
11-10 174
流程控制 Scanner 位于java.util.Scanner库 来获取用户输入 Scanner scanner = new Scanner(System.in); 借助Scanner的next() 和nextline()获取输入的字符串 一般需要使用hasNext()和hasNextline()判断是否有输入 package scanner; import java.util.Scanner; public class Demo01 { public static void main(S
Lesson01_Java开发环境
weixin_44120423的博客
06-03 470
Java开发环境 计算机基础 计算机应用领域 科学计算：科学计算也称数值计算。计算机最开始是为解决科学研究和工程设计中遇到的大量数学问题的数值计算而研制的计算工具。 数据处理：在科学研究和工程技术中，会得到大量的原始数据，其中包括大量图片、文字、声音等信息处理就是对数据进行收集、分类、排序、存储、计算、传输、制表等操作。 自动控制：自动控制是指通过计算机对某一过程进行自动操作，它不需人工干预，能按人预定的目标和预定的状态进行过程控制。 计算机辅助设计：计算机辅助设计(Computer Aided Desi
Lesson5--二叉树1
08-03
1.树概念及结构 2.二叉树概念及结构 3.二叉树顺序结构及实现 4.二叉树链式结构及实现 1.树概念及结构 2.二叉树概念及结构 1. 每个结点最多有两棵子树
比特数据结构课件-Lesson5-二叉树.pdf
07-07
比特数据结构课件
lesson03-02 Java类基础知识--基本类型.ppt
09-23
Java类基础知识--基本类型
Lesson 5－教学教案.docx
12-23
Lesson 5－教学教案.docx
简单的项目部署脚本（转载）
u010230019的博客
06-09 648
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1433
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 461
修改菜品——后端Java
Spring Boot集成antlr实现词法和语法分析
最新发布
HBLOG
06-13 799
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
无法保存 E:\javaworkspace\lesson3\src\com\foreknow\lesson1\java1.java。 无法打开文件进行写入。
08-08
您遇到的问题是无法保存文件和无法打开文件进行写入的问题。这可能是由于文件路径错误或权限问题导致的。...这些引用内容涉及Java编程和MyBatis框架的相关代码。如果您有与这些引用内容相关的问题，我可以帮助您解答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值