第五章 Java程序控制结构

本章重点

1. random随机函数
2. 内存分析法
3. 编程思想: 化繁为简, 先死后活
4. 当分子分母都为int类型时, 相除等于0, 所以 1 / i 要写成 1.0 / i.

本章难题

1. 求出 1+(1 + 2) + (1 + 2 + 3) + (1 + 2 + 3 + 4) + … + (1 + 2 + 3 + … + 100)的结果.
2. 求出 1-1/2 + 1/3 - 1/4 … 1/100的和.
3. 打印出九九乘法表
4. 完成下面的表达式输出
   

4. 统计3个班成绩情况, 每个班有5名同学, 求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]; 统计三个班及格人数, 每个班有5名同学

🔥程序流程控制介绍

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

1. 顺序控制
2. 分支控制
3. 循环控制

🐇顺序控制

●顺序控制介绍
程序从上到下逐行地执行, 中间没有任何判断和跳转



●顺序控制举例和注意事项
Java中定义变量时采用合法的前向引用, 如:
public class Test {
      int num1 = 12;
      int num2 = num1 + 2;
}
错误形式
public class Test {
      int num2 = num1 + 2; //错误
      int num1 = 12;
}

🐇分支控制

●分支控制if-else介绍
让程序有选择的执行, 分支控制有三种

1.单分支 if
2.双分支 if-else
3.多分支 if-else if…-else

🐼单分支

√ 基本语法
if(条件表达式) {
      执行代码块; //可以有多条语句
}
说明:当条件表达式为true时, 就会执行 { } 的代码. 如果为false, 就不执行.
特别说明: 如果 {} 中只有一条语句, 则可以不用 {}, 建议写上{}

√ 案例说明 if01.java
编写一个程序, 可以输入人的年龄, 如果该同志的年龄大于18岁, 则输出 “你年龄大于18, 要对自己的行为负责, 送入监狱”

import java.util.Scanner;//导入

//if的快速入门
public class If01 {
	//编写一个main方法
	public static void main(String[] args) {
		//需求:编写一个程序, 可以输入人的年龄, 如果该同志的年龄大于18岁, 
		//则输出 "你年龄大于18, 要对自己的行为负责, 送入监狱"
		
		//思路分析
		//1.接收输入的年龄, 应该定义一个Scanner 对象
		//2.把年龄保存到一个变量 int age
		//3.使用 if 判断, 输出对应信息
		
		//接收输入的年龄, 应该定义一个Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入年龄: ");
		//把年龄保存到一个变量 int age
		byte age = myScanner.nextByte();
		//使用 if 判断, 输出对应信息
		if(age > 18) {
			System.out.println("你年龄大于18, 要对自己的行为负责, 送入监狱");
		}
		System.out.println("程序继续执行...");
	}
}

√ 单分支对应的流程图(描述程序执行流程)

🐼双分支

√ 基本语法
if(条件表达式) {
      执行代码块1;
} else {
      执行代码块2;
}

说明:当条件表达式成立, 即执行代码块1 , 否则执行代码块2. 如果执行代码块 只有一条语句, 则 {} 可以省略, 否则, 不能省略.

√ 案例演示 If02.java
编写一个程序, 可以输入人的年龄, 如果该同志的年龄大于18岁, 则输出 “你年龄大于18, 要对自己的行为负责, 送入监狱”. 否则, 输出 “你的年龄不大这次放过你了”

import java.util.Scanner;//导入

//if的快速入门
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.print("请输入年龄: ");
		//把年龄保存到一个变量 int age
		byte age = myScanner.nextByte();
		//使用 if-else 判断, 输出对应信息
		if(age > 18) {
			System.out.println("你年龄大于18, 要对自己的行为负责, 送入监狱");
		} else {//双分支
			System.out.println("你的年龄不大这次放过你了");
		}
		
		System.out.println("程序继续执行...");
	}
}

√ 双分支对应的流程图(描述程序执行流程)

🐼单分支和双分支练习题

1.对下列代码, 若有输出, 指出输出结果
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 is " + x);
}
//输出的内容是? => 星儿~

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

//单分支和双分支的练习
public class IfExercise01 {
	//编写一个main方法
	public static void main(String[] args) {
		//需求: 编写程序, 声明2个double类型变量并赋值, 
		//判断第一个数大于10.0, 且第2个数小于20.0, 打印两数之和.
		
		//思路分析
		
		double num1 = 12;
		double num2 = 15.3;
		if(num1 > 10.0 && num2 < 20.0) {
			System.out.println("两个数的和=" + (num1 + num2);
		}
	}
}

3.定义两个变量int, 判断二者的和, 是否能被3又能被5整除, 打印提示信息.

//单分支和双分支的练习
public class IfExercise01 {
	//编写一个main方法
	public static void main(String[] args) {
		//需求: 定义两个变量int, 判断二者的和, 
		//是否能被3又能被5整除, 打印提示信息.
		
		//思路分析
		//1.定义两个变量 int num1, num2
		//2.定义一个变量 int sum = num1 + num2;
		//3.sum % 3, 5 后 等于0 说明可以整除
		//4.使用 if-else 来提示对应信息
		//走代码
		int num1 = 1;
		int num2 =15;
		int sum = num1 + num2;
		if(sum % 5 == 0 && sum % 5 == 0) {
			System.out.println("和可以被3又能被5整除");
		} else {
			System.out.println("和不可以被3和5整除");
		}
	}
}

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

//单分支和双分支的练习
public class IfExercise01 {
	//编写一个main方法
	public static void main(String[] args) {
		//需求: 判断一个年份是否是闰年, 闰年的条件是符合下面二者之一: 
		//(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 = 2012;
		if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
			System.out.println(year + " 是闰年");
		} else {
			System.out.println(year + " 不是闰年");
		}
		
	}
}

🐼多分支

√ 基本语法
if(条件表达式1) {
      执行代码块1;
}
else if(条件表达式2) {
      执行代码块2;
}
…
else {
      执行代码块n;
}

多分支的流程图

说明:
1.当条件表达式1成立时, 即执行代码块1.
2.当条件表达式1不成立, 采取判断表达式2是否成立
3.如果表达式2成立, 就执行代码块2
4.依此类推, 如果所有的表达式都不成立
5.则执行 else 的代码块. 注意, 只能有一个执行入口

特别说明: (1)多分支 可以没有 else, 在这种情况下, 如果所有的条件表达式都不成立, 则一个执行入口都没有 (2) 如果有 else, 如果所有的条件表达式都不成立, 则默认执行else代码块

