1. 关系运算符
1.1 概述
关系运算符就是用来描述两个变量或者常量之间的关系的.主要分为以下6种:
|
符号 |
说明 |
|
== |
a==b，判断a和b的值是否相等，成立为true，不成立为false |
|
!= |
a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
|
> |
a>b，判断a是否大于b，成立为true，不成立为false |
|
>= |
a>=b，判断a是否大于等于b，成立为true，不成立为false |
|
< |
a<b，判断a是否小于b，成立为true，不成立为false |
|
<= |
a<=b，判断a是否小于等于b，成立为true，不成立为false |
1.2 注意事项
- 关系运算符的结果都是boolean类型，要么是true，要么是false。
- 千万不要把==写成了=, 否则结果可能不是你想要的.
1.3 案例
需求
定义两个int类型的变量a和b, 分别赋值为10和5.
通过关系运算符比较这两个变量之间的关系, 并打印结果.
参考代码
public class OperatorDemo01 {
public static void main(String[] args) {
//定义两个int类型的变量a和b, 分别赋值为10和5.
int a = 10;
int b = 5;
//通过`关系运算符`比较这两个变量之间的关系, 并打印结果.
System.out.println(a > b);
System.out.println(5 >= 5);
System.out.println(a < b);
System.out.println(5 <= 5);
System.out.println(a != b);
System.out.println(a == b);
System.out.println(a = b);
//关系运算符的最终结果是boolean类型, 所以我们也可以用boolean类型的变量接收.
boolean flag = 10 < 5;
System.out.println(flag);
}
}
2. 逻辑运算符
2.1 概述
- 逻辑运算符是用来判断并且, 或者, 除非等逻辑关系的符号.
- 该符号两端一般连接值为布尔类型的关系表达式
例如: 某企业招工, 要求年龄必须在 20 ~ 65岁之间.
2.2 分类
注意: 假设下表中的a和b, 都是boolean类型的值.
|
符号 |
作用 |
说明 |
|
& |
逻辑与 |
a&b，并且的意思. 有false则整体为false, 都为true, 则整体为true. |
|
| |
逻辑或 |
a|b，或者的意思, 有true则整体为true, 都为false, 则整体为false. |
|
! |
逻辑非 |
!a，取反的意思, 以前为true, 取反后为false, 以前为false, 取反后为true. |
|
^ |
逻辑异或 |
a^b，异同的意思, 相同为false, 不同为true. |
小技巧:
对一个布尔数据, 偶数次取反, 该数据值不变.
!true = false
2.3 示例: 逻辑运算符入门
需求
定义三个int类型的变量a, b, c, 它们的初始化值分别为10, 20, 30.
通过上述的三个变量, 演示各个逻辑运算符.
参考代码
public class OperatorDemo02 {
public static void main(String[] args) {
int a = 10, b = 20, c = 30;
//&: 逻辑与, 并且的意思, 有false则整体为false.
//相当于: 班长找女朋友, 要求长得漂亮, 并且身材好.
System.out.println((a > b) & (a > c)); //false & false
System.out.println((a < b) & (a > c)); //true & false
System.out.println((a > b) & (a < c)); //false & true
System.out.println((a < b) & (a < c)); //true & true
System.out.println("-----------------");
//|: 逻辑或, 或者的意思, 有true则整体为true.
//相当于: 降低条件了, 要么长得漂亮, 要么身材好.
System.out.println((a > b) | (a > c)); //false | false
System.out.println((a < b) | (a > c)); //true | false
System.out.println((a > b) | (a < c)); //false | true
System.out.println((a < b) | (a < c)); //true | true
System.out.println("-----------------");
//!: 逻辑非, 取反的意思
//相当于: 只要不是男的就行.
System.out.println(!(a > b)); //!false
System.out.println(!(a < b)); //!true
System.out.println("-----------------");
//逻辑异或, 异同的意思, 相同为false, 不同为true.
//相当于: 最后还是找了个男的, 但是领不了证.
//法律规定: 一夫一妻, 一男一女, 必须是异性才能领证.
System.out.println((a > b) ^ (a > c)); //false ^ false
System.out.println((a < b) ^ (a > c)); //true ^ false
System.out.println((a > b) ^ (a < c)); //false ^ true
System.out.println((a < b) ^ (a < c)); //true ^ true
}
}
2.4 短路逻辑运算符
在实际开发中, 并且, 或者这样的操作是非常多的, 但是上述的&(逻辑与), !(逻辑或)运算符没有短路效应, 所以效率相对较低, 针对这种情况, 我们可以使用&&(短路与), ||(短路或)来优化.
2.4.1 格式
|
符号 |
作用 |
说明 |
|
&& |
短路与 |
作用和&相同，但是有短路效果, 前边出现false, 后边不执行. |
|
|| |
短路或 |
作用和|相同，但是有短路效果, 前边出现true, 后边不执行. |
2.4.2 解释
- 在短路与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与运算符就有这样的效果，可以提高效率。
- 同理在短路或运算中，一旦发现值为true，右边的表达式将不再参与运算。
- 逻辑与 和 短路与之间的区别
2.4.3 短路和非短路之间的区别
– 逻辑与&(也叫单与): 无论左边真假，右边都要执行。
– 短路与&&(也叫双与): 如果左边为真，右边执行；如果左边为假，右边不执行。
- 逻辑或 和 短路或之间的区别
– 逻辑或|(也叫单或): 无论左边真假，右边都要执行。
– 短路或||(也叫双或): 如果左边为假，右边执行；如果左边为真，右边不执行。
- 记忆: 在实际开发中, 我们用的最多的逻辑运算符就是: &&, ||, !
2.4.4 案例
需求
参考代码
public class OperatorDemo03 {
public static void main(String[] args) {
//1. 定义两个int类型的变量a和b, 初始化值分别为: 2, 5
int a = 2, b = 5;
//2. 演示逻辑与(&)
/* System.out.println((a++ > 2) & (b++ < 7)); //两个表达式都会执行.
System.out.println(a);
System.out.println(b);*/
System.out.println("------------------");
//3. 演示短路与(&&)
System.out.println((a++ > 2) && (b++ < 7)); //左边表达式结果为false, 右边不执行.
System.out.println(a);
System.out.println(b);
}
}
3. 三元运算符
3.1 格式
三元运算符也叫三目运算符，即由三部分组成，格式如下：
(关系表达式) ? 表达式1：表达式2；
3.2 执行流程
先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行表达式1
如果是false, 则执行表达式2
3.3 案例一: 入门案例
需求
定义两个int类型的变量a. b, 初始化值分别为10, 20
通过三元运算符, 获取变量a和b的最大值.
将结果(最大值)打印到控制台上.
参考代码
public class OperatorDemo04 {
public static void main(String[] args) {
//1. 定义两个int类型的变量a. b, 初始化值分别为10, 20
int a = 10, b = 20;
//2. 通过三元运算符, 获取变量a和b的最大值.
int max = a < b ? b : a;
//3. 将结果(最大值)打印到控制台上.
System.out.println(max);
}
}
3.4 案例二: 判断老虎体重
需求
动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
参考代码
public class OperatorDemo05 {
public static void main(String[] args) {
//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
int weight1 = 180;
int weight2 = 200;
//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
boolean flag = weight1 == weight2 ? true : false;
//3：输出结果
System.out.println("flag:" + flag);
}
}
3.5 案例三: 获取和尚的最高身高
需求
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm.
请用程序实现获取这三个和尚的最高身高。
参考代码
public class OperatorDemo06 {
public static void main(String[] args) {
//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
int h1 = 150;
int h2 = 210;
int h3 = 165;
//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
int temp = h1 > h2 ? h1 : h2;
//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
int max = temp > h3 ? temp : h3;
//4：输出结果
System.out.println("这三个和尚中身高最高的是：" + max +"cm");
}
}
4. 键盘录入
4.1 概述
之前我们涉及到的数据都是写死的, 固定的数据, 这样做用户体验并不好, 我们就想着, 能不能让用户录入数据, 我们通过特定的代码来接收, 这样做就非常好玩儿了, 针对于这种情况, 我们可以通过键盘录入来实现.
即: Java中键盘录入功能指的就是Scanner类, 我们可以通过它的一 些方法, 来获取用户录入的数据.
4.2 使用步骤
导包. 包就是文件夹.
注意:
– Scanner类是java.util包下的类, 使用之前必须要先导包.
– 导包的语句是定义在类的上面的, 格式如下:
import java.util.Scanner;
创建Scanner类的对象, 格式为:
//暂时先理解为固定格式, 也就是必须这么写.
Scanner sc = new Scanner(System.in);
通过Scanner类的nextInt()方法接收用户录入的数据.
int a = sc.nextInt();
4.3 案例一: Scanner入门
需求
提示用户录入他/她的年龄.
通过键盘录入功能, 接收用户录入的年龄.
将用户录入的数据(年龄)打印到控制台上.
参考代码
//导包
import java.util.Scanner;
public class ScannerDemo01 {
public static void main(String[] args) {
//1. 提示用户录入他/她的年龄.
System.out.println("请录入您的年龄: ");
//2. 通过键盘录入功能, 接收用户录入的年龄.
Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
//3. 将用户录入的数据(年龄)打印到控制台上.
System.out.println("age: " + age);
}
}
4.4 案例二: 键盘录入版和尚身高
需求
提示用户录入第一个和尚的身高, 并接收
提示用户录入第二个和尚的身高, 并接收
提示用户录入第三个和尚的身高, 并接收.
通过三元运算符, 获取三个和尚中身高最矮的那个和尚的身高.
将结果(最低身高)打印到控制台上.
参考代码
import java.util.Scanner;
public class ScannerDemo02 {
public static void main(String[] args) {
//身高未知，采用键盘录入实现。首先导包，然后创建对象。
Scanner sc = new Scanner(System.in);
//键盘录入三个身高分别赋值给三个变量。
System.out.println("请输入第一个和尚的身高：");
int h1 = sc.nextInt();
System.out.println("请输入第二个和尚的身高：");
int h2 = sc.nextInt();
System.out.println("请输入第三个和尚的身高：");
int h3 = sc.nextInt();
//用三元运算符获取前两个和尚的较低身高值，并用临时身高变量保存起来。
int temp = h1 < h2 ? h1 : h2;
//用三元运算符获取临时身高值和第三个和尚身高较低值，并用最低身高变量保存。
int min = temp < h3 ? temp : h3;
//输出结果。
System.out.println("这三个和尚中身高最低的是：" + min +"cm");
}
}
5. 练习
需求
- 提示用户键盘录入一个三位数, 并接收.
- 求这个数的个位,十位,百位分别是多少.
- 并将结果打印到控制台上.
参考代码
import java.util.Scanner;
//定义一个类, 类名叫: ExerciseDemo01
public class ExerciseDemo01 {
//定义main方法, 作为程序的主入口.
public static void main(String[] args) {
//1. 创建Scanner对象, 用户接受用户录入的数据.
Scanner sc = new Scanner(System.in);
//2. 提示用户录入一个三位数, 并接收.
System.out.println("请录入一个100 - 999 之间的整数: ");
int num = sc.nextInt();
//3. 获取该三位数的各个位数上的数字.
int ge = num % 10;
int shi = num / 10 % 10;
int bai = num / 100 % 10;
//4. 打印结果.
System.out.println(num + "的百位数字是: " + bai + ", 十位数字是: " + shi + ", 个位数字是: " + ge);
}
}
6. 流程控制
6.1 概述
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
例如: 某些代码是满足特定条件的情况下, 才会被执行. 而有些代码, 在满足某些条件的情况下, 需要重复执行, 这些, 都需要用到流程控制语句.
6.2 分类
- 顺序结构
- 选择结构(if语句, switch.case语句)
- 循环结构(for循环, while循环, do.while循环)
6.3 顺序结构
概述
顺序结构指的是代码是按照从上往下, 从左往右的顺序, 依次逐行执行的, 且顺序结构也是Java程序的默认结构.
图解
需求
定义类OrderDemo01, 在类中定义main方法, 打印如下数据:
//start
//HelloWorld1
//HelloWorld2
//HelloWorld3
//end
参考代码
public class OrderDemo01 {
public static void main(String[] args) {
//打印指定的数据
System.out.println("start");
System.out.println("HelloWorld1");
System.out.println("HelloWorld2");
System.out.println("HelloWorld13");
System.out.println("end");
}
}
7. 选择结构之if语句
7.1 概述
如果我们想某些代码是在满足条件的情况下, 才能被执行, 此时就需要用到选择结构了, 选择结构也叫分支结构, 主要分为以下两种:
- if语句
- switch.case语句
7.2 分类
if语句一般用于范围的判断, 例如: 如果当前时间是0~8点, 小黑就和你说: 早上好, 如果当前时间是9 ~12点, 小黑就和你说: 中午好. 根据应用场景的不同(即: 分支个数不同), if语句的格式主要分为以下三种:
if语句(也叫: 单分支)
if.else语句(也叫: 双分支)
if.else if语句(也叫: 多分支)
7.3 单分支
单分支结构一般用来判断一种情况, 格式如下:
格式
if(关系表达式) {
//语句体;
}
执行流程
先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行大括号中的语句体.
如果是false, 则大括号中的语句体不执行.
图解
需求
定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则不操作.
解释: [0, 8], 意思是说 0~8之间, 包含0, 也包含8, 这种写法属于"前闭后闭".
[0, 8), 意思是: 0~8之间, 包含0, 不包含8, 这种写法属于"前闭后开", 也叫: 包左不包右.
参考代码
public class IfDemo01 {
public static void main(String[] args) {
int time = 5;
if(time >= 0 && time <= 8) {
System.out.println("早上好");
}
}
}
7.4 双分支
双分支结构指的是if. else语句, 一般用来判断两种情况, 格式如下:
7.4.1 格式
if(关系表达式) { //if的意思: 如果
//语句体1;
} else { //否则...
//语句体2;
}
7.4.2 执行流程
先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行语句体1.
如果是false, 则执行语句体2.
7.4.3 图解
7.4.5 案例一: if格式二入门
需求
定义变量time表示时间, 如果它的范围是在0~8之间, 就打印早上好, 否则就打印中午好.
参考代码
public class IfDemo02 {
public static void main(String[] args) {
int time = 5;
if(time >= 0 && time <= 8) {
System.out.println("早上好");
} else {
System.out.println("中午好");
}
}
}
7.4.6 案例二: 判断奇偶数
需求
提示用户键盘录入一个数据并接收.
判断该数据是奇数还是偶数, 并将结果打印到控制台上.
参考代码
public class IfDemo03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数: ");
int num = sc.nextInt();
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
}
}
记忆
if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写.
例如:
if(5 > 3)
System.out.println("夯哥最纯洁!");
if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写, 定义变量的语法除外.
例如:
if(5 > 3)
int a = 10; //这样写会报错, jvm会识别这样代码为两行: int a; a = 10;
上述的代码就相当于:
if(5 > 3) {
int a;
}
a = 10; //这样写肯定会报错.
你省略if后边的大括号时, 有个问题一定要注意, 不要乱写分号.
例如:
if(5 > 3) ; //这里如果写分号了, 就意味着if语句结束了.
System.out.println("本意: 这行代码只有条件成立才会被执行");
7.5 多分支
多分支结构指的是if. else if语句, 一般用来判断多种情况, 格式如下:
7.5.1 格式
if(关系表达式1) {
//语句体1;
} else if(关系表达式2){
//语句体2;
} else if(关系表达式3){ //这里可以根据需求, 有多个else if语句
//语句体3;
} else {
//语句体n;
}
7.5.2 执行流程
先执行关系表达式1, 看其结果是true还是false.
如果是true, 则执行语句体1, 整个if语句结束.
如果是false, 则判断关系表达式2, 看其结果是true还是false.
如果是true, 则执行语句体2, 整个if语句结束.
如果是false, 则判断关系表达式3, ...以此类推.
如果所有的关系表达式都不成立, 则执行else语句的语句体n, 整个if语句结束.
7.5.3 图解
7.5.4 案例一: 打印星期
需求
提示用户录入[1, 7]之间的数字, 并接收.
根据用户录入的数字, 打印对应的星期, 格式如下:
– 用户录入1, 打印"星期一"
– 用户录入2, 打印"星期二"
– ...以此类推
– 用户录入非法数字, 打印"没有这样的日期"
参考代码
import java.util.Scanner;
public class IfDemo04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个1 - 7之间的整数: ");
int week = sc.nextInt();
if (week == 1) {
} else if(week == 2) {
System.out.println("星期二");
} else if(week == 3) {
System.out.println("星期三");
} else if(week == 4) {
System.out.println("星期四");
} else if(week == 5) {
System.out.println("星期五");
} else if(week == 6) {
System.out.println("星期六");
} else if(week == 7) {
System.out.println("星期日");
} else {
System.out.println("没有这样的日期, 你是从火星来的吧!");
}
}
}
7.5.5 案例二: 发放奖励
需求
小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
礼物标准如下:
– 95~100 山地自行车一辆
– 90~94 游乐场玩一次
– 80~89 变形金刚玩具一个
– 80以下 胖揍一顿
参考代码
import java.util.Scanner;
public class IfDemo05 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入小明的考试成绩: ");
int score = sc.nextInt();
if (score >= 95 && score <= 100) {
System.out.println("奖励小明: 山地自行车一辆");
} else if(score >= 90 && score < 95) {
System.out.println("奖励小明: 游乐场玩儿一次");
} else if(score >= 80 && score < 90) {
System.out.println("奖励小明: 变形金刚玩具一个");
} else if(score >= 0 && score < 80){
System.out.println("奖励小明: 男女双混组合拳 + 扫帚棒法");
} else {
System.out.println("考试成绩录入有误.");
}
}
}
7.5.6 案例三: 获取最大值
需求
提示用户录入3个整数, 并接收.
通过if语句获取这三个整数的最大值.
将结果打印到控制台上.
参考代码
import java.util.Scanner;
public class IfDemo06 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入第一个整数: ");
int a = sc.nextInt();
System.out.println("请录入第二个整数: ");
int b = sc.nextInt();
System.out.println("请录入第三个整数: ");
int c = sc.nextInt();
//方式一: if嵌套实现.
int max = a;
int max2 = a;
if (a > b) {
if (a > c) {
max = a;
} else {
max = c;
}
} else {
if(b > c) {
max = b;
} else {
max = c;
}
}
System.out.println("最大值: " + max);
//方式二: if. else.if语句实现
if (a > b && a > c) {
max2 = a;
} else if(b > a && b > c) {
max2 = b;
} else {
max2 = c;
}
System.out.println("最大值: " + max2);
}
}
8. 选择结构之switch语句
8.1 概述
switch语句, 一般是用于做固定值判断的, 在实际开发中, 用到的频率也非常高, 所以也是要求大家掌握的知识点.
8.2 格式
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
... //根据需求, 可以写多组case.
default:
语句体n;
break;
}
8.3 格式详解
8.4 执行流程
先计算表达式的值, 然后按照从上往下的顺序依次和每一个case对应的值相匹配.
如果能匹配成功, 则执行该case对应的语句体, 然后执行break, 至此, 整个switch语句结束.
如果和所有的case值都不匹配, 则执行default对应的语句体, 然后执行break, 至此, 整个switch语句结束.
解释: default语句就类似于if. else语句中的else, 当所有条件都不满足时才会执行.
8.5 执行流程图解
8.6 示例一: 春夏秋冬
需求
一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。
具体标准如下:
– 输入： 1、2、12 输出：冬季
– 输入： 3、4、5 输出：春季
– 输入： 6、7、8 输出：夏季
– 输入： 9、10、11 输出：秋季
– 输入：其它数字 输出：数字有误
参考代码
import java.util.Scanner;
public class SwitchDemo07 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个月份: ");
int month = sc.nextInt();
switch (month) {
case 12:
System.out.println("冬季");
break;
case 1:
System.out.println("冬季");
break;
case 2:
System.out.println("冬季");
break;
case 3:
System.out.println("春季");
break;
case 4:
System.out.println("春季");
break;
case 5:
System.out.println("春季");
break;
case 6:
System.out.println("夏季");
break;
case 7:
System.out.println("夏季");
break;
case 8:
System.out.println("夏季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("秋季");
break;
case 11:
System.out.println("秋季");
break;
default:
System.out.println("没有这样的日期");
break;
}
}
}
8.7 case穿透
概述
在switch语句中，如果case的后面不写break，将出现case穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
格式
switch(表达式) {
case 值1:
语句体1; //假设表达式的值 = 值1, 则执行完语句体1后, 不会判断第二个case, 直接执行语句体2;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
... //根据需求, 可以写多组case.
default:
语句体n;
break;
}
需求 通过case穿透, 优化刚才的春夏秋冬案例.
参考代码
import java.util.Scanner;
public class SwitchDemo08 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个月份: ");
int month = sc.nextInt();
switch (month) {
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
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;
default:
System.out.println("没有这样的日期");
break;
}
}
}
8.8 思考题
switch语句的小括号中, 可以放什么?
default语句必须放到switch语句的最后吗?
break关键字可以省略吗? 对执行结果是否有影响?
8.9 案例二: 发放奖励
需求
小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
礼物标准如下:
– 90~100 山地自行车一辆
– 80~89 游乐场玩一次
– 70~79 变形金刚玩具一个
– 70以下 胖揍一顿
参考代码
import java.util.Scanner;
public class SwitchDemo09 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入小明的考试成绩: ");
int score = sc.nextInt();
if (score >= 0 && score <= 100) {
//合法成绩
switch (score / 10) {
case 10:
case 9:
System.out.println("奖励小明: 山地自行车一辆");
break;
case 8:
System.out.println("奖励小明: 游乐场玩儿一次");
break;
case 7:
System.out.println("奖励小明: 变形金刚玩具一个");
break;
default:
System.out.println("奖励小明: 男女双混组合拳 + 扫帚棒法");
break;
}
} else {
//非法成绩
System.out.println("您录入的成绩有误!");
}
}
}
9. 循环结构
9.1 概述
循环，即事物周而复始的变化。循环结构指的是，使一部分代码按照次数或一定的条件反复执行的一种代码结构. 有些时候, 我们想代码是在满足某些条件的情况下, 重复(循环)执行的, 就需要用到循环结构了.
例如: 打印100次HelloWorld. 如果不用循环实现的话, 输出语句我们就需要写100次, 我们发现这样做是非常繁琐的. 于是, 我们可以通过循环来优化它.
9.2 组成
初始化条件.
假设用int类型的变量x记录循环次数,x从1开始数, 数到100刚好100次, 1在这里充当的角色就是: 初始化条件.
判断条件.
变量x从1开始数, 数到100结束. 即: x <= 100, 这就是判断条件, 用来决定循环是否继续执行的.
控制条件.
用来控制变量x变化的. 每循环一次, 变量x的值+1. 即: x++就是控制条件.
循环体.
指的是需要重复执行的代码, 例如: System.out.println("Hello World!");
9.3 分类
- for循环
一般适用于循环次数固定的情况.
- while循环
一般适用于循环次数不固定的情况.
- do.while循环
我们在实际开发中, 基本不用. 适用于先执行一次, 然后判断的情况.
10. for循环
for循环是我们在实际开发中应用到的最多的循环, 它一般适用于循环次数固定的情况.
10.1 格式
for(初始化条件1; 判断条件2; 控制条件3) {
//循环体4;
}
解释:
初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
循环体: 需要用来重复做的事情(代码).
10.2 执行流程
先执行初始化条件.
然后执行判断条件, 看其结果是true, 还是false.
如果是false, 则整个循环结束.
如果是true, 则执行循环体.
执行控制条件.
返回第2步, 继续往下重复执行.
简单理解:
第一次执行: 1, 2, 4, 3. 假设判断条件成立.
重复执行: 2, 4, 3.
最后一次执行: 2 判断条件不成立, 循环结束.
10.3 图解
10.4 案例一: for循环入门
需求 通过for循环, 打印10次"Hello World!".
参考代码
//需求: 打印10次HelloWorld
public class ForDemo01 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println("Hello World!");
}
}
}
10.5 案例二: 打印数字
需求
通过for循环, 打印1~5之间的数字.
通过for循环, 打印5~1之间的数字.
参考代码
public class ForDemo02 {
public static void main(String[] args) {
//1. 通过for循环, 打印1~5之间的数字.
for (int i = 1; i <= 5 ; i++) {
System.out.println(i);
}
System.out.println("--------------");
//2. 通过for循环, 打印5~1之间的数字.
//ritar
for (int i = 5; i >= 1; i--) {
System.out.println(i);
}
}
}
10.6 案例三: 求和案例
需求
通过for循环, 获取1 ~ 5之间的数字之和.
参考代码
public class ForDemo03 {
public static void main(String[] args) {
//1. 定义变量sum, 用来记录数据和.
int sum = 0;
//2. 通过for循环, 依次获取到1~5之间的数字.
for (int i = 1; i <= 5; i++) {
//3. 将获取到的数字, 累加给变量sum.
sum += i;
}
System.out.println("1 - 5之间的数字之和是: " + sum);
}
}
细节: 求和变量必须定义到for循环的外边, 如果定义到for循环的内容, 则每次循环都会被重置.
10.7 案例四: 求偶数和
需求 求1-100之间的偶数和，并把求和结果打印到控制台上.
参考代码
public class ForDemo04 {
public static void main(String[] args) {
//1. 定义变量sum, 用来记录数据和.
int sum = 0;
//2. 通过for循环, 依次获取到1 - 100之间的数字.
for (int i = 1; i <= 100; i++) {
//3. 判断当前遍历到的数字是否是偶数.
if (i % 2 == 0) {
//4. 走到这里, 说明是偶数, 累加给变量sum.
sum += i;
}
}
//5. 打印结果.
System.out.println("1 - 100之间的偶数之和是: " + sum);
}
}
10.8 案例五: 获取水仙花数
需求
获取到所有的水仙花数, 并将结果打印到控制台上.
解释:
水仙花数是一个3位数的整数.
该数字的各个位数立方和相加等于它本身.
例如: 153就是水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 153
参考代码
public class ForDemo05 {
public static void main(String[] args) {
int ge, shi, bai;
for (int i = 100; i < 1000; i++) {
ge = i / 1 % 10;
shi = i / 10 % 10;
bai = i / 100 % 10;
if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai)
System.out.println(i);
}
}
}
10.9 案例六: 计数思想
需求
统计所有水仙花数的个数, 并将其打印到控制台上.
参考代码
public class ForDemo06 {
public static void main(String[] args) {
int ge, shi, bai,count = 0;
for (int i = 100; i < 1000; i++) {
ge = i / 1 % 10;
shi = i / 10 % 10;
bai = i / 100 % 10;
if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai)
count++;
}
System.out.println("水仙花数的个数为: " + count);
}
}
11. while循环
while循环也是我们在实际开发中应用到的比较多的循环, 它一般适用于循环次数不固定的情况.
11.1 格式
初始化条件1;
while(判断条件2) {
//循环体3;
//控制条件4;
}
解释:
初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
循环体: 需要用来重复做的事情(代码).
11.2 执行流程
先执行初始化条件.
然后执行判断条件, 看其结果是true, 还是false.
如果是false, 则整个循环结束.
如果是true, 则执行循环体.
执行控制条件.
返回第2步, 继续往下重复执行.
简单理解:
第一次执行: 1, 2, 3, 4. 假设判断条件成立.
重复执行: 2, 3, 4.
最后一次执行: 2 判断条件不成立, 循环结束.
11.3 图解
11.4 案例一: while循环入门
需求
在控制台打印10次HelloWorld.
参考代码
public class WhileDemo01 {
public static void main(String[] args) {
int i = 0;
while(i < 10) {
System.out.println("Hello World!");
i++;
}
}
}
11.5 案例二: 求和
需求
获取1~100之间所有偶数和, 并将结果打印到控制台上.
参考代码
//需求: 获取1 - 100之间的偶数和.
public class WhileDemo02 {
public static void main(String[] args) {
int sum = 0;
int i = 1;
while (i <= 100) {
if (i % 2 == 0)
sum += i;
i++;
}
System.out.println("1-100之间的偶数和为: " + sum);
}
}
11.6 案例三: 珠穆朗玛峰
需求
已知世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米).
假如我有一张足够大的纸，它的厚度是0.1毫米.
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
即: 纸张的厚度 >= 珠穆朗玛峰的高度
参考代码
//案例: 珠穆朗玛峰
public class WhileDemo03 {
public static void main(String[] args) {
//1. 定义变量, 记录纸张的厚度.
double paper = 0.1;
//2. 定义变量, 记录珠峰的高度.
int zf = 8844430;
//3. 定义变量, 记录纸张的折叠次数.
int count = 0;
//4. 通过while循环实现, 获取折叠次数.
while (paper < zf) {
paper *= 2;
count++;
}
//5. 打印结果.
System.out.println("折叠次数为: " + count);
}
}
12. do.while循环
do.while循环在实际开发中应用到的并不是特别多, 所以我们简单的了解下它的用法即可.
12.1 格式
初始化条件;
do {
循环体;
控制条件;
} while(判断条件);
解释:
初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.
判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.
控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.
循环体: 需要用来重复做的事情(代码).
12.2 执行流程
先执行初始化条件.
再执行循环体.
再执行控制条件.
执行判断条件, 看其结果是true还是false.
如果是false, 则整个循环结束.
如果是true, 则返回第2步重复往下执行.
简单理解:
第一次执行: 1, 2, 3, 4. 假设判断条件成立.
重复执行: 2, 3, 4.
最后一次执行: 2 判断条件不成立, 循环结束.
12.3 图解
12.4 案例: 打印HelloWorld
需求 通过do.while循环, 在控制台打印10次Hello World!
参考代码
public class DoWhileDemo01 {
public static void main(String[] args) {
int i = 1;
do{
System.out.println("Hello World! " + i);
i++;
}while(i <= 10);
}
}
13. 循环扩展
13.1 三种循环之间的区别
do.while循环和其他两个循环之间的区别
– do.while循环是先执行一次, 后判断.
– 而其他两个循环都是先执行判断条件, 然后决定是否执行循环体.
for循环和其他两个循环之间的区别
– for循环执行结束后, 初始化条件就不能继续使用了.
– 而其他两个循环执行结束后, 初始化条件还可以继续使用.
13.2 死循环
13.2.1 概述
所谓的死循环指的是永不会结束的循环, 也就是循环的判断条件永远为true,
在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。
13.2.2 分类
在Java中, 死循环的写法格式主要有以下3种:
- for(;;) { }
- while(true){ }
- do { } while(true)
13.2.3 参考代码
public class DeadLoop {
public static void main(String[] args) {
/*for(;;) {
System.out.println("Hello World!");
}*/
/*while(true) {
System.out.println("Hello World!");
}*/
do {
System.out.println("Hello World!");
} while(true);
}
}
14. 循环跳转
14.1 概述
有些时候, 我们想提前终止循环的执行, 或者跳过循环的某一次执行, 例如: 打印1~10之间, 所有不是3倍数的数字, 或者采用死循环让用户不断的录入他/她的账号和密码, 直到用户录入正确, 再终止循环. 这些都要用到循环控制跳转知识点.
14.2 分类
- break: 是用来终止循环的, 循环不再继续执行.
- continue: 用来结束本次循环, 进行下一次循环的, 循环还会继续执行.
14.3 案例一: break入门
需求 打印10次HelloWorld, 当打印第五次的时候, 结束循环.
参考代码
//案例: 打印10次`HelloWorld`, 当打印第五次的时候, 结束循环.
public class BreakDemo01 {
public static void main(String[] args) {
System.out.println("start");
//1. 定义for循环, 打印10次HelloWorld
for (int i = 1; i <= 10 ; i++) {
//2.当i等于5的时候, 结束循环
if (i == 5)
break;
System.out.println("Hello World! " + i);
}
System.out.println("end");
}
}
图解
14.4 案例二: continue入门
需求
打印1~10之间, 所有不是3倍数的整数.
参考代码
//案例; 打印1~10之间, 所有不是3倍数的整数.
public class ContinueDemo02 {
public static void main(String[] args) {
System.out.println("start");
//1. 通过for循环, 获取1 - 10之间所有的整数
for (int i = 1; i <= 10; i++) {
//2. 判断该数字是否是3的倍数.
if (i % 3 == 0)
//3. 如果是, 就结束本次循环
continue;
//4. 如果不是, 就打印该数字的值.
System.out.println(i);
}
System.out.println("end");
}
}
图解
14.5 思考题
已知代码如下:
//思考题
public class BreakDemo03 {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
//这里加入什么???
}
System.out.println("Hello World! " + i);
}
}
}
问: 在注释的地方填充什么代码, 分别可以实现该循环共计打印: 2次, 7次, 13次"Hello World!"字符串?
15. 循环嵌套
所谓的循环嵌套指的是循环结构中还包裹着循环结构, 外边的循环结构叫外循环, 里边的循环结构叫内循环.
15.1 格式
循环嵌套用的最多的就是for循环的嵌套, 具体格式如下:
for(初始化条件; 判断条件; 控制条件) { //外循环, 例如: 5 1 2
for(初始化条件; 判断条件; 控制条件) { //内循环, 例如: 3 1,2,3 1,2,3
//循环体;
}
}
15.2 执行流程
外循环执行一次, 内循环执行一圈.
循环嵌套的总执行次数 = 外循环的次数 * 内循环的次数.
例如:
现实世界中的年月关系, 即: 1年 = 12个月
现实世界中的时分, 分秒关系, 即: 1小时 = 60分钟, 1分钟=60秒.
15.3 案例一: 打印年月
需求
打印2020年1月至2023年12月之间所有的月份, 格式为: XXXX年XX月
参考代码
- 复杂写法
//案例: 打印年月
public class ForForDemo04 {
public static void main(String[] args) {
//1. 定义循环, 打印2021年所有的月份
for (int j = 1; j <= 12 ; j++) {
System.out.print("2021年" + j + "月 ");
}
System.out.println(); //记得加换行
//2. 定义循环, 打印2022年所有的月份
for (int j = 1; j <= 12 ; j++) {
System.out.print("2022年" + j + "月 ");
}
System.out.println(); //记得加换行
//3. 定义循环, 打印2023年所有的月份
for (int j = 1; j <= 12 ; j++) {
System.out.print("2023年" + j + "月 ");
}
System.out.println(); //记得加换行
}
}
- 简单写法
//案例: 打印年月
public class ForForDemo04 {
public static void main(String[] args) {
//1. 定义外循环, 控制年份的变化.
for (int i = 2020; i <= 2023 ; i++) { //外循环执行一次, 内循环执行一圈.
System.out.println("start");
//变量i的取值: 2021, 2022, 2023
//2. 定义内循环, 控制月份的变化.
for (int j = 1; j <= 12 ; j++) {
System.out.print(i + "年" + j + "月 ");
}
System.out.println(); //记得加换行
System.out.println("end
");
}
}
}
15.4 案例二: 打印矩形
需求
在控制台打印一个3行5列的矩形星星序列, 具体格式如下:
*****
*****
*****
要求: 一次只能打印一个"*"
参考代码
public class ForForDemo05 {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) { //外循环控制行
for (int j = 0; j < 5; j++) { //内循环控制列
System.out.print("*"); //每次打印一个"*"
}
System.out.println(); //内循环执行结束, 意味着一行打印完毕, 记得要换行.
}
}
}
15.5 案例三: 打印正三角形
需求
在控制台打印一个5行5列的正三角形星星序列, 具体格式如下:
*
**
***
****
*****
要求: 一次只能打印一个"*"
参考代码
public class ForForDemo06 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) { //外循环控制行
for (int j = 1; j <= i; j++) { //内循环控制列
System.out.print("*"); //每次打印一个"*"
}
System.out.println(); //内循环执行结束, 意味着一行打印完毕, 记得要换行.
}
}
}
小技巧: 打印正三角形和打印矩形相比: 判断条件发生变化.
15.6 案例四: 打印倒三角形
需求
在控制台打印一个5行5列的正三角形星星序列, 具体格式如下:
*****
****
***
**.
*
要求: 一次只能打印一个"*"
参考代码
public class ForForDemo07 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) { //外循环控制行
for (int j = i; j <= 5; j++) { //内循环控制列
System.out.print("*"); //每次打印一个"*"
}
System.out.println(); //内循环执行结束, 意味着一行打印完毕, 记得要换行.
}
}
}
小技巧: 打印倒三角形和打印矩形相比: 初始化条件发生变化.
15.7 案例五: 打印99乘法表
需求
打印99乘法表, 格式如下:
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
参考代码
public class ForForDemo08 {
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) { //外循环控制行
for (int j = 1; j <= i; j++) { //内循环控制列
//1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
System.out.print(j + " * " + i + " = " + i * j + " ");
}
System.out.println(); //内循环执行结束, 意味着一行打印完毕, 记得要换行.
}
}
}
16. 生成随机数
16.1 概述
Math类似Scanner，也是Java提供好的API(Application Programming Interface)，内部提供了产生随机数的功能. API后续课程详细讲解，现在可以简单理解为Java已经写好的代码, 我们可以直接拿来用.
16.2 格式
Math.random(); //可以获取0.0 ~ 1.0之间所有的数据, 包左不包右.
//示例: 获取1-100之间的随机数
int num = (int)(Math.random()*100 + 1);
16.3 案例一: Math入门
需求
使用Math类，生成5个1~10之间的随机整数, 并将结果打印到控制台.
参考代码
public class MathDemo01 {
public static void main(String[] args) {
//1. 定义for循环, 用来获取5个随机数.
int num;
for (int i = 1; i <= 5; i++) {
//2.获取随机数, 并打印
num = (int)(Math.random()*10 + 1);
System.out.println(num);
}
}
}
16.4 案例二: 猜数字
需求
生成一个1-100之间的随机数, 让用户来猜.
如果猜的数字比生成的随机数大，提示你猜的数据大了
如果猜的数字比生成的随机数小，提示你猜的数据小了
如果猜的数字与生成的随机数相等，提示恭喜你猜中了
参考代码
import java.util.Scanner;
public class MathDemo02 {
public static void main(String[] args) {
//1. 生成一个随机数让用户来猜.
int guessNum = (int)(Math.random()*100 + 1);
//2. 因为不知道用户多少次能猜对, 所以用while(true)死循环.
int inputNum = 0;
while (true) {
//3. 提示用户录入猜的数据, 并接收.
System.out.println("请录入您猜的数据(1-100): ");
inputNum = new Scanner(System.in).nextInt();
//4. 比较用户录入的数据 和 生成的随机数是否一致, 并提示.
if (inputNum > guessNum)
System.out.println("您猜的数字大了!");
else if (inputNum < guessNum)
System.out.println("您猜的数字小了");
else {
System.out.println("恭喜您, 猜对了, 请找班任领取奖品... 就业班晋级卡");
break;
}
}
}
}