代码编织梦想

4.程序控制结构

🤖

4.1 程序流程控制介绍

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

  1. 顺序控制

  2. 分支控制

  3. 循环控制

4.2 顺序控制

image-20210908215424504

4.2 分支控制

让程序有选择的的执行,分支控制有三种

  1. 单分支 if

  2. 双分支 if-else

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

1️⃣:单分支

image-20210908220151493

image-20210908220324300

4.3 双分支

image-20210908222108910

//if-else的快速入门
import java.util.Scanner;//导入
public class If02 { 

	//编写一个main方法
	public static void main(String[] args) {
		//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
		//则输出 "你年龄大于18,要对
		//自己的行为负责, 送入监狱"。否则 ,输出"你的年龄不大这次放过你了."
		//
		//思路分析
		//1. 接收输入的年龄, 应该定义一个Scanner 对象
		//2. 把年龄保存到一个变量 int age
		//3. 使用 if-else 判断,输出对应信息
		
		//应该定义一个Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		//把年龄保存到一个变量 int age
		int age = myScanner.nextInt();
		//使用 if-else 判断,输出对应信息
		if(age > 18) {
			System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
		} else {//双分支
			System.out.println("你的年龄不大这次放过你了");
		}

		System.out.println("程序继续...");

	}
}
image-20210908222350177

4.4 单分支和双分支练习题

image-20210908223739194
  1. 编写程序,声明 2 个 double 型变量并赋值。判断第一个数大于 10.0,且第 2 个数小于 20.0,打印两数之和。

  2. 【课后自己练】定义两个变量 int,判断二者的和,是否能被 3 又能被 5 整除,打印提示信息

  3. 判断一个年份是否是闰年,闰年的条件是符合下面二者之一:(1)年份能被 4 整除,但不能被 100 整除;(2)能被 400

整除

//单分支和双分支的练习
//
public class IfExercise01 { 

	//编写一个main方法
	public static void main(String[] args) {

		//编写程序,声明2个double型变量并赋值。
		//判断第一个数大于10.0,且第2个数小于20.0,打印两数之和
		
		//思路分析
		
		double d1 = 33.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("和可以被3又能被5整除");
		} else {
			System.out.println("和不能被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 = 2028;
		if( (year % 4 == 0 && year % 100 != 0) ||  year % 400 == 0 ) {
			System.out.println(year + " 是 闰年");
		} else {
			System.out.println(year + " 不是 闰年");
		}
	}
}

4.5 多分支

image-20210909165555362

🌏:流程图

image-20210909165632518

//课堂练习
import java.util.Scanner;
public class If03 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		输入保国同志的芝麻信用分:
		如果:
		信用分为100分时,输出 信用极好;
		信用分为(80,99]时,输出 信用优秀;
		信用分为[60,80]时,输出 信用一般;
		其它情况 ,输出 信用 不及格 
		请从键盘输入保国的芝麻信用分,并加以判断
		假定信用分数为int
		 */
		
		Scanner myScanner = new Scanner(System.in);
		//接收用户输入
		System.out.println("请输入信用分(1-100):");
		//请思考:如果小伙伴输入的不是整数,而是hello..
		//==>这里我们后面可以使用异常处理机制搞定-》老师点一下
		int grade = myScanner.nextInt();

		//先对输入的信用分,进行一个范围的有效判断 1-100, 否则提示输入错误

		if(grade >=1 && grade <= 100) {
			//因为有4种情况,所以使用多分支
			if(grade == 100) {
				System.out.println("信用极好");
			} else if (grade > 80 && grade <= 99) { //信用分为(80,99]时,输出 信用优秀;
				System.out.println("信用优秀");
			} else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时,输出 信用一般
				System.out.println("信用一般");
			} else {//其它情况 ,输出 信用 不及格 
				System.out.println("信用不及格");
			}

		} else {
			System.out.println("信用分需要在1-100,请重新输入:)");
		}

	}
}
image-20210909202319182

🅾️:输出b

image-20210909202420990

🅾️:第一句b = false 把b的值改为了false

所以!b是真,输出c

4.6 嵌套循环

在一个分支结构中又完整的嵌套了另一个完整的分支结构,里面的分支的结构称为内层分支外面的分支结构称为外

层分支。老师建议: 不要超过 3 层 (可读性不好)

image-20210909210753132

