文章目录
本章重点
本章难题
🔥程序流程控制介绍
在程序中, 程序运行的流程控制决定程序是如何执行的, 主要有三大流程控制语句
- 顺序控制
- 分支控制
- 循环控制
🐇顺序控制
●顺序控制介绍
程序从上到下逐行地执行, 中间没有任何判断和跳转
●顺序控制举例和注意事项
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);
}
}