案例演示 If03.java
输入马宝国同志的芝麻信用分:
如果:
1.信用分为100分时, 输出 信用极好
2.信用分为(80, 99]时, 输出 信用优秀
3.信用分为(60, 80]时, 输出 信用一般
4.其它情况, 输出 信用 不及格
5.请从键盘输入马宝国的芝麻信用分, 并加以判断

import java.util.Scanner;

public class If03 {
	//编写一个main方法
	public static void main(String[] args) {
		System.out.println();
		/*
			输入马宝国同志的芝麻信用分: 
			如果:
			1.信用分为100分时, 输出 信用极好
			2.信用分为(80, 99]时, 输出 信用优秀
			3.信用分为(60, 80]时, 输出 信用一般
			4.其它情况, 输出 信用 不及格
			5.请从键盘输入马宝国的芝麻信用分, 并加以判断
			6.极爱的那个信用分数 int
			System.out.println();
		 */
		Scanner myScanner = new Scanner(System.in);
		//接收用户输入
		System.out.print("请输入马宝国同志的信用积分: ");
		//思考: 如果小伙伴输入的不是一个整数, 还是hello. 1.1...
		//==>这里我们后面可以使用异常处理机制搞定
		int grade = myScanner.nextInt();
		
		//先对输入的信用分, 进行一个范围的有效判断  1-100,  否则提示输入错误
		if(grade >= 1 && grade <= 100) {
			//因为有4种情况, 我们使用多分支
			if(grade == 100) {//信用分为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.print("信用分需要在1-100, 请重新输入: ");
		}
	}
}

√ 案例演示2

boolean b = true;
if (b = false) //如果写成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”);
}

代码

boolean b = true;
if (b == false) { //如果写成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");
}

🐼嵌套分支

英语学习时刻: nested branch

●基本介绍
在一个分支结构中又完整地嵌套了另一个分支结构, 里面的分支的结构称为内层分支, 外面的分支结构称为外层分支. 规范: 不要超过3层. (可读性不好)

●基本语法
if() {
      if() {
            //if-else…
      }else{
            //if-else…
      }
}

●应用案例
参加歌手比赛, 如果初赛成绩大于8.0则进入决赛, 否则提示淘汰. 并且根据性别提示进入男子组或女子组. 输入成绩和性别, 进行判断和输出信息. NestedIf.java
提示: double score, char gender;
接收字符: char gender = scanner.next().charAt(0);

import java.util.Scanner;

public class NestedIf {
	//编写一个main方法
	public static void main(String[] args) {
		//参加歌手比赛, 如果初赛成绩大于8.0则进入决赛, 
		//否则提示淘汰. 并且根据性别提示进入男子组或女子组. 
		//输入成绩和性别, 进行判断和输出信息
		
		//提示: 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.print("请输入该歌手的成绩: ");
		double score = myScanner.nextDouble();
		if (score > 8.0) {
			System.out.print("请输入性别: ");
			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, 你被淘汰了");
		}
		
	}
}

●应用案例2 NestedIf02.java
出票系统, 根据淡季旺季的月份和年龄, 打印票价
4-10 旺季:
            成人 [18-60]: 60元
            儿童 [0-18): 半价
            老人 (>60): 1/3
淡季:
            成人 [18-60]: 40元
            其它 : 20元

import java.util.Scanner;

public class NestedIf02 {
	//编写一个main方法
	public static void main(String[] args) {
		/*需求
			出票系统, 根据淡季旺季的月份和年龄, 打印票价
			4-10 旺季:
			            成人 (18-60): 60元
			            儿童 (<18): 半价
			            老人 (>60): 1/3
			淡季:
			            成人 (18-60): 40元
			            其它 : 20元
		 */
		
		//思路分析
		//1.创建Scanner 对象, 接收用户输入
		//2.接收 月份保存到 int year
		//3.接收年龄保存到 int age
		//4.使用 if-else双分支 判断 淡季旺季
		//5.在旺季中, 使用 多分支 判断年龄-票价
		//6.在淡季中, 使用 if-else双分支 判断 年龄-票价
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入月份: ");
		int year = myScanner.nextInt();
		System.out.print("请输入年龄: ");
		int age = myScanner.nextInt();
		if(year >= 4 && year <= 10) {
			if (age >= 18 && age <= 60) {
				System.out.println("成人 (18-60): 60元");
			} else if (age < 18 && age >= 0) {
				System.out.println("儿童 (<18): 半价");
			} else if (age > 60) {
				System.out.println("老人 (>60): 1/3");
			} else {
				System.out.print("您的年龄输入有误, 请重新输入");
			}
		} else {
			if (age >= 18 && age <= 60) {
				System.out.println("成人 (18-60): 40元");
			} else {
				System.out.println("其它: 20元");
			}
		}
	}
}

🐼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

●流程图

●快速入门
案例: Switch01.java
1.编写一个程序, 该程序可以接收一个字符, 比如: a,b,c,d,e,f,g
2.a表示星期一, b表示星期二…
3.根据用户的输入显示相应的信息. 要求使用switch语法完成

import java.util.Scanner;

public class Switch01 {
	//编写一个main方法
	public static void main(String[] args) {
		/*
			1.编写一个程序, 该程序可以接收一个字符, 比如: a,b,c,d,e,f,g
			2.a表示星期一, b表示星期二...
			3.根据用户的输入显示相应的信息. 要求使用switch语法完成
		 */
		
		//思路分析
		//1.接受一个字符, 创建Scanner对象
		//2.使用switch 来完成匹配, 并输出对应信息
		
		//代码实现
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入一个字符(a-f): ");
		char week = myScanner.next().charAt(0);
		//在java中, 只要是有值返回, 就是一个表达式
		switch (week) {
			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注意事项和细节讨论 SwitchDetail.java
1.表达式的数据类型, 应和case 后的常量类型一致, 或者是可以自动转成可以相互比较的类型, 比如输入的是字符, 而常量是 int
2.switch(表达式)中表达式的返回值必须是: (byte, short, int, char, enum[枚举], String)
3.case子句中的值必须是常量 或 常量表达式, 而不能是变量
4.default子句是可选的, 当没有匹配的case时, 执行default
5.break语句用来在执行完一个case分支后使程序跳出switch语句块; 如果没有写break. 程序会顺序执行到switch结尾, 直到遇到break;
6.default子句可以不用加break;

import java.util.Scanner;

public class SwitchDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//细节1
		//表达式的数据类型, 应和case 后的常量类型一致, 
		//或者是可以自动转成可以相互比较的类型, 比如输入的是字符, 而常量是 int
		
		//细节二
		//switch(表达式)中表达式的返回值必须是: 
		//(byte, short, int, char, enum[枚举], String)

		//细节三
		//case子句中的值必须是常量(1,'a')或常量表达式, 而不能是变量

		//细节四
		//default子句是可选的, 当没有匹配的case时, 执行default
		//如果没有default子句, 有没有匹配任何常量, 则没有输出
		char c = 'c';
		switch (c) {
				case 'a':
					System.out.println("ok1");
					// break;
				case 'b' + 1:
					System.out.println("ok2");
					// break;
				default:
					System.out.println("ok3");
			}
		System.out.println("退出了switch, 程序继续执行...");
	}
}

●switch课堂练习 SwitchExercise.java
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冬季. 提示 使用穿透

import java.util.Scanner;

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