image-20210909223117166

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)

		 */
		//思路分析
		//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 == '男') //char类型用单引号,string字符串才用双引号
			System.out.println("进入男生组");
			else if(gender == '女')
			System.out.println("进入女生组");
			else
				System.out.println("您输入的性别有误,请检查后重新输入");
		}
		else
			System.out.println("您已被淘汰!");
	}
}

image-20210909230709657

import java.util.Scanner;
public class Nestedif02
{
	public static void main(String[] args)
	{
		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>=0&&age<18)
				System.out.println("儿童票——30元");
			else if(age>=18 && age <= 60 )
				System.out.println("成人票——60元");
			else if(age> 60)
				System.out.println("老人票——20元");
			else
				System.out.println("您输入的年龄有误");

		}
		else if((month<=3&&month>=1)||(month>=11&&month<=12))
		{
			System.out.println("请输入年龄");
			int age = myScanner.nextInt();
			if(age>=18 && age <= 60 )
			System.out.println("成人票——40元");
			else
			System.out.println("20元");
		}
		else 
			System.out.println("您输入的月份有误");
	}

}

4.7 switch 分支结构

image-20210909233238711

ps:default 语句有没有break都一样。

🚀🚀🚀:流程图

image-20210909233831020

image-20210909234349922

import java.util.Scanner;
public class Switch01 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		案例:Switch01.java
		请编写一个程序,该程序可以接收一个字符,比如:a,b,c,d,e,f,g  
		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;
			//.....
			default:
				System.out.println("你输入的字符不正确,没有匹配的");

		}

		System.out.println("退出了switch ,继续执行程序");
	}
}

switch细节

image-20210910100419455

Switch练习

1️⃣ 使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 “other”。

2️⃣ 对学生成绩大于 60 分的,输出"合格"。低于 60 分的,输出"不合格"。(注:输入的成绩不能大于 100), 提示

成绩/60

3️⃣ 根据用于指定月份,打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季 (ps:使用case穿透)

import java.util.Scanner;
public class SwitchExercise { 

	//编写一个main方法
	public static void main(String[] args) {

		//使用 switch 把小写类型的 
		//char型转为大写(键盘输入)。只转换 a->A, b->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("你的输入有误~");

		// }

		//对学生成绩大于60分的,输出"合格"。低于60分的,
		//输出"不合格"。(注:输入的成绩不能大于100), 提示 成绩/60
		//思路分析
		//1. 这道题,可以使用 分支来完成, 但是要求使用switch
		//2. 这里我们需要进行一个转换, 编程思路 : 
		//   如果成绩在 [60,100] , (int)(成绩/60) = 1 
		//   如果成绩在 [0,60) , (int)(成绩/60) = 0 
		
		//代码实现
		
		double score = 1.1;

		//使用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,4,5 春季 6,7,8 夏季  9,10,11 秋季 12, 1, 2 冬季 
		//[课堂练习, 提示 使用穿透 ] 
		//
		//思路分析
		//1. 创建Scanner对象, 接收用户输入
		//2. 使用 int month 接收
		//3. 使用switch 来匹配 ,使用穿透来完成,比较简洁
		
		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 1:
			case 2:
			case 12: 
				System.out.println("这是冬季");
				break;
			default :
				System.out.println("你输入的月份不对(1-12)");
		}


	}
}

4.8 switch和if的比较

🅾️ 如果判断的具体数值不多,而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可

以使用,建议使用 swtich 语句

🅾️ 其他情况:对区间判断,对结果为 boolean 类型判断,使用 if,if 的使用范围更广

4.9 for循环控制

基本介绍:听其名而知其意,就是让你的代码可以循环的执行

基本语法👇

image-20210910111052594

说明

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

  2. for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代

  3. 循环操作 , 这里可以有多条语句,也就是我们要循环执行的代码

  4. 如果 循环操作(语句) 只有一条语句,可以省略 {}, 建议不要省略

流程图

image-20210910111948833

🙆‍♂:for循环细节

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

  2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方,但是两边的分号不能省略。

  3. 循环初始值可以有多条初始化语句,但要求类型一样,并且中间用逗号隔开,循环变量迭代也可以有多条变量迭代

    语句,中间用逗号隔开

❓使用内存分析法,分析输出下面代码输出什么?

image-20210910160754875

4.10 for 编程思想

