20260714-笔记.md 42 KB
JavaSE 基础 — Day02 笔记
日期：2026-07-14
项目：c260714
作者：WanJL
一、流程控制（if-else）
1. 程序的结构
程序的结构分为三种：
| 结构 | 说明 |
|---|---|
| 顺序结构 | 代码从左到右、从上到下依次执行 |
| 分支结构 | 为代码设定条件，满足条件执行 A，不满足执行 B |
| 循环结构 | 重复执行某段代码（后续课程讲解） |
2. if-else 分支结构
核心思想：告诉程序在什么情况下做什么事。
如果下雨，要打伞；否则就不打伞。
语法格式：
if (布尔表达式) {
// 条件为 true 时执行的代码
} else {
// 条件为 false 时执行的代码
}
布尔表达式：运算结果为
boolean类型值（true或false）的表达式。
示例：判断一个整数是正数还是负数
int a = 15;
if (a > 0) {
System.out.println("正数");
} else {
System.out.println("负数");
}
完整代码 —— Demo01.java
/**
* @author WanJl
* @version 1.0
* @title Demo01
* @description 流程控制
* @create 2026/7/14
*/
public class Demo01 {
public static void main(String[] args) {
/*
逻辑
流程控制就是告诉程序，要在什么情况下做什么事 的逻辑
如果 下雨 要打伞 否则就不打伞
程序的结构分为三种：
1、 顺序结构 代码从左到右从上到下依次执行
2、 分支结构 为代码设定条件，如果满足条件，就执行A，不满足就执行B
如果 (是否下雨){
要打伞
}否则{
不打伞
}
if(下雨==true){ 括号里的 必须是布尔表达式（布尔表达式就是运算的结果是布尔类型值 true 或 false）
要打伞
}else{
不打伞
}
比如判断： 15 是 正数 还是负数
*/
System.out.println("前面有n多代码...............");
int a = 15; // 定义一个整数类型的变量
if (a > 0) { // 判断 变量值是否大于0 运行结果是boolean类型值
System.out.println("正数");
} else {
System.out.println("负数");
}
System.out.println("后面有n多代码...............");
/*
1、判断年龄age 是否大于30岁
2、判断年龄 age2 是否成年
3、判断分数 score 是否优秀 大于90分
*/
}
}
3. 随堂练习（if 分支）
- 判断年龄
age是否大于 30 岁 - 判断年龄
age2是否成年（≥ 18 岁） - 判断分数
score是否优秀（大于 90 分）
二、Java 运算符
1. 运算符的分类
按操作数的数量分类
| 类型 | 说明 | 示例 |
|---|---|---|
| 一元运算符 | 只有一个操作数参与运算 | ++、-- |
| 二元运算符 | 有两个操作数参与运算 | +、-、*、/ |
| 三元运算符 | 有三个操作数参与运算 | ? :（后面课程讲解） |
按功能分类
| 类别 | 说明 |
|---|---|
| 算术运算符 | ✅ 本次课程重点 |
| 赋值运算符 | ✅ 本次课程重点 |
| 比较运算符 | ✅ 本次课程重点 |
| 逻辑运算符 | ✅ 本次课程重点 |
| 位运算符 | ✅ 本次课程重点 |
| 三目运算符 | ✅ 本次课程重点 |
| 运算符优先级 | ✅ 本次课程重点 |
2. 算术运算符
| 运算符 | 名称 | 示例 | 结果 |
|---|---|---|---|
+ |
加号 | 5 + 5 |
10 |
- |
减号 | 5 - 3 |
2 |
* |
乘号 | 5 * 3 |
15 |
/ |
除号 | 5 / 3 |
1（不是 1.666...） |
% |
取余/取模 | 5 % 3 |
2（5 / 3 = 1 余 2） |
++ |
自增 | ++i / i++ |
一元运算符 |
-- |
自减 | --i / i-- |
一元运算符 |
基本运算示例
int a = 10, b = 3;
System.out.println("10+3=" + (a + b)); // 13
System.out.println("10-3=" + (a - b)); // 7
System.out.println("10*3=" + (a * b)); // 30
System.out.println("10/3=" + (a / b)); // 3
System.out.println("10%3=" + (a % b)); // 1
常见问题
① 整数除法截断
两个整数相除，结果为整数，会直接截断小数部分，只保留整数。
System.out.println(10 / 3); // 3（截断小数）
System.out.println(10 / 3.0); // 3.3333333333333335（有小数参与，结果为小数）
System.out.println(10.0 / 3); // 3.3333333333333335
② 0 不能做除数
整数除法中，除数为 0 会抛出异常：
// System.out.println(3 / 0); // ArithmeticException（算术异常，程序停止）
但浮点数除法中，除数为 0 有特殊结果：
System.out.println(3 / 0.0); // Infinity（无穷大）
System.out.println(3 / -0.0); // -Infinity（负无穷大）
System.out.println(0.0 / 0.0); // NaN（Not a Number，非数字）
③ 取模运算 %
System.out.println(10 % 3); // 1
System.out.println(-10 % 3); // -1（结果的符号与被除数相同）
取模规则：
a % b的结果符号与a（被除数）的符号一致。
④ 自增 ++ 与自减 --
++表示这个数增加 1，--表示这个数减少 1- 符号在前（
++i）：先进行自增运算，再进行其他操作（如赋值） 符号在后（
i++）：先进行其他操作，再进行自增运算int i = 10; int j = ++i; // i 先自增变为 11，再将 11 赋值给 j int k = i++; // 先将 i（当前 11）赋值给 k，i 再自增变为 12 System.out.println(j); // 11 System.out.println(k); // 11 System.out.println(i); // 12
3. 赋值运算符
| 运算符 | 名称 | 含义 | 等价于 |
|---|---|---|---|
= |
赋值 | 把右边的值赋给左边 | — |
+= |
加后赋值 | a = a + b |
a += b |
-= |
减后赋值 | a = a - b |
a -= b |
*= |
乘后赋值 | a = a * b |
a *= b |
/= |
除后赋值 | a = a / b |
a /= b |
%= |
取余后赋值 | a = a % b |
a %= b |
示例
int x = 10;
x += 5; // x = x + 5 → 15
System.out.println(x);
x *= 3; // x = x * 3 → 45
System.out.println(x);
复合运算符隐含强制类型转换
byte a = 15;
// a = a + 6; // ❌ 编译错误：a + 6 结果被提升为 int，赋值给 byte 需强制转换
a += 6; // ✅ 复合赋值运算符隐含强制类型转换
重要：复合赋值运算符（
+=、-=等）内部隐含了强制类型转换，不需要手动强转。
完整代码 —— Demo03.java
/**
* @author WanJl
* @version 1.0
* @title Demo03
* @description 赋值运算符
* @create 2026/7/14
*/
public class Demo03 {
public static void main(String[] args) {
/*
赋值运算符
把=右边的值赋值给等号左边，比如 a=10
= 赋值 a=b 把b的值赋值给a
+= 加后赋值 a=a+b 把a+b的结果赋值给a
-= 减后赋值 a=a-b 把a-b的结果赋值给a
*= 乘后赋值 a=a*b 把a*b的结果赋值给a
/= 除后赋值 a=a/b 把a/b的结果赋值给a
%= 取余后赋值 a=a%b 把a%b的结果赋值给a
*/
int x = 10;
x += 5;
System.out.println(x); // 15
x *= 3;
System.out.println(x); // 45 (x = x * 3)
// 复合运算符隐含强制类型转换
byte a = 15;
// a = a + 6; // 因为a+6的结果被提升为int类型，再赋值给byte类型的a需要强制类型转换
a += 6; // 复合赋值运算符 隐含就帮我们做了强制类型转换。
}
}
4. 比较运算符
| 运算符 | 名称 | 示例 | 结果 |
|---|---|---|---|
> |
大于 | 5 > 3 |
true |
< |
小于 | 5 < 3 |
false |
== |
等于 | 5 == 3 |
false |
>= |
大于等于 | 5 >= 3 |
true |
<= |
小于等于 | 5 <= 3 |
false |
!= |
不等于 | 5 != 3 |
true |
注意：比较运算符的结果都是
boolean类型（true或false）。 判断相等使用==（双等号），不能写成=（单等号是赋值）。
浮点数精度陷阱
使用 == 比较浮点数时要特别小心，因为浮点数存在精度误差：
double b1 = 0.1 + 0.2;
double b2 = 0.3;
System.out.println(b1 == b2); // false！浮点数精度误差
System.out.println(b1); // 0.30000000000000004
System.out.println(b2); // 0.3
0.1 + 0.2在计算机中无法精确表示为0.3，而是近似值0.30000000000000004，因此==比较返回false。
解决方案：使用 printf 格式化输出，或设置误差范围进行比较。
System.out.printf("%.1f", b1); // 输出 0.3（保留1位小数）
完整代码 —— Demo04.java
/**
* @author WanJl
* @version 1.0
* @title Demo04
* @description 比较运算符
* @create 2026/7/14
*/
public class Demo04 {
public static void main(String[] args) {
/*
> 大于 5>3 true
< 小于 5<3 false
== 等于 5==3 false
>= 大于等于 5>=3 true
<= 小于等于 5<=3 false
!= 不等于 5!=3 true
*/
// 比较运算符 陷阱（精度陷阱）
double b1 = 0.1 + 0.2;
double b2 = 0.3;
System.out.println(b1 == b2); // false 浮点数精度误差
System.out.println(b1); // 0.30000000000000004
System.out.println(b2); // 0.3
// 输出保留1位小数
System.out.printf("%.1f", b1); // 0.3
}
}
5. 逻辑运算符
逻辑运算符操作的对象要么是布尔表达式，要么是布尔值。
| 运算符 | 名称 | 示例 | 结果 | 说明 |
|---|---|---|---|---|
& |
与 | true & false |
false |
两边都为 true 结果才为 true |
\| |
或 | true \| false |
true |
两边都为 false 结果才为 false |
! |
非 | !true |
false |
取反（单目运算符） |
&& |
短路与 | true && false |
false |
左边为 false 时右边不执行 |
\|\| |
短路或 | true \|\| false |
true |
左边为 true 时右边不执行 |
^ |
异或 | true ^ false |
true |
两边相同返回 false，不同返回 true |
① & 与（AND）
符号左右两侧的布尔表达式结果如果都是 true，则运算结果为 true，否则为 false。
System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & true); // false
System.out.println(false & false); // false
② | 或（OR）
符号左右两侧的布尔表达式结果如果都是 false，则运算结果为 false，否则为 true。
System.out.println(true | true); // true
System.out.println(true | false); // true
System.out.println(false | true); // true
System.out.println(false | false); // false
③ ! 非（NOT）
取反，单目运算符。符号右侧的布尔表达式结果为 true 时运算后为 false，反之亦然。
System.out.println(!true); // false
System.out.println(!false); // true
④ && 短路与（Short-circuit AND）
作用与 & 相同，但具有短路特性：如果符号左边为 false，右边不再运算，直接返回 false。
System.out.println(true && true); // true
System.out.println(true && false); // false
System.out.println(false && true); // false（右边不执行）
System.out.println(false && false); // false（右边不执行）
⑤ || 短路或（Short-circuit OR）
作用与 | 相同，但具有短路特性：如果符号左边为 true，右边不再运算，直接返回 true。
System.out.println(true || true); // true（右边不执行）
System.out.println(true || false); // true（右边不执行）
System.out.println(false || true); // true
System.out.println(false || false); // false
⑥ ^ 异或（XOR）
符号左右两侧的布尔表达式如果相同，返回 false；不同返回 true。
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
System.out.println(false ^ false); // false
完整代码 —— Demo05.java
/**
* @author WanJl
* @version 1.0
* @title Demo05
* @description 逻辑运算符
* @create 2026/7/14
*/
public class Demo05 {
public static void main(String[] args) {
/*
逻辑运算符 操作的数 要么是布尔表达式 要么是布尔值。
& 与 true&false false
| 或 true|false true
! 非 !true false
&& 短路与 true&&false false
|| 短路或 true||false true
^ 异或 true^false true
*/
// & 与：符号左右两侧的布尔表达式结果如果都是true，则运算结果为true，否则就是false
System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & true); // false
System.out.println(false & false); // false
// | 或：符号左右两侧的布尔表达式结果如果都是false，则运算结果为false，否则就是true
System.out.println(true | true); // true
System.out.println(true | false); // true
System.out.println(false | true); // true
System.out.println(false | false); // false
// && 短路与，作用和&相同，只不过，符号左边如果是false，右边就不运算了，直接返回false
System.out.println(true && true); // true
System.out.println(true && false); // false
System.out.println(false && true); // false
System.out.println(false && false); // false
// || 短路或，作用和|相同，只不过，符号左边如果是true，右边就不运算了，直接返回true
System.out.println(true || true); // true
System.out.println(true || false); // true
System.out.println(false || true); // true
System.out.println(false || false); // false
// ! 非 也就是取反，它也是单目运算符，符号右侧的布尔表达式的结果如果是true，运算后就是false
System.out.println(!true); // false
System.out.println(!false); // true
// ^ 异或 符号左右两侧的布尔表达式如果相同，就返回false，不同返回true
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
System.out.println(false ^ false); // false
}
}
6. 位运算符
位运算符用来直接操作整型（
byte/short/int/long/char）的二进制位，性能极高，在底层编程、权限控制、编码算法中使用较多。
| 运算符 | 名称 | 示例 | 说明 |
|---|---|---|---|
& |
按位与 | 5 & 3 |
对应位同时为 1 时结果为 1，否则为 0 |
| ` | ` | 按位或 | `5 |
^ |
按位异或 | 5 ^ 3 |
对应位相同为 0，不同为 1 |
~ |
按位取反 | ~5 |
单目运算符，0 变 1，1 变 0 |
<< |
按位左移 | 5 << 1 |
向左移动指定位数，空位补 0，相当于 ×2ⁿ |
>> |
按位右移 | 5 >> 1 |
向右移动指定位数，空位补符号位，相当于 ÷2ⁿ（向下取整） |
>>> |
无符号右移 | 5 >>> 1 |
向右移动指定位数，空位补 0，负数会得到大正数 |
① & 按位与
符号左右两边的数的每个二进制位，如果同时为 1，则运算结果为 1，否则为 0，最后把二进制数转换为十进制数。
0101 ← 5
& 0011 ← 3
--------
0001 → 1
System.out.println(5 & 3); // 1
② | 按位或
符号左右两边的数的每个二进制位，如果同时为 0，则运算结果为 0，否则为 1，最后把二进制数转换为十进制数。
0101 ← 5
| 0011 ← 3
--------
0111 → 7
System.out.println(5 | 3); // 7
③ ^ 按位异或
符号左右两边的数的每个二进制位，如果相同则为 0，不同则为 1，最后把二进制数转换为十进制数。
0101 ← 5
^ 0011 ← 3
--------
0110 → 6
System.out.println(5 ^ 3); // 6
④ ~ 按位取反
单目运算符，符号右边的数的二进制位，如果为 0 则运算结果为 1，如果为 1 则运算结果为 0。
~ 0000 0101 ← 5（8位二进制）
------------
1111 1010 → -6
System.out.println(~5); // -6
注意：
~5的结果是-6，因为计算机使用补码表示负数。
⑤ << 按位左移
把符号左边的数的二进制位，向左移动符号右边指定的位数，空出来的位置补 0。
0101 ← 5
<< 1
--------
1010 → 10（相当于 5 × 2¹ = 10）
System.out.println(5 << 3); // 40（相当于 5 × 2³ = 40）
左移规律：左移 n 位相当于乘以 2ⁿ（在不溢出的前提下）。
⑥ >> 按位右移
把符号左边的数的二进制位，向右移动符号右边指定的位数，空出来的位置补符号位的值。
二进制最左侧为最高位（符号位）：
0表示正数，1表示负数。
0101 ← 5
>> 1
--------
0010 → 2（相当于 5 ÷ 2¹ = 2，向下取整）
System.out.println(5 >> 3); // 0（相当于 5 ÷ 2³ = 0，向下取整）
右移规律：右移 n 位相当于除以 2ⁿ（向下取整）。
⑦ >>> 无符号右移
把符号左边的数的二进制位，向右移动符号右边指定的位数，空出来的位置补 0。对负数操作后会得到大正数。
1111 1011 ← -5（8位表示）
>>> 1
-----------
0111 1101 → 正数
System.out.println(-5 >>> 1); // 2147483645（大正数）
位运算总结：
| 运算 | 效果 | 规律 |
|---|---|---|
左移 << |
高位丢失，低位补 0 | 相当于 ×2ⁿ |
右移 >> |
低位丢失，高位补符号位 | 相当于 ÷2ⁿ（向下取整） |
无符号右移 >>> |
低位丢失，高位补 0 | 负数会变为大正数 |
随堂练习：位运算
运行以下代码，查看结果，并验证位运算规律：
System.out.println(15 >> 3); // ?
System.out.println(66 << 2); // ?
System.out.println(75 & 86); // ?
System.out.println(63 | 36); // ?
System.out.println(-128 >>> 3); // ?
完整代码 —— Demo06.java
/**
* @author WanJl
* @version 1.0
* @title Demo06
* @description 位运算符
* @create 2026/7/14
*/
public class Demo06 {
/*
位运算符是用来直接操作 整型（byte/short/int/long/char）的二进制位，
性能极高，在底层编程、权限控制、编码算法中使用的比较多
& 按位与 5&3 0101 & 0011 = 0001
| 按位或 5|3 0101 | 0011 = 0111
^ 按位异或 5^3 0101 ^ 0011 = 0110
~ 按位取反 ~5 ~0101 = 1010
<< 按位左移 5<<1 0101 << 1 = 1010
>> 按位右移 5>>1 0101 >> 1 = 0010
>>> 无符号右移 5>>>1 0101 >>> 1 = 0010
*/
public static void main(String[] args) {
// 按位与 &：对应位同时为1则结果为1，否则为0
System.out.println(5 & 3); // 1
// 按位或 |：对应位同时为0则结果为0，否则为1
System.out.println(5 | 3); // 7
// 按位异或 ^：对应位相同为0，不同为1
System.out.println(5 ^ 3); // 6
// 按位取反 ~：单目，0变1，1变0
System.out.println(~5); // -6
// 按位左移 <<：向左移动，低位补0，相当于 ×2ⁿ
System.out.println(5 << 3); // 40（5 × 2³ = 40）
// 按位右移 >>：向右移动，高位补符号位，相当于 ÷2ⁿ（向下取整）
System.out.println(5 >> 3); // 0
// 无符号右移 >>>：向右移动，高位补0，负数变为大正数
System.out.println(-5 >>> 1); // 2147483645
/*
左移：高位丢失，低位补0，相当于 ×2
右移：低位丢失，高位补符号位，相当于 ÷2 并且向下取整
无符号右移：低位丢失，高位补0，对负数会得到大正数
*/
}
}
7. 三目运算符（三元运算符）
三目运算符是 Java 中唯一一个需要三个操作数的运算符。
语法格式：
布尔表达式 ? 表达式1 : 表达式2
执行逻辑：
- 如果布尔表达式结果为
true，执行（返回）表达式1 - 如果布尔表达式结果为
false，执行（返回）表达式2
示例
System.out.println(15 > 8 ? "hello" : "哈哈哈哈"); // hello
System.out.println(15 > 8 ? 6 : "哈哈哈哈"); // 6（返回 int）
int x = 10, y = 6;
System.out.println(x > y ? "x>y" : "x<=y"); // x>y
System.out.println(x > y ? "x>y" : y); // x>y（返回 String）
三目运算符 vs if-else 选择原则
| 场景 | 推荐使用 |
|---|---|
| 简单的二选一赋值 | 三目运算符 |
| 复杂多个分支逻辑 | if-else |
| 嵌套超过 2 层 | if-else（三目嵌套可读性差） |
| 需要执行某段代码而不是返回一个值 | if-else |
完整代码 —— Demo07.java
/**
* @author WanJl
* @version 1.0
* @title Demo07
* @description 三目运算符 三元运算符
* @create 2026/7/14
*/
public class Demo07 {
public static void main(String[] args) {
/*
三目运算符
布尔表达式?表达式1:表达式2
布尔表达式的结果如果是true，就执行表达式1，否则执行表达式2
*/
System.out.println(15 > 8 ? "hello" : "哈哈哈哈");
System.out.println(15 > 8 ? 6 : "哈哈哈哈");
int x = 10, y = 6;
System.out.println(x > y ? "x>y" : "x<=y");
System.out.println(x > y ? "x>y" : y);
/*
什么时候使用三元运算符，什么时候使用if...else
如果是简单的二选一赋值 → 三元运算符
复杂多个分支逻辑 → if...else
嵌套超过2层 → if...else
需要执行某段代码而不是返回一个值 → if...else
*/
}
}
8. 运算符优先级
运算符优先级决定了表达式中的计算顺序。优先级越高，越先被计算。
| 优先级 | 运算符 | 说明 |
|---|---|---|
| 1（最高） | () . [] |
括号、成员访问、数组下标 |
| 2 | ++ -- +（正）-（负） |
自增、自减、正负号 |
| 3 | * / % |
乘、除、取余 |
| 4 | + - |
加、减 |
| 5 | << >> >>> |
移位运算 |
| 6 | < > <= >= |
比较（instanceof） |
| 7 | == != |
等于、不等于 |
| 8 | & |
按位与 |
| 9 | ^ |
按位异或 |
| 10 | \| |
按位或 |
| 11 | && |
短路与 |
| 12 | \|\| |
短路或 |
| 13 | ?: |
三目运算符 |
| 14（最低） | = += -= *= /= %= |
赋值运算符 |
记忆口诀：括号最高，单目第二，乘除第三，加减第四，移位第五，比较第六，等于第七，位逻辑（
&^|）第八到十，短路逻辑（&&||）十一十二，三目十三，赋值最后。最佳实践：当不确定优先级时，使用
()明确指定计算顺序，提高代码可读性。
完整代码 —— Demo08.java
/**
* @author WanJl
* @version 1.0
* @title Demo08
* @description 运算符优先级
* @create 2026/7/14
*/
public class Demo08 {
public static void main(String[] args) {
/*
运算符优先级决定了表达式中的计算顺序
最高优先级：() . []
2 ++ -- +正数 -负数
3 * / %
4 + -
5 << >> >>>
6 < > <= >=
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
13 ?: 三元运算符
14 各种赋值 = += -=
*/
}
}
结合 if-else 分支结构与算术运算符，完成以下练习：
练习 1：判断奇偶数
int i1 = 7;
if (i1 % 2 == 0) {
System.out.println("偶数");
} else {
System.out.println("奇数");
}
思路：奇数不能被 2 整除（
% 2 == 1），偶数能被 2 整除（% 2 == 0）。
练习 2：判断倍数关系
int a1 = 10, b1 = 5;
if (a1 % b1 == 0) {
System.out.println("是倍数");
} else {
System.out.println("不是倍数");
}
思路：
a1 % b1 == 0说明a1能被b1整除，即a1是b1的倍数。
练习 3：判断正数、负数还是 0
int i2 = 10;
if (i2 > 0) {
System.out.println("正数");
} else if (i2 < 0) {
System.out.println("负数");
} else {
System.out.println("0");
}
思路：使用
if - else if - else进行多分支判断。
练习 4：分钟数转换
将总分钟数（如 130 分钟）转换为几小时几分钟，并判断是否超过 1 小时。
int time = 130;
int h = time / 60; // 整除获取小时数
int m = time % 60; // 取余获取剩余分钟数
System.out.println(h + "小时" + m + "分钟");
if (h > 1) {
System.out.println("超过1小时");
} else {
System.out.println("不超过1小时");
}
思路：
小时 = 总分钟 / 60（整除），剩余分钟 = 总分钟 % 60（取余）。
练习 5：成绩等级判定
定义一个成绩变量 score，使用 if - else if - else 结合逻辑运算符 && 实现多级判断：
| 分数范围 | 等级 |
|---|---|
| 90 ≤ score ≤ 100 | 优秀 |
| 80 ≤ score < 90 | 良好 |
| 70 ≤ score < 80 | 中等 |
| 60 ≤ score < 70 | 及格 |
| 0 ≤ score < 60 | 不及格 |
| 其他 | 分数错误 |
double score = 85.3;
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80 && score < 90) {
System.out.println("良好");
} else if (score >= 70 && score < 80) {
System.out.println("中等");
} else if (score >= 60 && score < 70) {
System.out.println("及格");
} else if (score >= 0 && score < 60) {
System.out.println("不及格");
} else {
System.out.println("成绩错误");
}
知识点：综合运用
if-else语句 + 比较运算符 + 逻辑运算符&&。
四、完整代码汇总
Demo01.java — 流程控制
/**
* @author WanJl
* @version 1.0
* @title Demo01
* @description 流程控制
* @create 2026/7/14
*/
public class Demo01 {
public static void main(String[] args) {
System.out.println("前面有n多代码...............");
int a = 15;
if (a > 0) {
System.out.println("正数");
} else {
System.out.println("负数");
}
System.out.println("后面有n多代码...............");
}
}
Demo02.java — 算术运算符 + 综合练习
/**
* @author WanJl
* @version 1.0
* @title Demo02
* @description Java运算符
* @create 2026/7/14
*/
public class Demo02 {
public static void main(String[] args) {
// 1. 算术运算符
int a = 10, b = 3;
System.out.println("10+3=" + (a + b));
System.out.println("10-3=" + (a - b));
System.out.println("10*3=" + (a * b));
System.out.println("10/3=" + (a / b));
System.out.println("10%3=" + (a % b));
// 整数除法截断
System.out.println(10 / 3); // 3
System.out.println(10 / 3.0); // 3.3333...
// 0 不能做除数
System.out.println(3 / 0.0); // Infinity
System.out.println(3 / -0.0); // -Infinity
System.out.println(0.0 / 0.0); // NaN
// 取模运算
System.out.println(10 % 3); // 1
System.out.println(-10 % 3); // -1
// 自增自减
int i = 10;
int j = ++i; // 11
int k = i++; // 11（赋值后再自增）
System.out.println(j);
System.out.println(k);
System.out.println(i); // 12
// 练习1：判断奇偶数
int i1 = 7;
if (i1 % 2 == 0) {
System.out.println("偶数");
} else {
System.out.println("奇数");
}
// 练习2：判断倍数
int a1 = 10, b1 = 5;
if (a1 % b1 == 0) {
System.out.println("是倍数");
} else {
System.out.println("不是倍数");
}
// 练习3：判断正数/负数/0
int i2 = 10;
if (i2 > 0) {
System.out.println("正数");
} else if (i2 < 0) {
System.out.println("负数");
} else {
System.out.println("0");
}
// 练习4：分钟转换
int time = 130;
int h = time / 60;
int m = time % 60;
System.out.println(h + "小时" + m + "分钟");
if (h > 1) {
System.out.println("超过1小时");
} else {
System.out.println("不超过1小时");
}
}
}
Demo03.java — 赋值运算符
/**
* @author WanJl
* @version 1.0
* @title Demo03
* @description 赋值运算符
* @create 2026/7/14
*/
public class Demo03 {
public static void main(String[] args) {
int x = 10;
x += 5;
System.out.println(x); // 15
x *= 3;
System.out.println(x); // 45
// 复合运算符隐含强制类型转换
byte a = 15;
a += 6; // 隐含强制类型转换
}
}
Demo04.java — 比较运算符 + 浮点数精度陷阱
/**
* @author WanJl
* @version 1.0
* @title Demo04
* @description 比较运算符
* @create 2026/7/14
*/
public class Demo04 {
public static void main(String[] args) {
/*
> 大于 5>3 true
< 小于 5<3 false
== 等于 5==3 false
>= 大于等于 5>=3 true
<= 小于等于 5<=3 false
!= 不等于 5!=3 true
*/
// 比较运算符 陷阱（精度陷阱）
double b1 = 0.1 + 0.2;
double b2 = 0.3;
System.out.println(b1 == b2); // false 浮点数精度误差
System.out.println(b1); // 0.30000000000000004
System.out.println(b2); // 0.3
// 输出保留1位小数
System.out.printf("%.1f", b1); // 0.3
}
}
Demo05.java — 逻辑运算符 + 成绩等级练习
/**
* @author WanJl
* @version 1.0
* @title Demo05
* @description 逻辑运算符
* @create 2026/7/14
*/
public class Demo05 {
public static void main(String[] args) {
/*
逻辑运算符 操作的数 要么是布尔表达式 要么是布尔值。
& 与 true&false false
| 或 true|false true
! 非 !true false
&& 短路与 true&&false false
|| 短路或 true||false true
^ 异或 true^false true
*/
// & 与
System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & true); // false
System.out.println(false & false); // false
// | 或
System.out.println(true | true); // true
System.out.println(true | false); // true
System.out.println(false | true); // true
System.out.println(false | false); // false
// && 短路与（左边为false时右边不执行）
System.out.println(true && true); // true
System.out.println(true && false); // false
System.out.println(false && true); // false
System.out.println(false && false); // false
// || 短路或（左边为true时右边不执行）
System.out.println(true || true); // true
System.out.println(true || false); // true
System.out.println(false || true); // true
System.out.println(false || false); // false
// ! 非（取反）
System.out.println(!true); // false
System.out.println(!false); // true
// ^ 异或（相同为false，不同为true）
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
System.out.println(false ^ false); // false
/*
课堂练习题：
定义一个成绩变量 score，判断：
如果score大于等于90并且小于等于100，就输出优秀
如果score大于等于80并且小于90，就输出良好
如果score大于等于70并且小于80，就输出中等
如果score大于等于60并且小于70，就输出及格
如果score大于等于0并且小于60，就输出不及格
在此范围外的任何值，都输出 分数错误。
*/
double score = 85.3;
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80 && score < 90) {
System.out.println("良好");
} else if (score >= 70 && score < 80) {
System.out.println("中等");
} else if (score >= 60 && score < 70) {
System.out.println("及格");
} else if (score >= 0 && score < 60) {
System.out.println("不及格");
} else {
System.out.println("成绩错误");
}
}
}
Demo06.java — 位运算符
/**
* @author WanJl
* @version 1.0
* @title Demo06
* @description 位运算符
* @create 2026/7/14
*/
public class Demo06 {
/*
位运算符是用来直接操作 整型（byte/short/int/long/char）的二进制位，
性能极高，在底层编程、权限控制、编码算法中使用的比较多
& 按位与 5&3 0101 & 0011 = 0001
| 按位或 5|3 0101 | 0011 = 0111
^ 按位异或 5^3 0101 ^ 0011 = 0110
~ 按位取反 ~5 ~0101 = 1010
<< 按位左移 5<<1 0101 << 1 = 1010
>> 按位右移 5>>1 0101 >> 1 = 0010
>>> 无符号右移 5>>>1 0101 >>> 1 = 0010
*/
public static void main(String[] args) {
// 按位与 &：对应位同时为1则结果为1，否则为0
System.out.println(5 & 3); // 1
// 按位或 |：对应位同时为0则结果为0，否则为1
System.out.println(5 | 3); // 7
// 按位异或 ^：对应位相同为0，不同为1
System.out.println(5 ^ 3); // 6
// 按位取反 ~：单目，0变1，1变0
System.out.println(~5); // -6
// 按位左移 <<：向左移动，低位补0，相当于 ×2ⁿ
System.out.println(5 << 3); // 40
// 按位右移 >>：向右移动，高位补符号位，相当于 ÷2ⁿ（向下取整）
System.out.println(5 >> 3); // 0
// 无符号右移 >>>：向右移动，高位补0，负数变为大正数
System.out.println(-5 >>> 1); // 2147483645
/*
左移：高位丢失，低位补0，相当于 ×2
右移：低位丢失，高位补符号位，相当于 ÷2 并且向下取整
无符号右移：低位丢失，高位补0，对负数会得到大正数
*/
/*
编程运行，查看结果
15>>3
66<<2
75&86
63|36
-128>>>3
*/
}
}
Demo07.java — 三目运算符
/**
* @author WanJl
* @version 1.0
* @title Demo07
* @description 三目运算符 三元运算符
* @create 2026/7/14
*/
public class Demo07 {
public static void main(String[] args) {
/*
三目运算符
布尔表达式?表达式1:表达式2
布尔表达式的结果如果是true，就执行表达式1，否则执行表达式2
*/
System.out.println(15 > 8 ? "hello" : "哈哈哈哈");
System.out.println(15 > 8 ? 6 : "哈哈哈哈");
int x = 10, y = 6;
System.out.println(x > y ? "x>y" : "x<=y");
System.out.println(x > y ? "x>y" : y);
/*
什么时候使用三元运算符，什么时候使用if...else
如果是简单的二选一赋值 → 三元运算符
复杂多个分支逻辑 → if...else
嵌套超过2层 → if...else
需要执行某段代码而不是返回一个值 → if...else
*/
}
}
Demo08.java — 运算符优先级
/**
* @author WanJl
* @version 1.0
* @title Demo08
* @description 运算符优先级
* @create 2026/7/14
*/
public class Demo08 {
public static void main(String[] args) {
/*
运算符优先级决定了表达式中的计算顺序
最高优先级：() . []
2 ++ -- +正数 -负数
3 * / %
4 + -
5 << >> >>>
6 < > <= >=
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
13 ?: 三元运算符
14 各种赋值 = += -=
*/
}
}
五、随堂练习要点
- if-else 分支结构：
if (布尔表达式) { ... } else { ... } - 算术运算符：
+、-、*、/、%、++、-- - 整数除法截断：两个整数相除结果直接截断小数，不会四舍五入
- 0 不能做除数：整数除 0 会抛异常，浮点数除 0 得
Infinity/NaN - 取模运算：
%获取余数，结果符号与被除数相同 - 自增
++/ 自减--：符号在前先运算，符号在后先赋值 - 赋值运算符：
=、+=、-=、*=、/=、%= - 复合赋值运算符隐含强制类型转换
- 比较运算符：
>、<、==、>=、<=、!=，结果都是boolean类型 - 条件判断中比较相等使用
==，不要写成= - 浮点数精度陷阱：
0.1 + 0.2 == 0.3为false，浮点数不能直接用==比较 - 解决方案：使用
printf格式化输出，或设置误差范围 - 掌握
if - else if - else多分支结构 - 学会利用
%取模运算判断奇偶、倍数关系 - 学会利用
/整除和%取余进行单位换算（分钟 → 小时 + 分钟） - 逻辑运算符：
&（与）、|（或）、!（非）、&&（短路与）、||（短路或）、^（异或） &vs&&：&两边都要计算，&&左边为false时右边不执行（短路）|vs||：|两边都要计算，||左边为true时右边不执行（短路）^异或：两边相同为false，不同为true!非：单目运算符，取反操作- 位运算符：
&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）、>>>（无符号右移） - 左移
<<：高位丢失，低位补 0，相当于 ×2ⁿ - 右移
>>：低位丢失，高位补符号位，相当于 ÷2ⁿ（向下取整） - 无符号右移
>>>：低位丢失，高位补 0，负数会变为大正数 - 成绩等级练习：综合运用
if-else if-else+ 比较运算符 + 逻辑运算符&&实现多范围判断 - 位运算随堂练习：计算
15>>3、66<<2、75&86、63|36、-128>>>3的运行结果 - 三目运算符：
布尔表达式 ? 表达式1 : 表达式2，简化二选一赋值 - 三目 vs if-else：简单二选一赋值用三目，复杂多分支用
if-else - 运算符优先级：牢记
()最高、赋值最低，不确定时用()明确顺序
六、拓展阅读
| 概念 | 说明 |
|---|---|
| 布尔表达式 | 运算结果为 true 或 false 的表达式 |
| 算术异常 | ArithmeticException，整数除以 0 时抛出 |
Infinity |
浮点数除 0 的结果，表示无穷大 |
NaN |
Not a Number，0.0 / 0.0 的结果 |
| 复合赋值运算符 | 如 +=、-= 等，自带隐式强制类型转换 |
| 短路特性 | && 左边为 false 或 ` |
| 浮点数精度 | 浮点数在计算机中采用 IEEE 754 标准存储，存在精度误差，避免直接用 == 比较 |
| 补码 | 计算机使用补码表示负数，正数的补码 = 原码，负数的补码 = 原码取反 + 1 |
按位与 & vs 逻辑与 & |
按位与操作整型的二进制位，逻辑与操作布尔值 |
| 位运算性能 | 位运算直接操作二进制位，比算术运算性能更高，常用于底层编程 |
| 三目运算符 | 唯一的三元运算符，格式 ? :，适合简单的二选一赋值 |
| 运算符优先级 | 优先级高的运算符先执行，建议用 () 明确计算顺序 |
| 短路逻辑 vs 非短路逻辑 | &&/` |