		//使用 switch 把小写类型的 char型转为大写(键盘输入), 
		//只转换 a, b, c, d, e. 其它输出 "other".
		
		//思路分析
		//1.创建Scanner 对象, 接收用户输入
		//2.创建一个变量 char c, 接收用户输入
		//3.使用switch来完成匹配, 并输出信息

		//代码实现
/*		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入一个字符(a-e): ");
		char c = myScanner.next().charAt(0);
		switch(c) {
			case 'a':
				System.out.println((char)('a' - 32));
				break;
			case 'b':
				System.out.println((char)('b' - 32));
				break;
			case 'c':
				System.out.println((char)('c' - 32));
				break;
			case 'd':
				System.out.println((char)('d' - 32));
				break;
			case 'e':
				System.out.println((char)('e' - 32));
				break;
			default:
				System.out.println(("other"));
		}*/


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

		//思路分析
		//1.这道题, 可以使用 if-else分支 来完成, 但是要求使用switch分支
		//2.这里我们需要进行一个转换 编程思想
		//3.如果成绩在 [60, 100], (int)(成绩/60) = 1
		//  如果成绩在 [0, 60),   (int)(成绩/60) = 0
		
		//代码实现
/*		double score = 53.5;
		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("输入的成绩无效");
				// 	break;
			}
		} else {
			System.out.println("输入的成绩无效");
		}
*/
		//根据指定月份, 打印该月份所属的季节. 
		//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.print("你指定一下月份: ");
		int month = myScanner.nextInt();
		if (month >= 0 && month <= 12) {
			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("你输入的月份不对");
			}
		} else {
			System.out.println("输入的月份有误");
		}
	}
} 

●switch和if的比较
1.如果判断的具体数值不多, 而且符合byte, short, int, char, enum[枚举], String这6种类型, 虽然两个语句都可以使用, 建议使用switch分支. (星期, 季节, 性别等等)
2.其它情况: 对区间判断, 对结果为boolean类型判断, 使用if分支.

🐇循环控制

🐼for循环控制

●需求: 编写一个程序, 可以打印10句 “你好, 赵志伟” For01.java

public class For01 {
	//编写一个main方法
	public static void main(String[] args) {
		//打印10句 "你好, 赵志伟"
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
		System.out.println("你好, 赵志伟");
	}
}

●基本语法
for(循环变量初始化; 循环条件; 循环变量迭代;) {
       循环操作(可以多条语句);
}

√ 说明
1.for关键字, 表示循环控制
2.for循环有四要素: (1)循环变量初始化 (2)循环条件 (3)循环操作 (4)循环变量迭代
3.如果 循环操作(语句) 只有一条语句, 可以省略 {}, 建议不要省略


●for循环执行流程分析
1.使用for循环完成前面的题

public class For01 {
	//编写一个main方法
	public static void main(String[] args) {
		//打印10句 "你好, 赵志伟"
		//传统的方法
		//...
		
		// 使用for循环控制
		for(int i = 1; i <= 10; i++) {
			System.out.println("你好, 赵志伟" + i);
		}
	}
}

2.画出for循环流程图

3.代码执行内存分析图

●注意事项和细节说明 ForDetail.java
1.循环条件是返回一个布尔值的表达式
2.for(;循环条件;) 中的循环变量初始化和循环变量迭代可以写到其它地方, 但是两边的分号不能省略
3.循环变量初始值可以有多条初始化语句, 但要求类型一样, 并且中间用逗号隔开; 循环变量迭代也可以有多条变量迭代语句, 中间用逗号隔开.

/**
 * 演示for的使用细节 
 */
public class ForDetail {
	//编写一个main方法
	public static void main(String[] args) {
		//for(;循环条件;) 
		//中的循环变量初始化和变量迭代可以写到其它地方, 但是两边的分号不能省略
		
		// 使用for循环控制
		int i = 1;//循环变量初始化
		for(; i <= 10; ) {
			System.out.println("hello, 赵志伟" + i);
			i++;
		}
		System.out.println(i);//ok

		//补充
		int j = 1;
		for(;;) { //表示无限循环(死循环) ctrl+c退出
			System.out.println("ok~" + j++);
		}

		//循环初始值可以有多条初始化语句, 但要求类型一样, 
		//并且中间用逗号隔开; 循环变量迭代也可以有多条变量迭代语句, 中间用逗号隔开.
		//我们使用内存分析法, 观察下面代码输出什么
		int count = 3;
		for(int i = 0, j = 0; i < count; i++, j += 2) {
			System.out.println("i=" + i + " j=" + j);
		}
	}
}

4.使用内存分析法, 分析下列代码输出什么

int count = 3;
for(int i = 0, j = 0; i < count; i++, j += 2) {
	System.out.println("i=" + i + " j=" + j);
}

●for循环练习题
1.打印1~100之间所有是9的倍数的整数, 统计个数 及 总和. [化繁为简, 先死后活] ForExercise.java

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 = 100;
		int end = 200;
		int t = 5;//倍数
		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);
	}
}

2.完成下面的表达式输出 ForExercise02.java

public class ForExercise02 {
	//编写一个main方法
	public static void main(String[] args) {
		//完成下面表达式的输出

		//化繁为简
		//(1) 先输出 1 - 5
		//(2) +后面的是 5-i
		//先死后活
		//(1) 把范围的结束值, 替换成变量 end
		int end = 10;
		for(int i = 1; i <= end; i++) {
			System.out.println(i + " + " + (end - i) + "= " + end);
		}
	}
}

🐼while循环控制

●基本语法

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

●说明
1.while 循环也有四要素
2.只是四要素放的位置和for不一样

●while循环执行流程分析
1.画出流程图

2.使用while循环, 打印10句 “你好, 赵志伟”. While01.java