1️⃣:化繁为简:将复杂的需求拆解成简单的需求,逐步完成。

2️⃣: 先死后活:先考虑固定的值,然后转成可以灵活变换的值。

练习:

  1. 打印 1~100 之间所有是 9 的倍数的整数,统计个数 及 总和.[化繁为简,先死后活]

public class ForExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		//打印1~100之间所有是9的倍数的整数,统计个数  及 总和.[化繁为简,先死后活]
		//老韩的两个编程思想(技巧)
		//1. 化繁为简 : 即将复杂的需求,拆解成简单的需求,逐步完成
		//2. 先死后活 : 先考虑固定的值,然后转成可以灵活变化的值
		//
		//思路分析
		//打印1~100之间所有是9的倍数的整数,统计个数  及 总和
		//化繁为简
		//(1) 完成 输出 1-100的值
		//(2) 在输出的过程中,进行过滤,只输出9的倍数  i % 9 ==0
		//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
		//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
		//先死后活
		//(1) 为了适应更好的需求,把范围的开始的值和结束的值,做出变量
		//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;

		int count = 0; //统计9的倍数个数 变量
		int sum = 0; //总和
		int start = 10;
		int end = 200;
		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);
	}
}

image-20210910162837565

public class ForExercise02 { 
	//编写一个main方法
	public static void main(String[] args) {

		//化繁为简
		//先死后活 
		int n = 9;
		for( int i = 0; i <= n; i++) {
			System.out.println(i + "+" + (n-i) + "=" + n);
		}
	}
}

4.11 while 循环控制

基本语法 :image-20210910163117959

流程图:image-20210910163321891

注意事项和细节说明

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

  2. while 循环是先判断再执行语句

image-20210910202733564

public class WhileExercise { 

	//编写一个main方法
	public static void main(String[] args) {

		// 打印1―100之间所有能被3整除的数 [使用while, 老师评讲 ]
		// 化繁为简, 先死后活
		
		int i = 1;
		int endNum = 100;
		while( i <= endNum) {
			if( i % 3 == 0) {
				System.out.println("i=" + i);
			}

			i++;//变量自增
		}

		// 打印40―200之间所有的偶数 [使用while, 课后练习]
		// 化繁为简, 先死后活(利于思考)
		//
		System.out.println("========");
		int j = 40; //变量初始化
		while ( j <= 200) {
			//判断
			if( j % 2 == 0) {
				System.out.println("j=" + j);
			}
			j++;//循环变量的迭代
		}

	}
}

4.12 do…while 循环

image-20210910204951496

🅾️ 流程图image-20210910205130696

👇:细节说明

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

  2. do…while 循环是先执行,再判断, 因此它至少执行一次,而while循环是先判断,再执行

image-20210910211144625

public class DoWhileExercise01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//统计1---200之间能被5整除但不能被3整除的 个数
		//化繁为简
		//(1) 使用do-while输出 1-200
		//(2) 过滤 能被5整除但不能被3整除的数 %
		//(3) 统计满足条件的个数 int count = 0; 
		//先死后活
		//(1) 范围的值 1-200 你可以做出变量
		//(2) 能被5整除但不能被3整除的 , 5 和 3 可以改成变量 
		int i = 1;
		int count = 0; //统计满足条件的个数
		do {
			if( i % 5 == 0 && i % 3 != 0 ) {
				System.out.println("i=" + i);
				count++;
			}
			i++;
		}while(i <= 200);

		System.out.println("count=" + count);
	}
}
import java.util.Scanner;
public class DoWhileExercise02 { 

	//编写一个main方法
	public static void main(String[] args) {
		//如果李三不还钱,则老韩将一直使出五连鞭,直到李三说还钱为
		//[System.out.println("老韩问:还钱吗?y/n")]   do...while ..
		//
		//化繁为简
		//(1) 不停的问还钱吗?
		//(2) 使用char answer 接收回答, 定义一个Scanner对象
		//(3) 在do-while 的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);
		}while(answer != 'y');//判断条件很关键

		System.out.println("李三还钱了");
	}
}

4.13 多重循环控制

image-20210911095118812

应用实例:

  1. 统计 3 个班成绩情况,每个班有 5 名同学,求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。

  2. 统计三个班及格人数,每个班有 5 名同学。

