# JavaSE 基础 — Day02 笔记 > **日期**：2026-07-14 > **项目**：`c260714` > **作者**：WanJL --- ## 一、流程控制（if-else） ### 1. 程序的结构 程序的结构分为三种： | 结构 | 说明 | |------|------| | **顺序结构** | 代码从左到右、从上到下依次执行 | | **分支结构** | 为代码设定条件，满足条件执行 A，不满足执行 B | | **循环结构** | 重复执行某段代码（后续课程讲解） | ### 2. if-else 分支结构 **核心思想**：告诉程序在什么情况下做什么事。 > 如果下雨，要打伞；否则就不打伞。 **语法格式**： ```java if (布尔表达式) { // 条件为 true 时执行的代码 } else { // 条件为 false 时执行的代码 } ``` > **布尔表达式**：运算结果为 `boolean` 类型值（`true` 或 `false`）的表达式。 **示例**：判断一个整数是正数还是负数 ```java int a = 15; if (a > 0) { System.out.println("正数"); } else { System.out.println("负数"); } ``` **完整代码 —— Demo01.java** ```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 分支） 1. 判断年龄 `age` 是否大于 30 岁 2. 判断年龄 `age2` 是否成年（≥ 18 岁） 3. 判断分数 `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--` | 一元运算符 | #### 基本运算示例 ```java 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 ``` #### 常见问题 ##### ① 整数除法截断 两个整数相除，结果为整数，会**直接截断小数部分**，只保留整数。 ```java System.out.println(10 / 3); // 3（截断小数） System.out.println(10 / 3.0); // 3.3333333333333335（有小数参与，结果为小数） System.out.println(10.0 / 3); // 3.3333333333333335 ``` ##### ② 0 不能做除数 整数除法中，除数为 0 会抛出异常： ```java // System.out.println(3 / 0); // ArithmeticException（算术异常，程序停止） ``` 但浮点数除法中，除数为 0 有特殊结果： ```java 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，非数字） ``` ##### ③ 取模运算 `%` ```java System.out.println(10 % 3); // 1 System.out.println(-10 % 3); // -1（结果的符号与被除数相同） ``` > **取模规则**：`a % b` 的结果符号与 `a`（被除数）的符号一致。 ##### ④ 自增 `++` 与自减 `--` - `++` 表示这个数增加 1，`--` 表示这个数减少 1 - **符号在前**（`++i`）：先进行自增运算，再进行其他操作（如赋值） - **符号在后**（`i++`）：先进行其他操作，再进行自增运算 ```java 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` | #### 示例 ```java int x = 10; x += 5; // x = x + 5 → 15 System.out.println(x); x *= 3; // x = x * 3 → 45 System.out.println(x); ``` #### 复合运算符隐含强制类型转换 ```java byte a = 15; // a = a + 6; // ❌ 编译错误：a + 6 结果被提升为 int，赋值给 byte 需强制转换 a += 6; // ✅ 复合赋值运算符隐含强制类型转换 ``` > **重要**：复合赋值运算符（`+=`、`-=` 等）内部隐含了强制类型转换，不需要手动强转。 **完整代码 —— Demo03.java** ```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`）。 > 判断相等使用 `==`（双等号），**不能**写成 `=`（单等号是赋值）。 #### 浮点数精度陷阱 使用 `==` 比较浮点数时要特别小心，因为浮点数存在**精度误差**： ```java 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` 格式化输出，或设置误差范围进行比较。 ```java System.out.printf("%.1f", b1); // 输出 0.3（保留1位小数） ``` **完整代码 —— Demo04.java** ```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`。 ```java 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`。 ```java 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`，反之亦然。 ```java System.out.println(!true); // false System.out.println(!false); // true ``` #### ④ `&&` 短路与（Short-circuit AND） 作用与 `&` 相同，但具有**短路特性**：如果符号左边为 `false`，右边**不再运算**，直接返回 `false`。 ```java 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`。 ```java 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`。 ```java 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** ```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 | 3` | 对应位同时为 `0` 时结果为 `0`，否则为 `1` | | `^` | 按位异或 | `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 ``` ```java System.out.println(5 & 3); // 1 ``` #### ② `|` 按位或 符号左右两边的数的每个二进制位，如果同时为 `0`，则运算结果为 `0`，否则为 `1`，最后把二进制数转换为十进制数。 ``` 0101 ← 5 | 0011 ← 3 -------- 0111 → 7 ``` ```java System.out.println(5 | 3); // 7 ``` #### ③ `^` 按位异或 符号左右两边的数的每个二进制位，如果相同则为 `0`，不同则为 `1`，最后把二进制数转换为十进制数。 ``` 0101 ← 5 ^ 0011 ← 3 -------- 0110 → 6 ``` ```java System.out.println(5 ^ 3); // 6 ``` #### ④ `~` 按位取反 单目运算符，符号右边的数的二进制位，如果为 `0` 则运算结果为 `1`，如果为 `1` 则运算结果为 `0`。 ``` ~ 0000 0101 ← 5（8位二进制） ------------ 1111 1010 → -6 ``` ```java System.out.println(~5); // -6 ``` > **注意**：`~5` 的结果是 `-6`，因为计算机使用**补码**表示负数。 #### ⑤ `<<` 按位左移 把符号左边的数的二进制位，向左移动符号右边指定的位数，空出来的位置补 `0`。 ``` 0101 ← 5 << 1 -------- 1010 → 10（相当于 5 × 2¹ = 10） ``` ```java System.out.println(5 << 3); // 40（相当于 5 × 2³ = 40） ``` > **左移规律**：左移 n 位相当于乘以 2ⁿ（在不溢出的前提下）。 #### ⑥ `>>` 按位右移 把符号左边的数的二进制位，向右移动符号右边指定的位数，空出来的位置补**符号位**的值。 > 二进制最左侧为最高位（符号位）：`0` 表示正数，`1` 表示负数。 ``` 0101 ← 5 >> 1 -------- 0010 → 2（相当于 5 ÷ 2¹ = 2，向下取整） ``` ```java System.out.println(5 >> 3); // 0（相当于 5 ÷ 2³ = 0，向下取整） ``` > **右移规律**：右移 n 位相当于除以 2ⁿ（向下取整）。 #### ⑦ `>>>` 无符号右移 把符号左边的数的二进制位，向右移动符号右边指定的位数，空出来的位置补 `0`。对负数操作后会得到大正数。 ``` 1111 1011 ← -5（8位表示） >>> 1 ----------- 0111 1101 → 正数 ``` ```java System.out.println(-5 >>> 1); // 2147483645（大正数） ``` **位运算总结：** | 运算 | 效果 | 规律 | |------|------|------| | 左移 `<<` | 高位丢失，低位补 0 | 相当于 **×2ⁿ** | | 右移 `>>` | 低位丢失，高位补符号位 | 相当于 **÷2ⁿ**（向下取整） | | 无符号右移 `>>>`| 低位丢失，高位补 0 | 负数会变为大正数 | #### 随堂练习：位运算 运行以下代码，查看结果，并验证位运算规律： ```java 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** ```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 中唯一一个需要**三个操作数**的运算符。 **语法格式：** ```java 布尔表达式 ? 表达式1 : 表达式2 ``` **执行逻辑：** - 如果布尔表达式结果为 `true`，执行（返回）**表达式1** - 如果布尔表达式结果为 `false`，执行（返回）**表达式2** #### 示例 ```java System.out.println(15 > 8 ? "hello" : "哈哈哈哈"); // hello System.out.println(15 > 8 ? 6 : "哈哈哈哈"); // 6（返回 int） ``` ```java 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** ```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** ```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：判断奇偶数 ```java int i1 = 7; if (i1 % 2 == 0) { System.out.println("偶数"); } else { System.out.println("奇数"); } ``` > **思路**：奇数不能被 2 整除（`% 2 == 1`），偶数能被 2 整除（`% 2 == 0`）。 ### 练习 2：判断倍数关系 ```java 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 ```java 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 小时。 ```java 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 | 不及格 | | 其他 | 分数错误 | ```java 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 — 流程控制 ```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 — 算术运算符 + 综合练习 ```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 — 赋值运算符 ```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 — 比较运算符 + 浮点数精度陷阱 ```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 — 逻辑运算符 + 成绩等级练习 ```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 — 位运算符 ```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 — 三目运算符 ```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 — 运算符优先级 ```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 各种赋值 = += -= */ } } ``` --- ## 五、随堂练习要点 1. **if-else 分支结构**：`if (布尔表达式) { ... } else { ... }` 2. **算术运算符**：`+`、`-`、`*`、`/`、`%`、`++`、`--` 3. **整数除法截断**：两个整数相除结果直接截断小数，不会四舍五入 4. **0 不能做除数**：整数除 0 会抛异常，浮点数除 0 得 `Infinity` / `NaN` 5. **取模运算**：`%` 获取余数，结果符号与被除数相同 6. **自增 `++` / 自减 `--`**：符号在前先运算，符号在后先赋值 7. **赋值运算符**：`=`、`+=`、`-=`、`*=`、`/=`、`%=` 8. **复合赋值运算符隐含强制类型转换** 9. **比较运算符**：`>`、`<`、`==`、`>=`、`<=`、`!=`，结果都是 `boolean` 类型 10. **条件判断中比较相等使用 `==`**，不要写成 `=` 11. **浮点数精度陷阱**：`0.1 + 0.2 == 0.3` 为 `false`，浮点数不能直接用 `==` 比较 12. **解决方案**：使用 `printf` 格式化输出，或设置误差范围 13. 掌握 `if - else if - else` 多分支结构 14. 学会利用 `%` 取模运算判断奇偶、倍数关系 15. 学会利用 `/` 整除和 `%` 取余进行单位换算（分钟 → 小时 + 分钟） 16. **逻辑运算符**：`&`（与）、`|`（或）、`!`（非）、`&&`（短路与）、`||`（短路或）、`^`（异或） 17. **`&` vs `&&`**：`&` 两边都要计算，`&&` 左边为 `false` 时右边不执行（短路） 18. **`|` vs `||`**：`|` 两边都要计算，`||` 左边为 `true` 时右边不执行（短路） 19. **`^` 异或**：两边相同为 `false`，不同为 `true` 20. **`!` 非**：单目运算符，取反操作 21. **位运算符**：`&`（按位与）、`|`（按位或）、`^`（按位异或）、`~`（按位取反）、`<<`（左移）、`>>`（右移）、`>>>`（无符号右移） 22. **左移 `<<`**：高位丢失，低位补 0，相当于 **×2ⁿ** 23. **右移 `>>`**：低位丢失，高位补符号位，相当于 **÷2ⁿ**（向下取整） 24. **无符号右移 `>>>`**：低位丢失，高位补 0，负数会变为大正数 25. **成绩等级练习**：综合运用 `if-else if-else` + 比较运算符 + 逻辑运算符 `&&` 实现多范围判断 26. **位运算随堂练习**：计算 `15>>3`、`66<<2`、`75&86`、`63|36`、`-128>>>3` 的运行结果 27. **三目运算符**：`布尔表达式 ? 表达式1 : 表达式2`，简化二选一赋值 28. **三目 vs if-else**：简单二选一赋值用三目，复杂多分支用 `if-else` 29. **运算符优先级**：牢记 `()` 最高、赋值最低，不确定时用 `()` 明确顺序 --- ## 六、拓展阅读 | 概念 | 说明 | |------|------| | **布尔表达式** | 运算结果为 `true` 或 `false` 的表达式 | | **算术异常** | `ArithmeticException`，整数除以 0 时抛出 | | **`Infinity`** | 浮点数除 0 的结果，表示无穷大 | | **`NaN`** | Not a Number，`0.0 / 0.0` 的结果 | | **复合赋值运算符** | 如 `+=`、`-=` 等，自带隐式强制类型转换 | | **短路特性** | `&&` 左边为 `false` 或 `||` 左边为 `true` 时，右边不再运算 | | **浮点数精度** | 浮点数在计算机中采用 IEEE 754 标准存储，存在精度误差，避免直接用 `==` 比较 | | **补码** | 计算机使用补码表示负数，正数的补码 = 原码，负数的补码 = 原码取反 + 1 | | **按位与 `&` vs 逻辑与 `&`** | 按位与操作整型的二进制位，逻辑与操作布尔值 | | **位运算性能** | 位运算直接操作二进制位，比算术运算性能更高，常用于底层编程 | | **三目运算符** | 唯一的三元运算符，格式 `? :`，适合简单的二选一赋值 | | **运算符优先级** | 优先级高的运算符先执行，建议用 `()` 明确计算顺序 | | **短路逻辑 vs 非短路逻辑** | `&&`/`||` 有短路效果，`&`/`|` 无短路效果，性能上短路更优 |