public class While01 {
	//编写一个main方法
	public static void main(String[] args) {
		//打印10句 "你好, 赵志伟"
		
		int i = 0;//循环变量初始化
		while (i <= 10) {//循环条件
			System.out.println("你好, 赵志伟" + i);//循环语句
			i++;//循环变量迭代
		}

		System.out.println("退出while循环, 继续...");
	}
}

3.代码执行内存分析图

●注意事项和细节说明
1.循环条件是返回一个布尔值的表达式
2.while循环是先判断再执行语句, 和for循环一样

●课堂练习题 WhileExercise.java
1.打印1-100之间所有能被3整除的数(使用while)
2.打印40-200之间所有的偶数 [使用while]

//课堂练习题
public class WhileExercise {
	//编写一个main方法
	public static void main(String[] args) {
		//打印1-100之间所有能被3整除的数(使用while)
		//化繁为简, 先死后活

		int i = 1;
		int end = 100;
		while (i <= end) {
			if (i % 3 == 0) {
			 	System.out.println("i=" + i);	
			}
		 	i++;//变量自增
		 }

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

🐼do-while循环控制

●基本语法

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

●说明
1.do while 关键字
2.也有循环四要素, 只是位置不一样
3.先执行, 再判断. 也就是说, 至少执行一次
4.最后有一个分号;

●do-while循环执行流程分析
1.画出流程图

2.使用do-while完成 打印10句 “你好, 赵志伟”. DoWhile.java

//课堂练习题
public class DoWhile {
	//编写一个main方法
	public static void main(String[] args) {
		//使用do-while完成 打印10句 "你好, 赵志伟".
		int i = 1;
		do {
			//循环执行语句
			System.out.println("你好, 赵志伟" + i);
			i++;//变量迭代
		}while(i <= 10);
		System.out.println("退出 do-while 继续..." + i);//11
	}
}

3.画出代码执行内存分析图

●注意事项和细节说明
1.循环条件是返回一个布尔值的表达式
2.do-while循环是先执行, 再判断, 因此它至少执行一次

●课堂练习题
1.打印1-100
2.计算1-100的和
3.统计1-200之间能被5整除但不能被3整除的个数 DoWhileExercise01.java

//课堂练习题
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.把范围的开始的值和结束的值, 做成变量 int start; int end
        //2.把 倍数 换成 int times1; int times
        int start = 1;
        int end = 200;
        int i = start;
        int times = 5;
        int times2 = 3;
        int count = 0;//统计满足条件的个数
        do {
        	if (i % times == 0 && i % times2 != 0) {
        		System.out.println("i=" + i);
        		count++;	
        	}
        	i++;
        }while(i <= end);
        System.out.println("count=" + count);
    }
}

4.如果李三不还钱, 则老王一直使出五连鞭, 直到李三说还钱为止. [System.out.println(“老王问: 还钱吗? y/n”)] do-whileDoWhileExercise02.java

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对象
        //.在do-while 的while判断 如果是 y 就不再循环
        //代码实现
        Scanner myScanner = new Scanner(System.in);
        char answer = ' ';
        do {
            System.out.println("老韩使出五连鞭");
            System.out.print("老王问: 还钱吗? y/n: ");
            answer = myScanner.next().charAt(0);
            System.out.println("他的回答是: " + answer);
        }while(answer != 'y');//判断条件
        System.out.println("李三终于还钱了");
    }
}

🐼多重循环控制(重点,难点)

●介绍
1.将一个循环放在另一个循环体内, 就形成了嵌套循环. 其中, for, while, do-whlie循环均可作为外层循环和内层循环. [建议嵌套循环一般使用两层, 最多不要超过3层. 否则, 代码的可读性很差]
2.实质上, 嵌套循环就是把内层循环当成外层循环的循环体. 当只有内层循环的循环条件为false时, 才会完全跳出内层循环, 才可结束外层的当次循环, 开始下一次的循环.
3.设外层循环次数为m次, 内层为n次, 则内层循环体实际上需要执行m*n次

●多重循环执行步骤分析
请分析 下面的多重循环执行步骤, 并写出 输出语句 内存分析法 MultiFor.java

//双层for
for(int i = 0; i < 2; i++) {
    for(int j = 0; j < 3; j++) {
        System.out.println("i=" + i + " j=" + j);
    }
}

内存分析法

●应用实例
1.统计3个班成绩情况, 每个班有5名同学, 求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]
2.统计三个班及格人数, 每个班有5名同学 MultiForExercise01.java

import java.util.Scanner;

public class MultiForExercise01 {
    //编写一个main方法
    public static void main(String[] args) {
		//1.统计3个班成绩情况, 每个班有5名同学, 
		//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]
		//2.统计三个班及格人数, 每个班有5名同学

		//思路分析
		//化繁为简
		//1. 先计算一个班, 5个学生 的成绩, 使用for
		//1.1创建 Scanner 对象, 接收用户输入
		//1.2得到该班级平均分
		//1.3先定义一个 double sum 把该班级5个学生的成绩累积

		//2. 求出所有班级的平均分
		//2.1定义一个变量 double totalScore, 累积所有学生的成绩
		//2.2当多重循环结束后, totalScore  / (3 * 5)
		//3. 统计三个班及格人数, 每个班5个同学
		//3.1定义一个变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
		//4. 可以优化[效率, 可读性, 结构]
		Scanner myScanner = new Scanner(System.in);
		double totalScore = 0;
		int passNum = 0;//累积 及格人数
		for(int i = 1; i <= 3; i++) {//i表示班级
			double sum = 0;//一个班级的总分
			for(int j = 1; j <= 5; 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 / 5);
			//把 sum 累积到 totalScore
			totalScore += sum;
    	}
    	System.out.println("三个班总分=" + totalScore + " 平均分=" + (totalScore / 15));
    	System.out.println("及格人数=" + passNum);
    }
}

3.打印出九九乘法表, 如下图所示. MultiForExercise02.java