import java.util.Scanner;
public class MulForExercise01 { 
	public static void main(String[] args) {
		//思路分析:
		//化繁为简
		//(1) 先计算一个班 , 5个学生的成绩和平均分 , 使用for
		//1.1 创建 Scanner 对象然后,接收用户输入
		//1.2 得到该班级的平均分 , 定义一个 doubel 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;//累积 及格人数
		int classNum = 3; //班级个数
		int stuNum = 5;//学生个数
		for( int i = 1; i <= classNum; i++) //i 表示班级
        {
			double sum = 0; //一个班级的总分
			for( int j = 1; j <= stuNum; j++) {//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 / stuNum));
			//把 sum 累积到 totalScore
			totalScore += sum;

		}
		System.out.println("三个班总分="+ totalScore 
			+ " 平均分=" + totalScore / (classNum*stuNum));
		System.out.println("及格人数=" + passNum);
	}
}

经典的打印金字塔

image-20210911103212562

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 = 20; //层数
		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("");
		}
	}
}

打印空心菱形

public class diamond
{
	/*
		*      //1   2*层数 - 1
	   ***     //3
	  *****    //5
	 *******   //7 
	*********  //9 
	 *******   //7		
	  *****		//5
	   ***		//3
		*		//1

	 
	    *      
	   * *     
	  *   *  
	 *     *    
	*       *   
	 *     *
	  *   *
	   * *
		*
	*/

	public static void main(String[] args)
	{
		int i=0;
		int j=0;
		int k=0;
		for(i=1;i<=5;i++)  //打印上面5行
		{
			for(k=1; k<= 5-i ; k++)//打印前5行*前的空格
			System.out.print(" ");

			for(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(i =4;  i>=1 ;i--)  //打印下面4行
		{
			for(k=1; k<= 5-i ; k++)//打印下面4行*前的空格
			System.out.print(" ");

			for( j = 1 ; j <= 2*i-1; j++)
			{
				if(j==1 || j==2*i-1 ) //当前行的第一个位置是*,最后一个位置也是*
			System.out.print("*");
				else 
			System.out.print(" ");	
			}	
			System.out.println("");	
		}	
	}
}

4.14 跳转控制语句-break

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

image-20210911190155765

使用细节🔻

image-20210911190647139

🤖🤖🤖:课堂练习

image-20210911191609259
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
		int sum = 0; //累积和

		//注意i 的作用范围在 for{}
		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);
	}
}
import java.util.Scanner;
public class BreakExercise02 { 

	public static void main(String[] args) {
		// 思路分析
		// 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++) {//3次登录机会
			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 + "次登录机会");

		}
	}
}

4.15 跳转控制语句-continue

基本介绍:

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

  2. continue 语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的

使用的规则一样

image-20210912161757707

细节

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 label2,输出2次[0,1,3,4,5,6,7,8,9]
					continue label1; //输出 2次[0,1]
				}
				System.out.println("i = " + i);
	        }
	     }

	}
}

4.16 跳转控制语句-return

return 使用在方法,表示跳出所在的方法,在讲解方法的时候,会详细的介绍,这里我们简单的提一下。注意:如

果 return 写在 main 方法,退出程序

4.17 本章作业

image-20210912164032067image-20210912164109183

image-20210912164127967

image-20210912164154806
//1
public class Homeworkchapter4{
	public static void main(String[] args){

		int money = 100000;
		int n = 0;
		while (money >=1000){
			if(money>50000){
				n++;
				money = (int) (0.95 * money); 
			}
			else{
				n++;
				money = money-1000;
			}
		}
		System.out.println("10万能过"+ n +"次路口");//62
	}
}
//4
public class Homework04 { 

	//编写一个main方法
	public static void main(String[] args) {

		/*
		4. 判断一个整数是否是水仙花数,所谓水仙花数是指一个3位数,
		其各个位上数字立方和等于其本身。
		例如: 153 = 1*1*1 + 3*3*3 + 5*5*5

		思路分析 => 多听. 见多识广..
		1. 比如 int n = 153; 
		2. 先得到 n的百位,十位 ,各位的数字, 使用 if 判断他们的立方和是否相等
		3. n的百位 = n / 100
		4. n的十位 = n % 100 / 10
		5. n的个位 = n % 10
		6. 判断即可
		 */
		int n = 154;
		int n1 = n / 100;
		int n2 = n % 100 / 10;
		int n3 = n % 10;
		if(n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == n) {
			System.out.println(n + "是水仙花数");
		} else {
			System.out.println(n + "不是水仙花数");
		}
	}
}
//6

