docs: 追加Demo04-Demo05比较/逻辑运算符新内容到课堂笔记

- Demo04.java 追加浮点数精度陷阱（0.1+0.2 != 0.3）
- Demo05.java 新增逻辑运算符（&、|、!、&&、||、^）
- 更新 20260714-笔记.md 追加逻辑运算符章节和浮点数精度陷阱
- Demo02.java 注释修正（逻辑运算付→逻辑运算符）
- 更新 README.md 标记逻辑运算符为已完成

授课代码/c260714/src/Demo02.java

@@ -16,8 +16,8 @@ public class Demo02 {
         按照功能分类：
             1、算术运算符 ✅
             2、赋值运算符 ✅
-            3、比较运算符
-            4、逻辑运算付
+            3、比较运算符 ✅
+            4、逻辑运算付 ✅
             5、位运算符
             6、三目运算符
 

授课代码/c260714/src/Demo04.java

@@ -15,5 +15,16 @@ public class Demo04 {
            <=       小于等于       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);
+        System.out.println(b2);
+        //输出保留2位小数
+        System.out.printf("%.1f",b1);
+
+
     }
 }

授课代码/c260714/src/Demo05.java

@@ -0,0 +1,53 @@
+/**
+ * @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
+
+    }
+}

课堂笔记/01-JavaSE基础-笔记/20260714-笔记.md

@@ -123,7 +123,7 @@ public class Demo01 {
 | **算术运算符** | ✅ 本次课程重点 |
 | **赋值运算符** | ✅ 本次课程重点 |
 | **比较运算符** | ✅ 本次课程重点 |
-| 逻辑运算符 | 后续课程讲解 |
+| **逻辑运算符** | ✅ 本次课程重点 |
 | 位运算符 | 后续课程讲解 |
 | 三目运算符 | 后续课程讲解 |
 
@@ -291,6 +291,26 @@ public class Demo03 {
 > **注意**：比较运算符的结果都是 `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
@@ -311,13 +331,156 @@ public class Demo04 {
            <=       小于等于       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
     }
 }
 ```
 
 ---
 
-## 三、综合练习（Demo02）
+### 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
+    }
+}
+```
 
 结合 if-else 分支结构与算术运算符，完成以下练习：
 
@@ -514,7 +677,7 @@ public class Demo03 {
 }
 ```
 
-### Demo04.java — 比较运算符
+### Demo04.java — 比较运算符 + 浮点数精度陷阱
 
 ```java
 /**
@@ -534,6 +697,74 @@ public class Demo04 {
            <=       小于等于       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
     }
 }
 ```
@@ -552,9 +783,16 @@ public class Demo04 {
 8. **复合赋值运算符隐含强制类型转换**
 9. **比较运算符**：`>`、`<`、`==`、`>=`、`<=`、`!=`，结果都是 `boolean` 类型
 10. **条件判断中比较相等使用 `==`**，不要写成 `=`
-11. 掌握 `if - else if - else` 多分支结构
-12. 学会利用 `%` 取模运算判断奇偶、倍数关系
-13. 学会利用 `/` 整除和 `%` 取余进行单位换算（分钟 → 小时 + 分钟）
+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. **`!` 非**：单目运算符，取反操作
 
 ---
 
@@ -567,3 +805,5 @@ public class Demo04 {
 | **`Infinity`** | 浮点数除 0 的结果，表示无穷大 |
 | **`NaN`** | Not a Number，`0.0 / 0.0` 的结果 |
 | **复合赋值运算符** | 如 `+=`、`-=` 等，自带隐式强制类型转换 |
+| **短路特性** | `&&` 左边为 `false` 或 `||` 左边为 `true` 时，右边不再运算 |
+| **浮点数精度** | 浮点数在计算机中采用 IEEE 754 标准存储，存在精度误差，避免直接用 `==` 比较 |