public class MultiForExercise02 {
    //编写一个main方法
    public static void main(String[] args) {
		/*
        打印九九乘法表
		1 * 1= 1
		1 * 2= 2        2 * 2= 4
		1 * 3= 3        2 * 3= 6        3 * 3= 9
		1 * 4= 4        2 * 4= 8        3 * 4= 12       4 * 4= 16
		1 * 5= 5        2 * 5= 10       3 * 5= 15       4 * 5= 20       5 * 5= 25
		1 * 6= 6        2 * 6= 12       3 * 6= 18       4 * 6= 24       5 * 6= 30       6 * 6= 36
		1 * 7= 7        2 * 7= 14       3 * 7= 21       4 * 7= 28       5 * 7= 35       6 * 7= 42       7 * 7= 49
		1 * 8= 8        2 * 8= 16       3 * 8= 24       4 * 8= 32       5 * 8= 40       6 * 8= 48       7 * 8= 56       8 * 8= 64
		1 * 9= 9        2 * 9= 18       3 * 9= 27       4 * 9= 36       5 * 9= 45       6 * 9= 54       7 * 9= 63       8 * 9= 72       9 * 9= 81
		
		思路分析
        1. 从图中可以看到
          (1) 一共有9行 输出
          (2) 每一行的表达式在逐渐地增加
              第1行 有 1个表达式
	          第2行 有 2个表达式
	          第3行 有 3个表达式
	          第4行 有 4个表达式
          (3) 适合使用双重for循环
        2. i 可以表示第几行, 是当前行的第2个乘数
           j 的范围是 1-i,  是当前行的第1个乘数 
        */
       
       //代码实现
       for(int i = 1; i <= 9; i++) {
        for(int j = 1; j <= i; j++) {//内层对1-i进行循环
            System.out.print(j + " * " + i + " = " + (j * i));
            System.out.print("\t");
        }
        System.out.println("");
       }
    }
}

●经典的打印金字塔
使用 for 循环完成下面的案例
请编写一个程序, 可以接收一个整数, 表示层数 (totalLevel), 打印出金字塔. Stars.java [化繁为简, 先死后活]

import java.util.Scanner;

public class Stars {
    //编写一个main方法
    public static void main(String[] args) {
        //请编写一个程序, 可以接收一个整数, 表示层数 (totalLevel), 打印出金字塔.
        /*
            *
           * *
          *   *
         *     *
        *********

        思路分析
        化繁为简
        1.先打印 一个矩形
        *****
        *****
        *****
        *****
        *****

        2.打印 半个金字塔
        *       //第1层 有 1个*
        **      //第2层 有 2个*
        ***     //第3层 有 3个*
        ****    //第4层 有 4个*
        *****   //第5层 有 5个*
        
        3.打印 整个金字塔
        *       //第1层 有 1个*     1(当前层数) * 2 - 1     有4=(总层数-1[当前层])个空格
       ***      //第2层 有 3个*     2(当前层数) * 2 - 1     有3=(总层数-2[当前层])个空格
      *****     //第3层 有 5个*     3(当前层数) * 2 - 1     有2=(总层数-3[当前层])个空格
     *******    //第4层 有 7个*     4(当前层数) * 2 - 1     有1=(总层数-4[当前层])个空格
    *********   //第5层 有 9个*     5(当前层数) * 2 - 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 <= i * 2 - 1; j++) {
                if (j == 1 || j == 2 * i - 1 || i == totalLevel) {
                    System.out.print("*");//println()有换行
                } else {//其它情况
                    System.out.print(" ");
                }
            }
            //每打印完一层的*后, 就换行 println()本身有换行
            System.out.println("");
        }
    }
}

拓展: 请编写一个程序, 可以接收一个整数, 表示层数 (totalLevel), 打印出菱形. Diamond.java [化繁为简, 先死后活]

import java.util.Scanner;

public class Diamond {
    //编写一个main方法
    public static void main(String[] args) {
        //请编写一个程序, 可以接收一个整数, 表示层数 (totalLevel), 打印出空心菱形.

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

        思路分析
        化繁为简
        思路分析
        化繁为简
        1.先打印 一个矩形
        *****
        *****
        *****
        *****
        *****

        2.打印 半个金字塔
        *       //第1层 有 1个*
        **      //第2层 有 2个*
        ***     //第3层 有 3个*
        ****    //第4层 有 4个*
        *****   //第5层 有 5个*
        
        3.打印 整个金字塔
        *       //第1层 有 1个*     1(当前层数) * 2 - 1     有4=(总层数-1[当前层])个空格
       ***      //第2层 有 3个*     2(当前层数) * 2 - 1     有3=(总层数-2[当前层])个空格
      *****     //第3层 有 5个*     3(当前层数) * 2 - 1     有2=(总层数-3[当前层])个空格
     *******    //第4层 有 7个*     4(当前层数) * 2 - 1     有1=(总层数-4[当前层])个空格
    *********   //第5层 有 9个*     5(当前层数) * 2 - 1     有0=(总层数-5[当前层])个空格

        4.打印 空心金字塔 [最难]
        *       //第1层 有 1个*     当前行的第一个位置是*, 最后一个位置也是*
       * *      //第2层 有 2个*     当前行的第一个位置是*, 最后一个位置也是*
      *   *     //第3层 有 2个*     当前行的第一个位置是*, 最后一个位置也是*
     *     *    //第4层 有 2个*     当前行的第一个位置是*, 最后一个位置也是*
    *       *   //第5层 有 9个*     当前行的第一个位置是*, 最后一个位置也是*

        先死后活
        5.把层数做成变量 int totalLevel = 5;
        
        6.先打印一个矩形 
        ****
        ****
        ****
        ****

        7.打印半个金字塔
        ****    //第6层 有 4=(2 * 5[totalLevel]-6[当前层数])个*
        ***     //第7层 有 3=(2 * 5[totalLevel]-7[当前层数])个*
        **      //第8层 有 2=(2 * 5[totalLevel]-8[当前层数])个*
        *       //第9层 有 1=(2 * 5[totalLevel]-9[当前层数])个*

        8.打印整个金字塔  
       *******       //第6层 有 7个*     (2*5[totalLevel] - 6[当前层数]) * 2 - 1     有1=(6[当前层]-5[totalLevel])个空格
        *****        //第7层 有 5个*     (2*5[totalLevel] - 7[当前层数]) * 2 - 1     有2=(7[当前层]-5[totalLevel])个空格
         ***         //第8层 有 3个*     (2*5[totalLevel] - 8[当前层数]) * 2 - 1     有3=(8[当前层]-5[totalLevel])个空格
          *          //第9层 有 1个*     (2*5[totalLevel] - 9[当前层数]) * 2 - 1     有4=(9[当前层]-5[totalLevel])个空格

         9.打印空心金字塔 [最难]
       *     *       //第6层 有 2个*     当前行的第一个位置是*, 最后一个位置也是*
        *   *        //第7层 有 2个*     当前行的第一个位置是*, 最后一个位置也是*
         * *         //第8层 有 2个*     当前行的第一个位置是*, 最后一个位置也是*
          *          //第9层 有 1个*     当前行的第一个位置是*, 最后一个位置也是*

          先死后活
          10.把层数做成变量
         */



        int totalLevel = 30;
        for(int i = 1; i <= totalLevel; i++) { //i表示层数

          //在打印输出*之前, 先输出 对应空格
          for(int k = 1; k <= totalLevel-i; k++) {
            System.out.print(" ");
          }

          //控制打印每层的*的个数
          for(int j = 1; j <= i * 2 - 1; j++) {
            //当前行的第一个位置是*, 最后一个位置也是*
            if(j == 1 || j == i * 2 - 1) {
              System.out.print("*");
            } else {//其它情况输出空格
              System.out.print(" ");
            }
          }
          //在打印完每层的*之后, 输出换行 println自带换行
          System.out.println("");
        }


        for(int i = totalLevel + 1; i <= 2 * totalLevel - 1; i++) {

          //在打印输出*之前, 先打印 对应空格
          for(int k = 1; k <= i - totalLevel; k++) {
            System.out.print(" ");
          }

          for(int j = 1; j <= (2 * totalLevel - i) * 2 - 1; j++) {
            if (j == 1 || j == (2 * totalLevel - i) * 2 - 1) {
              //控制每层输出的*的个数
              System.out.print("*");
            } else {//其它情况输出空格
              System.out.print(" ");
            }
          }
          //在打印完每层的*之后, 输出换行
          System.out.println("");
        }
    }
}