public class Homework06 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		输出1-100之间的不能被5整除的数,每5个一行

		思路分析
		1. 先输出1-100的所有数
		2. 然后过滤输出 不能被5整除的数 i % 5 !=0
		3. 每5个一行, 我们使用 int count 统计输出的个数 当 count%5=0就说明
			输出了5个,这时,我们输出 一个换行即可控制
		代码实现

		 */
		int count = 0; //统计输出的个数
		for(int i = 1; i <= 100; i++) {
			if(i % 5 != 0) {
				count++;
				System.out.print(i + "\t");
				//判断, 每满5个,就输出一个换行..
				if(count % 5 == 0) {
					System.out.println();
				}
			}
		}
	}
}
//7
public class Homework07 { 
	//编写一个main方法
	public static void main(String[] args) {
		//输出小写的a-z以及大写的Z-A
		//考察我们对 a-z编码和 for的综合使用
		//思路分析
		//1. 'b' = 'a' + 1 c = 'a' + 2
		//2. 使用for搞定
		
		for(char c1 = 'a'; c1 <= 'z'; c1++) {
			System.out.print(c1 +" ");
		} 
		System.out.println("============");
		//灵活的使用,编程..
		for(char c1 = 'Z'; c1 >= 'A'; c1--) {
			System.out.print(c1 +" ");
		}
	}
}
//8
public class Homework08 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		求出1-1/2+1/3-1/4…..1/100的和
		思路分析
		1. 1-1/2+1/3-1/4…..1/100 = (1/1)-(1/2)+(1/3)-(1/4)...1/100
		2. 从上面的分析我们可以看到 
		(1) 一共有100数 , 分子为1 , 分母从1-100
		(2) 还发现 当分母为奇数时,前面是 +, 当分母是偶数时,前面是-
		3. 我们可以使用 for + 判断即可完成
		4. 把结果存放到 double sum 
		5. 这里有一个隐藏的陷阱,要把 公式分子 1 写出1.0 才能得到精确的小数
		 */
		
		double sum = 0;
		for(int i = 1; i <= 100; i++) {
			//判断是奇数还是偶数,然后做不同的处理
			if( i % 2 != 0) {//分母为奇数
				sum += 1.0/i;
			} else { //分母我偶数
				sum -= 1.0/i;
			}
		}
		System.out.println("sum=" + sum);
	}
}
public class Homework09 { 
	//编写一个main方法
	public static void main(String[] args) {
		//求(1)+(1+2)+(1+2+3)+(1+2+3+4)+...+(1+2+3+..+100)的结果
		//
		//思路分析
		//1. 一共有100项相加
		//2. 每一项的数字在逐渐增加
		//3. 很像一个双层循环
		//i 可以表示是第几项,同时也是当前项的最后一个数
		//4. 使用 sum 进行累计即可
		int sum = 0;
		for(int i = 1; i <= 100; i++) {
			for(int j = 1;j <= i; j++) {//内层对1-i进行循环
				sum += j;
			}
		}
		System.out.println("sum=" + sum);  
	}
}

🔚

✴️✴️✴️✴️

在校学生,0基础学习java,如有问题,请多指教(^U^)ノ~YO
后续会继续更新哒,如果对博主感兴趣,麻烦点个关注和👍哟!😄😄😄
🚀🚀🚀

在这里插入图片描述

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/TripleK99999/article/details/120253678

android开发面试经——3.常见java基础笔试题-爱代码爱编程

关注finddreams博客:http://blog.csdn.net/finddreams/article/details/44403041 因为Androd使用Java语言来编程的,所以我们做Android开发全面的掌

java基础知识点梳理(详细)_程序员小辰的博客-爱代码爱编程_java基础知识点

