docs: 追加Demo01~Demo04运算符与流程控制笔记到课堂笔记

- 新增 20260714-笔记.md，涵盖：
  - Demo01 流程控制 if-else 分支结构
  - Demo02 算术运算符（+、-、*、/、%、++、--）
  - Demo03 赋值运算符（=、+=、-=、*=、/=、%=）
  - Demo04 比较运算符（>、<、==、>=、<=、!=）
  - 综合练习（奇偶判断、倍数判断、正负判断、分钟转换）
- 更新 README.md 添加 2026-07-14 笔记和代码链接

README.md

@@ -23,6 +23,7 @@
 | 日期 | 笔记 |
 |------|------|
 | 2026-07-13 | [JavaSE 基础入门](./课堂笔记/01-JavaSE基础-笔记/20260713-笔记.md) |
+| 2026-07-14 | [Java 运算符与流程控制](./课堂笔记/01-JavaSE基础-笔记/20260714-笔记.md) |
 
 ## 二、授课代码
 
@@ -32,4 +33,5 @@
 | 2026-07-09 | 流程控制与循环结构 | `java-prep-bootcamp` | [`com.lovecoding.day03`](./授课代码/java-prep-bootcamp/src/com/lovecoding/day03/) |
 | 2026-07-10 | 进制与进制转换 | `java-prep-bootcamp` | [`com.lovecoding.day04`](./授课代码/java-prep-bootcamp/src/com/lovecoding/day04/) |
 | 2026-07-13 | JavaSE 基础入门 | `javaSE-260713-FirstJava` | [默认包](./授课代码/javaSE-260713-FirstJava/src/) |
+| 2026-07-14 | Java 运算符与流程控制 | `c260714` | [默认包](./授课代码/c260714/src/) |
 

授课代码/c260714/.gitignore

@@ -0,0 +1,30 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+.kotlin
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

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

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

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

@@ -0,0 +1,122 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description Java运算符-
+ * @create 2026/7/14
+ */
+public class Demo02 {
+    /*
+        运算符：
+        按照操作数的数量分类：
+            一元运算符：  ++      --
+            二元运算符
+            三元运算符
+
+        按照功能分类：
+            1、算术运算符 ✅
+            2、赋值运算符 ✅
+            3、比较运算符
+            4、逻辑运算付
+            5、位运算符
+            6、三目运算符
+
+     */
+    public static void main(String[] args) {
+        /*
+            1、算术运算符
+            +   加号              5+5                 10
+            -   减号              5-3                 2
+            *   乘号              5*3                 15
+            /   除号              5/3                 1   (不是1.66666...7)
+            %   取余/取模          5%3                 2   (5 / 3 = 1 余 2) 获取的就是余数
+            ++  自增              ++i / i++       一元运算符   因为只有一个数参与运算
+            --  自减              --i / i--
+         */
+        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);   //两个整数相除，结果为整数，会直接截断小数部分，只保留整数。
+        System.out.println(10/3.0); //如果有一个小数参与，结果就为小数
+        System.out.println(10.0/3);
+
+        // 0 不能做除数
+        //System.out.println(3/0);    //会出现ArithmeticException 算术异常 （异常会让程序停止）
+        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
+        //以上 都表示 0 不能做除数，做了除数会有错误
+
+        //取模运算 %
+        System.out.println(10%3);   //1
+        System.out.println(-10%3);  // -1 返回的符号和被除数相同
+
+
+        // 自增和自减
+        //  ++ 表示这个数增加1 -- 表示这个数减1
+        //  ++ 符号在前，就会先进行自增运算，后进行其他操作（比如赋值）
+        //  ++ 符号在后，就会先进行其他操作，后进行自增运算
+
+        int i=10;
+        int j=++i;  //  赋值的数值 是自增运算后的 数值
+        int k=i++;  //  赋值的数值 是自增运算前的 数值
+        System.out.println(j);
+        System.out.println(k);
+        System.out.println(i);
+
+
+        //1、定义一个整数7，判断是奇数还是偶数（奇数不能被2整除，偶数能被2整除）
+        int i1=7;
+        if (i1%2==0){
+            System.out.println("偶数");
+        }else {
+            System.out.println("奇数");
+        }
+        //2、定义两个整数 a1和b1，判断a1是否是b1的倍数（a1能不能被b1整除）
+        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、定义一个总分钟数比如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小时");
+        }
+
+
+
+
+
+
+
+
+
+
+    }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * @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);
+        x*=3;
+        System.out.println(x);  //x=x*3
+
+        //复合运算符隐含强制类型转换
+        byte a=15;
+        //a=a+6;  //因为a+6的结果被提升为int类型，再赋值给byte类型的a需要强制类型转换
+        a+=6;   // 复合赋值运算符 隐含就帮我们做了强制类型转换。
+
+    }
+}

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

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

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

@@ -0,0 +1,569 @@
+# 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`）。
+> 判断相等使用 `==`（双等号），**不能**写成 `=`（单等号是赋值）。
+
+**完整代码 —— 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
+         */
+    }
+}
+```
+
+---
+
+## 三、综合练习（Demo02）
+
+结合 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`（取余）。
+
+---
+
+## 四、完整代码汇总
+
+### 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
+         */
+    }
+}
+```
+
+---
+
+## 五、随堂练习要点
+
+1. **if-else 分支结构**：`if (布尔表达式) { ... } else { ... }`
+2. **算术运算符**：`+`、`-`、`*`、`/`、`%`、`++`、`--`
+3. **整数除法截断**：两个整数相除结果直接截断小数，不会四舍五入
+4. **0 不能做除数**：整数除 0 会抛异常，浮点数除 0 得 `Infinity` / `NaN`
+5. **取模运算**：`%` 获取余数，结果符号与被除数相同
+6. **自增 `++` / 自减 `--`**：符号在前先运算，符号在后先赋值
+7. **赋值运算符**：`=`、`+=`、`-=`、`*=`、`/=`、`%=`
+8. **复合赋值运算符隐含强制类型转换**
+9. **比较运算符**：`>`、`<`、`==`、`>=`、`<=`、`!=`，结果都是 `boolean` 类型
+10. **条件判断中比较相等使用 `==`**，不要写成 `=`
+11. 掌握 `if - else if - else` 多分支结构
+12. 学会利用 `%` 取模运算判断奇偶、倍数关系
+13. 学会利用 `/` 整除和 `%` 取余进行单位换算（分钟 → 小时 + 分钟）
+
+---
+
+## 六、拓展阅读
+
+| 概念 | 说明 |
+|------|------|
+| **布尔表达式** | 运算结果为 `true` 或 `false` 的表达式 |
+| **算术异常** | `ArithmeticException`，整数除以 0 时抛出 |
+| **`Infinity`** | 浮点数除 0 的结果，表示无穷大 |
+| **`NaN`** | Not a Number，`0.0 / 0.0` 的结果 |
+| **复合赋值运算符** | 如 `+=`、`-=` 等，自带隐式强制类型转换 |