第二种做法, 涉及行列式知识点

public class Test {
	//编写一个main方法
	public static void main(String[] args) {
		/*
		请编写一个程序, 可以接收一个整数, 表示层数 (totalLevel), 打印出菱形.
			*
		   * *
		  *   *
		 *     *
		*       *
		 *     *
		  *   *
		   * *
		    *

		思路分析
		化繁为简
		1.先打印一个矩形 9x5
		*****
		*****
		*****
		*****
		*****
		*****
		*****
		*****
		*****

		2.打印半个 菱形
		抽象成绝对值函数 y = 5 - |5-x|

		*		第1行 有 1个*	5-|5-1当前层|
		**		第2行 有 2个*	5-|5-2当前层|
		***		第3行 有 3个*	5-|5-3当前层|
		****	第4行 有 4个*	5-|5-4当前层|
		*****	第5行 有 5个*	5-|5-5当前层|
		****	第6行 有 4个*	5-|5-4当前层|
		***		第7行 有 3个*	5-|5-3当前层|
		**		第8行 有 2个*	5-|5-2当前层|
		*		第9行 有 1个*	5-|5-1当前层|

		3.打印整个 菱形
		*				第1行 有 1个*	 2 * (5-|5-1当前层|) - 1		第1行 有 4个空格  |5-当前层|
	   ***				第2行 有 3个*	 2 * (5-|5-2当前层|) - 1		第2行 有 3个空格  |5-当前层|
	  *****				第3行 有 5个*	 2 * (5-|5-3当前层|) - 1		第3行 有 2个空格  |5-当前层|
	 *******			第4行 有 7个*	 2 * (5-|5-4当前层|) - 1		第4行 有 1个空格	 |5-当前层|
	*********			第5行 有 9个*	 2 * (5-|5-5当前层|) - 1		第5行 有 0个空格  |5-当前层|
	 *******			第6行 有 7个*	 2 * (5-|5-6当前层|) - 1		第6行 有 1个空格  |5-当前层|
	  *****				第7行 有 5个*	 2 * (5-|5-7当前层|) - 1		第7行 有 2个空格  |5-当前层|
	   ***				第8行 有 3个*	 2 * (5-|5-8当前层|) - 1		第8行 有 3个空格  |5-当前层|
	    *				第9行 有 1个*	 2 * (5-|5-9当前层|) - 1		第9行 有 4个空格  |5-当前层|

		4.打印空心 菱形
		*				第1行 有 1个*	 当前行的第一个位置是*, 最后一个位置也是*
	   * *				第2行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	  *   *				第3行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	 *     *			第4行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	*       *			第5行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	 *     *			第6行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	  *   *				第7行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	   * *				第8行 有 2个*	 当前行的第一个位置是*, 最后一个位置也是*
	    *				第9行 有 1个*	 当前行的第一个位置是*, 最后一个位置也是*
		
		先死后活
		5.把层数做成变量 int totalLevel
		 */
		
		//代码实现
		int totalLevel = 34;
		for(int i = 1; i <= totalLevel; i++) {//表示层数

			//在输出每一行之前, 还需要打印对应的*个数
			for(int j = 1; j<= Math.abs(totalLevel / 2 - i); j++) {
				System.out.print(" ");
			}

			//控制打印*的个数
			for(int j = 1; j <= 2 * (totalLevel / 2 - Math.abs(totalLevel / 2-i)) - 1; j ++) {
				if(j == 1 || j == 2 * (totalLevel / 2 - Math.abs(totalLevel / 2-i)) - 1) {
					System.out.print("*");
				} else {
					System.out.print(" ");
				}
			}
			System.out.print("\n");
		}
	}
}

🐼break跳转控制语句

●需求
随机生成1-100的一个数, 直到生成了97这个数, 看看一共循环了几次?
提示使用 (int)(Math.random() * 100) + 1

public class Test {
   //编写一个main方法
   public static void main(String[] args) {
   	for(int i = 1; i <= 10; i++) {
           /*
               Math.random()                       [0,1)
               Math.random() * 100                 [0, 100)
               (int)(Math.random() * 100)          [0, 99]
               (int)(Math.random() * 100) + 1      [1, 100]
            */
           System.out.println((int)(Math.random() * 100) + 1);//[1,100]

       }
   }
}

思路分析: 循环, 但是循环的次数不知道 -> 引出break. 当某个条件满足时, 终止循环.
通过该需求可以说明其它流程控制的必要性, 比如break

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

●基本语法
{
···········
break
···········
}

●以while使用break为例, 画出示意图

●快速入门 Break01.java

public class Break01 {
    //编写一个main方法
    public static void main(String[] args) {
		for(int i = 1; i <= 10; i++) {
            if (i == 3) {
                break;
            }
            System.out.println("i=" + i);
        }

        System.out.println("退出for循环, 继续执行..");
    }
}

●注意事项和细节说明
1.break语句出现在多层嵌套的语句块中时, 可以通过标签指明要终止的是哪一层语句块
2.标签的基本使用
label1: {…
label2:        { …
label3:                { …
                            break label2;
                        .   …
                           }
                   }
            }

解读:
(1) break 语句可以指定退出哪层
(2) label1 是标签, 名字由程序员指定
(3) break后指定到哪个label 就退出到哪里
(4) 在实际的开发中, 建议: 尽量不要使用标签
(5) 如果没有指定 break, 默认退出最近的循环体