Java基础知识梳理(详细) 1. Java中的数据类型 基本数据类型特征表 类型位数最小值最大值默认值其他byte8-128(-2^7)127(2^7-1)0有符号、二进制补码表示short16-32768(-

java基础四——面向对象思想_蜗牛2号的博客-爱代码爱编程

1.1 什么是面向对象         面向对象思想就是不断的创建对象(属性与行为的封装,让二者作为整体参与程序执行),使用对象,指挥对象做事情。(在已有对象的情况下,直接使用对象,而不再去考虑对象的内部构造)         面向对象的开发来讲也分为三个过程:OOA(面向对象分析)、OOD(面向对象设计)、OOP(面向对象编程) 1.2 了解对象的内部结

java基础知识之笔记总结分享(超详细)_iswitched的博客-爱代码爱编程_java笔记

给大家分享一篇我之前在学习java过程中的关于java基础部分的笔记,比较详细,内容也比较多。 如有问题请指出以便修改,谢谢。 篇幅较长建议收藏浏览。 1 环境变量配置 JAVA_HOME:jdk路径 Path:要把jd

java基础——java代码规范详细版_ddm01的博客-爱代码爱编程_java代码规范

本Java代码规范以SUN的标准Java代码规范为基础,为适应我们公司的实际需要,可能会做一些修改。本文档中没有说明的地方,请参看SUN Java标准代码规范。如果两边有冲突,以SUN Java标准为准。 1. 标识符命名规范 1.1 概述 标识符的命名力求做到统一、达意和简洁。 1.1.1 统一 统一是指,对于同一个概念,在程序中用同一种表示方

Java基础——异常处理机制-爱代码爱编程

目录 异常处理1. 介绍2. 异常类型3. 异常处理的详细操作3.1 声明异常3.2 抛出异常3.3 捕获异常与finally子句3.4 从异常中获取信息4. 创建自定义异常类 异常处理 1. 介绍 如果一个用户在运行程序期间,由于程序的错误或一些外部环境的影响造成用户数据的丢失,用户就有可能不再使用这个程序了, 为了避免这类事情的发生,

java,从入土到出棺——3.逻辑结构与程序控制-爱代码爱编程

java,从入土到出棺——3.逻辑结构与程序控制 1 逻辑结构1.1 概述1.2 业务逻辑结构的“五常”1.2.1 控制——调度者1.2.2 处理——业务处理1.2.3 储存——数据的时效储存1.2.4 输入——数据的获取1.2.5 输出——数据的处理反馈2 程序控制结构2.1 顺序结构2.2 选择结构2.2.1 逻辑判断2.2.2 if语句2.2

Java基础语法(四)——程序逻辑控制-爱代码爱编程

文章目录 Java基础语法(四)——程序逻辑控制一、顺序结构1.什么是顺序结构?2.顺序结构的示例二、选择结构1. if 语句(1)基本书写格式(2) 练习练习一练习二练习三(3)注意事项1.悬垂 else 问题2. 代码风格问题3. 分号问题2. switch .. case 语句(1)基本语法(2)代码示例(3)注意事项三、循环结构循环中的关键

史上最强 Java 学习路线图!-爱代码爱编程

网上看到一首诗:“代码尽头谁为峰,一见秃头道成空。编程修真路破折,一步一劫渡飞升。”感觉还挺有意境的。 第一部分:Java 基础篇 这个阶段就是编程入门,掌握 Java 这门编程语言的基本语法,为后面的修行之路打好基础。 包括的知识点有: 环境搭建——Intellij IDEA 一站式搞定Java 基础语法面向对象——封装、继承、多态数组字符串

绝不误人子弟!零基础应该选择学习Java、PHP,还是前端?-爱代码爱编程

上周,有读者私信我说,“二哥,零基础该选择 Java 还是 PHP 啊?” 我瞬间就误了!PHP?世界上最好的编程语言? 后来,又有读者私信问我,“挺纠结的,不知道该选前端还是 Java?” 真不好选,因为“男怕入错行,女怕嫁错郎”,初学者纠结这个问题也是情有可原。 首先来说说 PHP,Web 蛮荒的年代,PHP 真的是王者姿态,连 Java

java基础——面试篇下-爱代码爱编程

java基础 java基础——面试篇下 java基础——面试篇下 java基础前言一、Map1、Map常见的几种类型2、HashMap和HashTable的区别3、hashcode()和equals()4、hashMap和TreeMap区别5、Set和Map的关系6、常见的Map的排序规则是怎样的?7、线程安全且效率高的map8、为什么Coll

【java基础】java内置数据结构——栈_java自带栈-爱代码爱编程

简述 以前在学习C语言的时候学习过基本的数据结构,栈就是其中非常基础的数据结构之一。 栈(stack)又名堆栈,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为