BreakDetail.java

public class BreakDetail {
    //编写一个main方法
    public static void main(String[] args) {
		zzw:
        for(int j = 0; j < 4; j++) {//外层for
            zzw2:
            for(int i = 0; i < 10; i++) {//内层for
                if(i == 2) {
                    break;//等价于 break zzw2;
                }
                System.out.println("i=" + i);
            }
        }
    }
}

public class BreakDetail {
    //编写一个main方法
    public static void main(String[] args) {
		zzw:
        for(int j = 0; j < 4; j++) {//外层for
            zzw2:
            for(int i = 0; i < 10; i++) {//内层for
                if(i == 2) {
                    // break;//等价于 break zzw2;
                    break zzw;
                }
                System.out.println("i=" + i);
            }
        }
    }
}

●课堂练习题
1.1-100以内的数求和, 求出 当 和 第一次大于20的当前数. [for+break] BreakExercise.java

import java.util.Scanner;

public class BreakExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //1-100以内的数求和, 
        //求出 当 和 第一次大于20的当前数. [for+break]

        //思路分析
        //1.循环1-100, 求和 sum
        //2.当 累积的和大于20时[sum > 20时], 记录下当前数, 操作完成让代码停止运行,退出,以节省资源
        //3.定义变量 n, 当累计和大于20时, 把当前数i赋给 n, 变量n的作用范围大

        //代码实现
        int sum = 0;
        int n = 0;
        for(int i = 0; i <= 100; i++) {
            sum += i;//累积求和
            if(sum > 20) {
                System.out.println("累积和大于20, 当前数为=" + i);
                n = i;
                break;//break, 当某个条件满足时, 终止循环. 常用于 for, whlie, do-while, switch
            }
        }
        System.out.println("当前数=" + n);
    }
}

2.实现登陆验证, 有3次机会, 如果用户名为"丁真", 密码"666"提示登陆成功, 否则提示还有几次机会, 请使用for+break完成 BreakExercise02 .java

import java.util.Scanner;

public class BreakExercise02 {
    //编写一个main方法
    public static void main(String[] args) {
         //实现登陆验证, 有3次机会, 如果用户名为"丁真", 密码"666"提示登陆成功, 
        //否则提示还有几次机会, 请使用for+break完成

        //思路分析
        //化繁为简, 先死后活
        //1.创建Scanner对象, 接收用户输入
        //2.定义 String username, String password, 保存用户名和密码
        //3.最多循环3次, 让用户输入 用户名 和 密码, 如果满足条件就提前退出
        //4.在外层循环外面定义一个变量 int chance, 记录还有几次登陆机会, 
        //  每循环一次, 执行chance--
        //5.当 用户名 和 密码 匹配时, 提示登陆成功, 然后break退出 for{}
        //  当 用户名 和 密码 不匹配时, 提示还有几次机会[输出chance] 
        
        //代码实现
        Scanner myScanner = new Scanner(System.in);
        String username = "";
        String password = "";
        int chance = 3;//每循环一次, 就执行chance--
        for(int i = 1; i <= 3; i++) {
            System.out.print("请输入用户名: ");
            username = myScanner.next();
            System.out.print("请输入密　码: ");
            password = myScanner.next();
            //比较
            if("丁真".equals(username) && "666".equals(password)) {
                System.out.println("登陆成功");
                break;//当条件满足时, 退出循环
            } else {
                chance--;
                System.out.println("用户名和密码不匹配, 你还有" + chance + "次机会");
            }
        }
    }
}

🐼continue跳转控制语句

●基本介绍
1.continue语句用于结束本次循环, 继续执行下一次循环

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

●基本语法
{
···········
continue
···········
}

●以while使用continue为例, 画出示意图

●快速入门 Continue01.java

public class Continue01 {
    //编写一个main方法
    public static void main(String[] args) {
        //代码
        int i = 1;
        while (i <= 4) {
            i++;
            if (i == 2) {
                continue;
            }
            System.out.println("i=" + i);
        }
    }
}

●细节案例分析和说明 ContinueDetail.java

public class ContinueDetail {
    //编写一个main方法
    public static void main(String[] args) {
        zzw1:
        for(int j = 0; j < 4; j++) {
            zzw2:
            for(int i = 0; i < 10; i++) {
                if(i == 2) {
                    continue;// 等价于 continue zzw2
                }
                System.out.println("i=" + i);//输出4次[0,1,3,4,5,6,7,8,9]
            }
        }
    }
}

public class ContinueDetail {
    //编写一个main方法
    public static void main(String[] args) {
        zzw1:
        for(int j = 0; j < 2; j++) {
            zzw2:
            for(int i = 0; i < 10; i++) {
                if(i == 2) {
                    // continue;// 等价于 continue zzw2
                    continue zzw1;
                }
                System.out.println("i=" + i);//输出2次[0,1,0,1]
            }
        }
    }
}

🐼return跳转控制语句

●介绍
return在方法中使用, 表示跳出所在的方法, 在学习方法的时候, 会进行学习. 这里简单地提一下.
注意: 如果 return 写在 main 方法, 退出程序…Return01.java

public class Return01 {
    //编写一个main方法
    public static void main(String[] args) {
        for(int i = 1; i <= 5; i++) {
            if(i == 3) {
                System.out.println("赵志伟love赵培竹" + i);
                break;
            }
            System.out.println("hello world");
        }
        System.out.println("go on...");
    }
}

public class Return01 {
    //编写一个main方法
    public static void main(String[] args) {
        for(int i = 1; i <= 5; i++) {
            if(i == 3) {
                System.out.println("赵志伟love赵培竹" + i);
                // break;
                continue;
            }
            System.out.println("hello world");
        }
        System.out.println("go on...");
    }
}

public class Return01 {
    //编写一个main方法
    public static void main(String[] args) {
        for(int i = 1; i <= 5; i++) {
            if(i == 3) {
                System.out.println("赵志伟love赵培竹" + i);
                return;//当return用在方法时, 表示跳出方法, 如果使用在main, 表示退出程序
            }
            System.out.println("hello world");
        }
        System.out.println("go on...");
    }
}

🐇第五章 · 课后作业

1.编程实现如下功能. Homework01.java
某人有100,000元, 每经过一次路口, 需要缴费. 规则如下
1)当现金 > 50000时, 每次交5%
2)当现金 <= 50000时, 每次交1000
编程计算该人可以经过多少次路口, 要求: 使用 while break方式完成

知识点:
1.money = money - money * 0.05 可以写成 money *= 0.95
2.else if(money >= 1000 && money <= 50000) 可以写成 else if(money >= 1000)

public class Homework01 {
    //编写一个main方法
    public static void main(String[] args) {
        /*
            某人有100,000元, 每经过一次路口, 需要缴费. 规则如下
            1)当现金 > 50000时, 每次交5%
            2)当现金 <= 50000时, 每次交1000
            编程计算该人可以经过多少次路口, 要求: 使用 while break方式完成

            思路分析 
            1.定义一个变量 double money 用来保存 100000
            2.根据题的要求, 分析出来有三种情况
              money > 50000
              money >= 1000 && money <= 50000
              money < 1000
            3.使用多分支 if-else if-else 来完成
            4.使用 while + break[当money < 1000]. 同时定义一个变量count用来统计次数
         */

        //代码实现
        double money = 100000;
        int count = 0;
        while (true) {//无限循环
            if (money > 50000) {//在50000以上
                // money = money * 0.95;
                money *= 0.95;
                count++;
            // && money <= 50000 可以不要
            } else if (money >= 1000) {//在1000-50000之间
                money -= 1000;
                count++;
            } else {//小于1000
                break;   
            }
        }
        System.out.println("100000 可以经过" + count + "次路口, 还剩" + money + "元");
    }
}

2.实现判断一个整数, 属于哪个范围: 大于0; 小于0; 等于0 Homework02.java

import java.util.Scanner;

public class Homework02 {
    //编写一个main方法
    public static void main(String[] args) {
        /*
        实现判断一个整数, 属于哪个范围: 大于0; 小于0; 等于0 

        思路分析:
        1.创建Scanner对象, 接收用户输入
        2.创建一个变量 int num
        3.使用分支 if-elseif-else 来完成
         */
        
        //代码实现
        Scanner myScanner = new Scanner(System.in);
        System.out.print("输入一个整数: ");
        int num = myScanner.nextInt();
        if (num > 0) {
            System.out.println("大于0");
        } else if (num == 0) {
            System.out.println("等于0");
        } else {
            System.out.println("小于0");
        }
    }
}

3.判断一个年份是否是闰年 Homework03.java

import java.util.Scanner;

public class Homework03 {
    //编写一个main方法
    public static void main(String[] args) {
        /*
        判断一个年份是否是闰年

        思路分析:
        1.创建Scanner对象, 接收用户输入
        2.创建一个变量 int year 保存年份
        3.闰年的条件是符合下面二者之一: (1)年份能被4整除, 但不能被100整除; (2)能被400整除
        4.年份能被4整除, 但不能被100整除 (year % 4 == 0 && year % 100 != 0)
        5.能被400整除 (year % 400 == 0)
        6.上面的 4 和 5 是 或 的关系
         */
        
        //代码实现
        Scanner myScanner = new Scanner(System.in);
        System.out.print("输入一个年份: ");
        int year = myScanner.nextInt();
        if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            System.out.println(year + "是闰年");
        } else {
            System.out.println(year + "不是闰年");
        }
    }
}

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

import java.util.Scanner;

public class Homework04 {
    //编写一个main方法
    public static void main(String[] args) {
        /*
        判断一个整数是否是水仙花数, 
        所谓水仙花数是指一个3位数, 其各个位上的数的立方和等于其本身. 
        例如: 153 = 1\*1\*1 + 5\*5\*5 + 3\*3\*3 

        思路分析:
        1.创建Scanner对象, 接收用户输入
        2.创建一个变量 int n 保存一个3位数的整数
        3.先得到 n 的个位, 十位, 百位的数字, 使用 if 判断它们的立方和是否相等
          得到整数n 个位 上的数  n % 10
          得到整数n 十位 上的数  n % 100 / 10
          得到整数n 百位 上的数  n / 100
        4.使用 if 判断它们的立方和

        补充: Math.pow(10, 3) 意思为 10的3次方
         */
        
        //代码实现
        Scanner myScanner = new Scanner(System.in);
        System.out.print("输入3位的整数: ");
        int n = myScanner.nextInt();
        int geWei = n % 10;
        int shiWei = n % 100 / 10;
        int baiWei = n / 100;
        if (Math.pow(geWei, 3) + Math.pow(shiWei, 3) + Math.pow(baiWei, 3) == n) {
            System.out.println(n + "是水仙花数");
        } else {
            System.out.println(n + "不是水仙花数");
        }
    }
}

5.看看下面的代码输出什么?
答: 什么都不输出

class Demo {
    public static void main(String[] args) {
        int m = 0, n = 3;
        if (m > 0) {
            if (n > 2) {
                System.out.println("ok1");
            } else {
                System.out.println("ok2");
            }
        }
    }
}

6.输出1-100之间的不能被5整除的数, 每5个一行 Homework06.java

import java.util.Scanner;

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 + " ");
                //判断, 每满5个, 就输出换行
                if (count % 5 == 0) {
                    System.out.println("");
                }
            }
        }
    }
} 

7.输出小写的a-z以及大写的A-Z Homework07.java

public class Homework07 {
    //编写一个main方法
    public static void main(String[] args) {
       /*
        输出小写的a-z以及大写的A-Z
        考察我们对 a-z 编码和 for的综合使用

        思路分析
        1.字符类型本质是一个数字, 例如 'a' 对应 97
        2.字符'a' 可以通过 +1 得到 字符'b'
          'b' = 'a' + 1; 'c' = 'b' + 1;
        3.使用for完成
        */
       
       //代码实现
       for(char c1 = 'a'; c1 <= 'z'; c1++) {
        System.out.print(c1 + " ");
       }
       System.out.println();
       for(int c2 = 'A'; c2 <= 'Z'; c2++) {
        System.out.print((char)c2 + " ");
        }
    } 
}

8.求出 1-1/2 + 1/3 - 1/4 … 1/100的和. Homework08.java

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);
    } 
}

9.求出 1+(1 + 2) + (1 + 2 + 3) + (1 + 2 + 3 + 4) + … + (1 + 2 + 3 + … + 100)的结果. Homework09.java

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. 从上面的分析可以看到
          (1) 一共有100项 相加
          (2) 每一项的数字在逐渐地增加
              第1项 为 1
              第2项 为 1 + 2
              第3项 为 1 + 2 + 3
              第4项 为 1 + 2 + 3 + 4
              第i项 为 1 + 2 + 3 + 4 +...+ i [i >= 1 && i <= 100]			
          (3) 很像一个双层for循环
        2. i 可以表示第几项, 同时也是当前项的最后一个数
        3. 将累计结果放到 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);
    } 
}