feat: 新增20260715课程：switch分支语句、循环结构及课后作业讲解

- 新增 Demo01.java（switch 传统语法、增强语法、switch 表达式）
- 新增 Demo02.java（for/while/do...while 三种循环结构）
- 新增 HomeWork01~07（7月14日课后作业解答）
- 新增 20260715-笔记.md（switch 分支与循环结构笔记）
- 更新 README.md 添加 7月15日课程记录

README.md

@@ -24,6 +24,7 @@
 |------|------|
 | 2026-07-13 | [JavaSE 基础入门](./课堂笔记/01-JavaSE基础-笔记/20260713-笔记.md) |
 | 2026-07-14 | [Java 运算符与流程控制](./课堂笔记/01-JavaSE基础-笔记/20260714-笔记.md) |
+| 2026-07-15 | [switch分支与循环结构](./课堂笔记/01-JavaSE基础-笔记/20260715-笔记.md) |
 
 ## 二、授课代码
 
@@ -34,4 +35,5 @@
 | 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/) |
+| 2026-07-15 | switch分支与循环结构 | `c260715` | [默认包](./授课代码/c260715/src/) |
 

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

@@ -0,0 +1,109 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 流程控制-分支语句-switch
+ * @create 2026/7/15
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        /*
+            switch语句和if不一样，不是范围的匹配，而是针对某个值的匹配，格式：
+            switch(变量){
+                case 常量1:
+                    代码块;
+                    break;
+                case 常量2:
+                    代码块;
+                    break;
+                case 常量n:
+                    代码块;
+                    break;
+                default:
+                    代码块;
+            }
+            如果变量的值和常量1相等，就执行对应的代码块，...如果和n相等就执行对应代码块，
+            如果都不相等，就执行default中代码块
+
+         */
+        int a=3;
+        switch (a){
+            case 1:
+                System.out.println("a=1");
+                break;  //break的作用，是在执行完对应的代码块后，后面的代码就不要执行了，直接跳出switch
+            case 2:
+                System.out.println("a=2");
+                break;
+            case 3:
+                System.out.println("a=3");
+                break;
+            default:
+                System.out.println("不知道");
+        }
+        /*
+            练习题：定义一个变量，使用switch判断1~7，分别输出 星期一~星期日
+         */
+
+        int b=3;
+        switch (b) {
+            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;
+            default:
+                System.out.println("不知道");
+        }
+        /*
+            JDK17~21 增强的switch语句：可以使用任何的基本数据类型、字符串String、枚举
+         */
+        String day="1";
+        switch (day){
+            case "1","2","3","4","5" -> System.out.println("工作日");
+            case "6","7" -> System.out.println("休息日");
+        }
+        // 使用switch匹配，匹配到了，就输出对应的语句
+        switch (day){
+            case "1" -> {
+                System.out.println("星期一");
+                System.out.println("周一");
+                System.out.println("天不错");
+            }
+            case "2" -> System.out.println("星期二");
+            case "3" -> System.out.println("星期三");
+            case "4" -> System.out.println("星期四");
+            case "5" -> System.out.println("星期五");
+            case "6" -> System.out.println("星期六");
+            case "7" -> System.out.println("星期日");
+        }
+        // 使用switch匹配，匹配到了，就返回对应的值，这个值，可能要拿来做其他的操作
+        String dd="1";
+        String s=switch (dd){
+            case "1" -> "星期一";
+            case "2" -> "星期二";
+            case "3" -> "星期三";
+            case "4" -> "星期四";
+            case "5" -> "星期五";
+            case "6" -> "星期六";
+            case "7" -> "星期日";
+            default -> "不知道";
+        };
+        System.out.println("今天是"+s+"，天气真不错");
+    }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description 流程控制-循环结构
+ * @create 2026/7/15
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        /*
+            循环结构，满足条件就不停的循环执行代码
+            Java三种循环结构：
+            for循环：
+                for(初始化语句;循环条件;迭代语句){
+                    循环体;
+                }
+                for(int i=0;i<10;i++){
+                    System.out.println(i);
+                }
+            执行步骤：
+                1、执行初始化语句：int i=0;
+                2、执行循环条件：i<10;  如果结果为true，就执行第3步。如果结果为false，就执行最后一步
+                3、执行循环体：System.out.println(i);
+                4、执行迭代语句：i++ ，然后再跳转回第2步。
+                5、跳出循环，继续执行后面的代码
+
+            while循环：
+                初始化语句;
+                while(循环条件){
+                    循环体;
+                    迭代语句;
+                }
+                int i=0;
+                while(i<10){
+                    System.out.println(i);
+                    i++;
+                }
+               使用while循环或do...while循环的时候，一定不要忘了写i++ 迭代语句。否则会一直循环，也就是死循环。
+
+            do...while循环：
+                初始化语句;
+                do{
+                    循环体;
+                    迭代语句;
+                }while(循环条件);
+                int i=0;
+                do{
+                    System.out.println(i);
+                    i++;
+                }while(i<10);
+                do...while 因为循环条件在最后，也就是最后才会判断是否满足循环条件，是否要继续循环。
+                所以循环体一定会执行一次。所以，for和while是先判断，后执行。do...while是先执行后判断。
+
+         */
+        /*
+            练习：分别使用for、while和do...while 循环1~100之间的整数。
+         */
+    }
+}

授课代码/c260715/src/HomeWork01.java

@@ -0,0 +1,18 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork05
+ * @description 7月14日课后作业-判断年份
+ * @create 2026/7/15
+ */
+public class HomeWork01 {
+    public static void main(String[] args) {
+        int year = 2000;    //年份
+        //判断 是否是闰年
+        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
+            System.out.println(year + "是闰年");
+        } else {
+            System.out.println(year + "是平年");
+        }
+    }
+}

授课代码/c260715/src/HomeWork02.java

@@ -0,0 +1,13 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWord02
+ * @description  7月14日课后作业-三个数比大小
+ * @create 2026/7/15
+ */
+public class HomeWork02 {
+    public static void main(String[] args) {
+        int a=10,b=15,c=20;
+        System.out.println(a>b?(a>c?a:c):(b>c?b:c));
+    }
+}

授课代码/c260715/src/HomeWork04.java

@@ -0,0 +1,20 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork04
+ * @description  7月14日课后作业-水仙花数
+ * @create 2026/7/15
+ */
+public class HomeWork04 {
+    public static void main(String[] args) {
+        int number=153; //定义一个整数变量
+        int bai=number/100; //百位
+        int shi=number/10%10;   //十位
+        int ge=number%10;   //个位
+        if (number==bai*bai*bai+shi*shi*shi+ge*ge*ge){
+            System.out.println(number+"是水仙花数");
+        }else {
+            System.out.println(number + "不是水仙花数");
+        }
+    }
+}

授课代码/c260715/src/HomeWork05.java

@@ -0,0 +1,30 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork05
+ * @description  7月14日课后作业-简易计算器
+ * @create 2026/7/15
+ */
+public class HomeWork05 {
+    public static void main(String[] args) {
+        int a=15,b=20;
+        char operator='/';
+        if (operator=='+'){
+            System.out.println(a+b);
+        }else if (operator=='-'){
+            System.out.println(a-b);
+        }else if (operator=='*'){
+            System.out.println(a*b);
+        }else if (operator=='/'){
+            if (b==0){
+                System.out.println("除数不能为0");
+            }
+            System.out.println(a/b);
+        }else if (operator=='%'){
+            if (b==0){
+                System.out.println("除数不能为0");
+            }
+            System.out.println(a%b);
+        }
+    }
+}

授课代码/c260715/src/HomeWork07.java

@@ -0,0 +1,59 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork07
+ * @description   7月14日课后作业-数字加密系统
+ * @create 2026/7/15
+ */
+public class HomeWork07 {
+    public static void main(String[] args) {
+        int number=1234;
+        //加密规则-0 获取每个位的数
+        int qian=number/1000; //百位
+        int bai=number/100%10; //百位
+        int shi=number/10%10;   //十位
+        int ge=number%10;   //个位
+        System.out.print("原始数字："+qian);
+        System.out.print(bai);
+        System.out.print(shi);
+        System.out.println(ge);
+
+        //加密规则-1 对每个数字加5
+        qian+=5;
+        bai+=5;
+        shi+=5;
+        ge+=5;
+        System.out.print("每位+5后："+qian);
+        System.out.print(bai);
+        System.out.print(shi);
+        System.out.println(ge);
+        //加密规则-2 对10取余
+        qian%=10;
+        bai%=10;
+        shi%=10;
+        ge%=10;
+        System.out.print("取余10后："+qian);
+        System.out.print(bai);
+        System.out.print(shi);
+        System.out.println(ge);
+        //加密规则-3 第1位和第4位互换，第2位和第3位互换
+
+        qian=qian+ge;
+        ge=qian-ge;
+        qian=qian-ge;
+
+        bai=bai+shi;
+        shi=bai-shi;
+        bai=bai-shi;
+        System.out.print("交换后："+qian);
+        System.out.print(bai);
+        System.out.print(shi);
+        System.out.println(ge);
+        System.out.println("加密结果："+qian+bai+shi+ge);
+        /*
+            0b开头的整数  二进制数
+            0开头的整数   八进制数
+            0x开头的整数 十六进制数
+         */
+    }
+}

课后作业/2026年7月14日-作业.md

@@ -0,0 +1,310 @@
+# 2026-07-14 JavaSE 课后作业
+
+> **课程内容**：流程控制、运算符（算术/赋值/比较/逻辑/位/三目）、运算符优先级  
+> **提交方式**：在 `提交\姓名\` 目录下创建对应的 Java 源文件  
+> **截止时间**：下次上课前
+
+---
+
+## 一、基础题（必做）
+
+### 题目 1：判断闰年
+
+**难度**：⭐  
+**知识点**：if-else、逻辑运算符、算术运算符
+
+从键盘输入一个年份（整数），判断该年份是否为闰年。
+
+**闰年规则（满足其一即可）**：
+1. 能被 4 整除但不能被 100 整除；或者
+2. 能被 400 整除
+
+**要求**：
+- 定义 `int year` 变量并赋值为要判断的年份
+- 使用 `if-else` 分支结构
+- 使用逻辑运算符 `&&` 和 `||`
+- 输出格式：`xxxx 年是闰年` 或 `xxxx 年不是闰年`
+
+**示例输出**：
+```
+2024 年是闰年
+2025 年不是闰年
+```
+
+---
+
+### 题目 2：三个数比大小
+
+**难度**：⭐  
+**知识点**：三目运算符、if-else
+
+定义三个整数变量 `a`、`b`、`c`，找出其中的最大值并输出。
+
+**要求**：
+- 方法一：使用三目运算符嵌套实现
+- 方法二：使用 `if-else` 实现
+- 两种方法都写在同一个文件中（分别注释标注）
+
+**示例输出**：
+```
+三个数中最大的值是: 78
+```
+
+---
+
+### 题目 3：位运算练习
+
+**难度**：⭐  
+**知识点**：位运算符
+
+定义两个整数 `int m = 27`、`int n = 15`，计算并输出以下位运算的结果，**并在注释中写出每一步的二进制运算过程**。
+
+```java
+int m = 27, n = 15;
+// 1. m & n  (按位与)
+// 2. m | n  (按位或)
+// 3. m ^ n  (按位异或)
+// 4. ~m     (按位取反)
+// 5. m << 2 (左移2位)
+// 6. n >> 2 (右移2位)
+```
+
+**示例注释格式**：
+
+```java
+// 27 & 15
+//  0001 1011  ← 27
+// & 0000 1111  ← 15
+// --------
+//  0000 1011  → 11
+System.out.println("27 & 15 = " + (27 & 15));  // 11
+```
+
+---
+
+## 二、进阶题（必做）
+
+### 题目 4：水仙花数判定
+
+**难度**：⭐⭐  
+**知识点**：算术运算符（`/`、`%`）、if-else
+
+"水仙花数"是指一个三位数，其各位数字的立方和等于该数本身。例如：`153 = 1³ + 5³ + 3³`。
+
+**要求**：
+
+- 定义一个三位数整数 `int num = 153;`（可自行修改测试其他数字）
+- 使用 `/` 和 `%` 分别取出个位、十位、百位
+- 判断是否为水仙花数，并输出结果
+
+**示例输出**：
+```
+153 是水仙花数
+```
+
+**提示**：
+```java
+int num = 153;
+int bai = num / 100;        // 百位
+int shi = num / 10 % 10;    // 十位
+int ge  = num % 10;         // 个位
+```
+
+---
+
+### 题目 5：简易计算器
+
+**难度**：⭐⭐  
+**知识点**：if-else、算术运算符、Scanner（选做）
+
+定义两个整数 `a` 和 `b`，以及一个字符变量 `operator`（取值为 `'+'`、`'-'`、`'*'`、`'/'`、`'%'`），根据运算符输出对应的运算结果。
+
+**要求**：
+
+- 使用 `if-else if-else` 多分支判断
+- 除号为 `/` 时，判断除数是否为 0，如果是则输出"除数不能为 0"
+- 取模为 `%` 时，同样判断除数是否为 0
+
+**示例输出 1**：
+```
+a = 20, b = 7, operator = '%'
+20 % 7 = 6
+```
+
+**示例输出 2**：
+```
+a = 20, b = 0, operator = '/'
+除数不能为 0
+```
+
+---
+
+### 题目 6：成绩等级判定（升级版）
+
+**难度**：⭐⭐  
+**知识点**：if-else if-else、逻辑运算符、三目运算符
+
+结合课堂练习的成绩等级判定，增加以下功能：
+
+**要求**：
+
+1. 定义 `double score = 85.5;`（可自行修改测试）
+2. 使用 `if-else` 实现以下等级判定：
+
+| 分数范围 | 等级 | 评价语 |
+|---------|------|--------|
+| 90 ≤ score ≤ 100 | A | 优秀，继续保持！ |
+| 80 ≤ score < 90 | B | 良好，再接再厉！ |
+| 70 ≤ score < 80 | C | 中等，还需努力！ |
+| 60 ≤ score < 70 | D | 及格，危险边缘！ |
+| 0 ≤ score < 60 | E | 不及格，加油啊！ |
+| 其他 | 无效 | 分数错误！ |
+
+3. 额外使用**三目运算符**判断该成绩是否及格（≥ 60 为及格），并输出结果
+4. 输出格式参考如下：
+
+**示例输出**：
+```
+成绩: 85.5 分
+等级: B - 良好，再接再厉！
+是否及格: 是
+```
+
+---
+
+## 三、挑战题（选做）
+
+### 题目 7：数字加密系统
+
+**难度**：⭐⭐⭐  
+**知识点**：算术运算符、位运算符、三目运算符、综合运用
+
+设计一个简单的 4 位数字加密系统。
+
+**加密规则**：
+
+1. 输入一个 4 位整数（如 `1234`）
+2. 对每一位数字进行以下处理：
+   - 每个数字加 5
+   - 对 10 取余
+   - 将第 1 位与第 4 位交换，第 2 位与第 3 位交换
+3. 输出加密后的数字
+
+**示例**：
+
+```
+原始数字: 1234
+每位+5后: 6789
+取余10后: 6789
+交换后:   9876
+加密结果: 9876
+```
+
+**要求**：
+- 分别使用算术运算符（`/`、`%`）取出每位数字
+- 使用三目运算符处理可能的负数情况
+- 输出每一步的中间结果（如上所示）
+- 可以尝试用位运算符对加密结果再次进行异或运算：`加密结果 ^ 0xAA`
+
+---
+
+### 题目 8：程序员智商测试
+
+**难度**：⭐⭐⭐  
+**知识点**：运算符优先级、自增/自减、综合运用
+
+请问以下代码的输出结果是什么？**先手算，再用 IDE 验证**。
+
+```java
+public class IQTest {
+    public static void main(String[] args) {
+        int a = 5, b = 3, c = 2;
+        int result1 = a++ + ++b * c--;
+        System.out.println("result1 = " + result1);
+        System.out.println("a = " + a + ", b = " + b + ", c = " + c);
+
+        int x = 10, y = 4;
+        boolean flag = (x > y) && (++x > 10) || (y-- < 3);
+        System.out.println("flag = " + flag);
+        System.out.println("x = " + x + ", y = " + y);
+
+        int m = 8, n = 3;
+        int r = m++ - --n + ++m - n--;
+        System.out.println("r = " + r);
+        System.out.println("m = " + m + ", n = " + n);
+    }
+}
+```
+
+**要求**：
+1. 先手算出每一步的中间结果，写在注释中
+2. 再运行代码验证，输出结果
+3. 分析 `&&` 短路特性对执行结果的影响
+
+---
+
+### 题目 9：位运算权限系统
+
+**难度**：⭐⭐⭐  
+**知识点**：位运算符（`&`、`|`、`~`、`<<`）、综合运用
+
+在计算机系统中，常用**位运算**来实现权限控制。假设一个系统的权限定义如下：
+
+```java
+// 权限定义（每个权限占用一个二进制位）
+int READ    = 1 << 0;  // 0001 = 1   读权限
+int WRITE   = 1 << 1;  // 0010 = 2   写权限
+int EXECUTE = 1 << 2;  // 0100 = 4   执行权限
+int DELETE  = 1 << 3;  // 1000 = 8   删除权限
+```
+
+**要求**：
+1. 定义一个用户权限变量 `int userPerm = 0;`（初始无权限）
+2. 使用 `|` 赋予用户读、写、执行权限：`userPerm = READ | WRITE | EXECUTE;`
+3. 使用 `&` 判断用户是否拥有某个权限（如判断是否有删除权限）
+4. 使用 `&` 和 `~` 取消用户的写权限
+5. 按以下格式输出每一步的结果：
+
+**示例输出**：
+```
+初始权限: 0 (无权限)
+赋予权限(读|写|执行): 7
+是否有删除权限? false
+取消写权限后: 5
+最终权限: 读取=有, 写入=无, 执行=有, 删除=无
+```
+
+**提示**：
+```java
+// 判断是否有写权限
+boolean hasWrite = (userPerm & WRITE) == WRITE;
+
+// 取消写权限
+userPerm = userPerm & ~WRITE;
+```
+
+---
+
+## 四、提交要求
+
+1. 在 `提交` 文件夹下创建【以你名字命名】的文件夹，然后复制 Java 源文件。比如：
+
+   ![image-20260714171229747](https://gitee.com/lk506667090/PicGo_img/raw/master/images/202607141713967.png)
+
+2. 每个题目一个文件，命名格式：`Demo_题目编号_姓名.java`
+   - 例如：`Demo_01_张三.java`
+
+3. 文件头部使用文档注释，包含：
+   ```java
+   /**
+    * @author 你的姓名
+    * @title 题目X：题目名称
+    * @create 2026/7/14
+    */
+   ```
+
+4. 代码整洁，有必要的注释
+
+5. 基础题`（1~3）`和进阶题`（4~6）`为**必做**
+
+6. 挑战题`（7~9）`为 **选做**，学有余力的同学尝试完成

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

@@ -0,0 +1,738 @@
+# JavaSE 基础 — Day03 笔记
+
+> **日期**：2026-07-15  
+> **项目**：`c260715`  
+> **作者**：WanJL
+
+---
+
+## 一、流程控制 — switch 分支语句
+
+### 1. switch 语句概述
+
+`switch` 语句和 `if` 不同，`if` 是**范围的匹配**，而 `switch` 是**针对某个具体值的匹配**。
+
+#### 基本语法格式
+
+```java
+switch (变量) {
+    case 常量1:
+        代码块;
+        break;
+    case 常量2:
+        代码块;
+        break;
+    case 常量n:
+        代码块;
+        break;
+    default:
+        代码块;
+}
+```
+
+**执行流程**：
+- 如果变量的值和 `case 常量1` 相等，就执行对应的代码块
+- 如果和 `case 常量n` 相等，就执行对应代码块
+- 如果都不相等，就执行 `default` 中的代码块
+- `break` 的作用：在执行完对应的代码块后，跳出整个 switch 结构，后面的代码不再执行
+
+#### 基本示例
+
+```java
+int a = 3;
+switch (a) {
+    case 1:
+        System.out.println("a=1");
+        break;
+    case 2:
+        System.out.println("a=2");
+        break;
+    case 3:
+        System.out.println("a=3");
+        break;
+    default:
+        System.out.println("不知道");
+}
+// 输出：a=3
+```
+
+#### 课堂练习：星期转换
+
+定义一个变量（1~7），使用 switch 判断并分别输出 星期一 ~ 星期日。
+
+```java
+int b = 3;
+switch (b) {
+    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;
+    default:
+        System.out.println("不知道");
+}
+```
+
+---
+
+### 2. 增强 switch（JDK 17~21）
+
+JDK 17~21 引入了增强的 switch 语句，支持：
+
+- **任何基本数据类型**、**字符串 String**、**枚举**
+- **箭头语法 `->`**：更简洁，自带 break 效果（不需要显式写 `break`）
+- **多值匹配**：一个 case 可以匹配多个值，用逗号分隔
+- **switch 表达式**：switch 可以直接返回一个值
+
+#### ① 箭头语法 + 多值匹配
+
+```java
+String day = "1";
+switch (day) {
+    case "1", "2", "3", "4", "5" -> System.out.println("工作日");
+    case "6", "7" -> System.out.println("休息日");
+}
+```
+
+#### ② 箭头语法 + 代码块（多条语句）
+
+```java
+switch (day) {
+    case "1" -> {
+        System.out.println("星期一");
+        System.out.println("周一");
+        System.out.println("天不错");
+    }
+    case "2" -> System.out.println("星期二");
+    case "3" -> System.out.println("星期三");
+    case "4" -> System.out.println("星期四");
+    case "5" -> System.out.println("星期五");
+    case "6" -> System.out.println("星期六");
+    case "7" -> System.out.println("星期日");
+}
+```
+
+> 如果箭头右侧有多条语句，需要使用 `{ }` 代码块包裹。
+
+#### ③ switch 表达式（返回一个值）
+
+switch 可以直接作为一个表达式使用，返回匹配到的值，可用于赋值等操作：
+
+```java
+String dd = "1";
+String s = switch (dd) {
+    case "1" -> "星期一";
+    case "2" -> "星期二";
+    case "3" -> "星期三";
+    case "4" -> "星期四";
+    case "5" -> "星期五";
+    case "6" -> "星期六";
+    case "7" -> "星期日";
+    default -> "不知道";
+};
+System.out.println("今天是" + s + "，天气真不错");
+// 输出：今天是星期一，天气真不错
+```
+
+> ⚠️ switch 表达式必须要有 `default` 分支，以确保所有可能值都有对应结果。
+
+---
+
+### 3. 传统 switch vs 增强 switch 对比
+
+| 特性 | 传统 switch | 增强 switch（JDK 17+） |
+|------|-----------|----------------------|
+| **语法** | `case 值:` + `break;` | `case 值 ->` 箭头语法 |
+| **break** | 必须写，否则穿透 | 自带 break，无需写 |
+| **多值匹配** | 不支持（需写多个 case） | 支持：`case "1","2" ->` |
+| **返回值** | 不支持 | 支持：`switch(expr) { ... }` |
+| **穿透效果** | 有（可利用） | 无 |
+| **可读性** | 一般 | 更简洁清晰 |
+
+---
+
+## 二、流程控制 — 循环结构
+
+### 1. 循环概述
+
+**循环结构**：满足条件就不停地重复执行某段代码。
+
+Java 提供三种循环结构：
+| 循环类型 | 特点 |
+|---------|------|
+| **`for` 循环** | 先判断，后执行；适用于已知循环次数 |
+| **`while` 循环** | 先判断，后执行；适用于不确定循环次数 |
+| **`do...while` 循环** | 先执行，后判断；**循环体至少执行一次** |
+
+---
+
+### 2. for 循环
+
+#### 语法格式
+
+```java
+for (初始化语句; 循环条件; 迭代语句) {
+    循环体;
+}
+```
+
+#### 执行步骤
+
+```
+第1步：执行初始化语句（如 int i = 0;）
+第2步：执行循环条件（如 i < 10;）
+       → 如果结果为 true，执行第3步
+       → 如果结果为 false，跳转到第5步（结束循环）
+第3步：执行循环体（如 System.out.println(i);）
+第4步：执行迭代语句（如 i++），然后跳转回第2步
+第5步：跳出循环，继续执行后面的代码
+```
+
+#### 示例：循环 1~100 之间的整数
+
+```java
+for (int i = 1; i <= 100; i++) {
+    System.out.println(i);
+}
+```
+
+---
+
+### 3. while 循环
+
+#### 语法格式
+
+```java
+初始化语句;
+while (循环条件) {
+    循环体;
+    迭代语句;
+}
+```
+
+#### 示例：循环 1~100 之间的整数
+
+```java
+int i = 1;
+while (i <= 100) {
+    System.out.println(i);
+    i++;
+}
+```
+
+> ⚠️ **重要**：使用 `while` 或 `do...while` 时，**一定不要忘了写迭代语句（如 `i++`）**，否则会变成**死循环**（无限循环）。
+
+---
+
+### 4. do...while 循环
+
+#### 语法格式
+
+```java
+初始化语句;
+do {
+    循环体;
+    迭代语句;
+} while (循环条件);
+```
+
+#### 示例：循环 1~100 之间的整数
+
+```java
+int i = 1;
+do {
+    System.out.println(i);
+    i++;
+} while (i <= 100);
+```
+
+#### 三种循环的核心区别
+
+| 特性 | `for` | `while` | `do...while` |
+|------|-------|---------|-------------|
+| **判断时机** | 先判断，后执行 | 先判断，后执行 | 先执行，后判断 |
+| **执行次数** | 0~n 次 | 0~n 次 | **至少 1 次** |
+| **适用场景** | 已知循环次数 | 不确定循环次数 | 至少需要执行一次 |
+| **初始化位置** | for 语句内部 | 循环外部 | 循环外部 |
+
+---
+
+## 三、课后作业讲解（7月14日作业）
+
+### 题目 1：判断闰年
+
+**知识点**：if-else、逻辑运算符（`&&`、`||`）、算术运算符（`%`）
+
+**闰年规则**（满足其一即可）：
+1. 能被 4 整除但不能被 100 整除
+2. 能被 400 整除
+
+**代码实现**：
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork05
+ * @description 7月14日课后作业-判断年份
+ * @create 2026/7/15
+ */
+public class HomeWork01 {
+    public static void main(String[] args) {
+        int year = 2000;
+        // 判断是否闰年：能被4整除且不能被100整除，或者能被400整除
+        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
+            System.out.println(year + "是闰年");
+        } else {
+            System.out.println(year + "是平年");
+        }
+    }
+}
+```
+
+> **核心逻辑**：`year % 4 == 0 && year % 100 != 0 || year % 400 == 0`
+
+---
+
+### 题目 2：三个数比大小
+
+**知识点**：三目运算符嵌套
+
+**代码实现**：
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWord02
+ * @description 7月14日课后作业-三个数比大小
+ * @create 2026/7/15
+ */
+public class HomeWork02 {
+    public static void main(String[] args) {
+        int a = 10, b = 15, c = 20;
+        // 三目运算符嵌套：先比较 a 和 b，再将结果与 c 比较
+        System.out.println(a > b ? (a > c ? a : c) : (b > c ? b : c));
+    }
+}
+```
+
+> **核心逻辑**：`a > b ? (a > c ? a : c) : (b > c ? b : c)`
+> - 先判断 `a > b` 是否成立
+> - 如果成立，再比较 `a` 和 `c`，取较大值
+> - 如果不成立，再比较 `b` 和 `c`，取较大值
+
+---
+
+### 题目 4：水仙花数判定
+
+**知识点**：算术运算符（`/`、`%`）、if-else
+
+**水仙花数**：一个三位数，其各位数字的立方和等于该数本身。例如：`153 = 1³ + 5³ + 3³`
+
+**代码实现**：
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork04
+ * @description 7月14日课后作业-水仙花数
+ * @create 2026/7/15
+ */
+public class HomeWork04 {
+    public static void main(String[] args) {
+        int number = 153;           // 定义一个整数变量
+        int bai = number / 100;     // 百位
+        int shi = number / 10 % 10; // 十位
+        int ge = number % 10;       // 个位
+        if (number == bai * bai * bai + shi * shi * shi + ge * ge * ge) {
+            System.out.println(number + "是水仙花数");
+        } else {
+            System.out.println(number + "不是水仙花数");
+        }
+    }
+}
+```
+
+> **取位技巧**：
+> - 百位：`number / 100`（整除去掉后两位）
+> - 十位：`number / 10 % 10`（先整除去掉个位，再取余去掉百位以上）
+> - 个位：`number % 10`（取余去掉前三位）
+
+---
+
+### 题目 5：简易计算器
+
+**知识点**：if-else if-else 多分支、算术运算符、除零判断
+
+**代码实现**：
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork05
+ * @description 7月14日课后作业-简易计算器
+ * @create 2026/7/15
+ */
+public class HomeWork05 {
+    public static void main(String[] args) {
+        int a = 15, b = 20;
+        char operator = '/';
+        if (operator == '+') {
+            System.out.println(a + b);
+        } else if (operator == '-') {
+            System.out.println(a - b);
+        } else if (operator == '*') {
+            System.out.println(a * b);
+        } else if (operator == '/') {
+            if (b == 0) {
+                System.out.println("除数不能为0");
+            } else {
+                System.out.println(a / b);
+            }
+        } else if (operator == '%') {
+            if (b == 0) {
+                System.out.println("除数不能为0");
+            } else {
+                System.out.println(a % b);
+            }
+        }
+    }
+}
+```
+
+> ⚠️ **注意**：做除法和取模运算时，必须先判断除数是否为 0，避免 `ArithmeticException` 异常。
+
+---
+
+### 题目 7：数字加密系统
+
+**知识点**：算术运算符（`/`、`%`）、变量交换算法、综合运用
+
+**加密规则**：
+1. 获取 4 位数的每一位
+2. 每个数字加 5
+3. 对 10 取余
+4. 第 1 位与第 4 位互换，第 2 位与第 3 位互换
+
+**代码实现**：
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork07
+ * @description 7月14日课后作业-数字加密系统
+ * @create 2026/7/15
+ */
+public class HomeWork07 {
+    public static void main(String[] args) {
+        int number = 1234;
+
+        // 加密规则-0：获取每个位的数
+        int qian = number / 1000;     // 千位
+        int bai = number / 100 % 10;  // 百位
+        int shi = number / 10 % 10;   // 十位
+        int ge = number % 10;         // 个位
+
+        // 加密规则-1：每个数字加 5
+        qian += 5;
+        bai += 5;
+        shi += 5;
+        ge += 5;
+
+        // 加密规则-2：对 10 取余
+        qian %= 10;
+        bai %= 10;
+        shi %= 10;
+        ge %= 10;
+
+        // 加密规则-3：第1位和第4位互换，第2位和第3位互换（使用加减法交换）
+        qian = qian + ge;
+        ge = qian - ge;
+        qian = qian - ge;
+
+        bai = bai + shi;
+        shi = bai - shi;
+        bai = bai - shi;
+
+        System.out.println("加密结果：" + qian + bai + shi + ge);
+    }
+}
+```
+
+> **变量交换技巧**（不借助第三个变量）：
+> ```java
+> a = a + b;  // a 变成两数和
+> b = a - b;  // b 得到原 a 的值
+> a = a - b;  // a 得到原 b 的值
+> ```
+
+---
+
+## 四、知识拓展
+
+### 1. break 在 switch 中的作用
+
+在传统 switch 中，`break` 用于**跳出 switch 结构**，防止**穿透（fall-through）**。
+
+```java
+int n = 2;
+switch (n) {
+    case 1:
+        System.out.println("A");
+        // 没有 break → 会继续执行 case 2
+    case 2:
+        System.out.println("B");
+        break;  // 跳出 switch
+    case 3:
+        System.out.println("C");
+}
+// 输出：B（case 1 不会匹配，case 2 匹配后输出 B 后跳出）
+```
+
+> 如果不写 `break`，匹配到某个 case 后，其后的所有 case 都会被执行，直到遇到 `break` 或 switch 结束。这个特性有时也会被**利用**（如多个 case 共享同一段代码）。
+
+### 2. 死循环
+
+循环条件永远为 `true` 的循环称为**死循环**（无限循环），应避免出现：
+
+```java
+// 死循环示例（不要运行！）
+while (true) {
+    System.out.println("无限循环");
+}
+
+// for 的死循环写法
+for (;;) {
+    System.out.println("无限循环");
+}
+```
+
+### 3. 整数的进制表示
+
+Java 中整数可以使用不同进制表示：
+
+| 前缀 | 进制 | 示例 | 十进制值 |
+|------|------|------|---------|
+| `0b` 或 `0B` | 二进制 | `0b1100` | 12 |
+| `0` | 八进制 | `014` | 12 |
+| 无前缀 | 十进制 | `12` | 12 |
+| `0x` 或 `0X` | 十六进制 | `0xC` | 12 |
+
+```java
+int bin = 0b1100;  // 二进制 → 12
+int oct = 014;     // 八进制 → 12
+int dec = 12;      // 十进制 → 12
+int hex = 0xC;     // 十六进制 → 12
+```
+
+---
+
+## 五、完整代码汇总
+
+### Demo01.java — switch 分支语句
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 流程控制-分支语句-switch
+ * @create 2026/7/15
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        /*
+            switch语句和if不一样，不是范围的匹配，而是针对某个值的匹配，格式：
+            switch(变量){
+                case 常量1:
+                    代码块;
+                    break;
+                case 常量2:
+                    代码块;
+                    break;
+                case 常量n:
+                    代码块;
+                    break;
+                default:
+                    代码块;
+            }
+         */
+        // ===== 传统 switch =====
+        int a = 3;
+        switch (a) {
+            case 1:
+                System.out.println("a=1");
+                break;
+            case 2:
+                System.out.println("a=2");
+                break;
+            case 3:
+                System.out.println("a=3");
+                break;
+            default:
+                System.out.println("不知道");
+        }
+
+        // ===== 练习题：星期转换 =====
+        int b = 3;
+        switch (b) {
+            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;
+            default: System.out.println("不知道");
+        }
+
+        // ===== 增强 switch：箭头语法 + 多值匹配 =====
+        String day = "1";
+        switch (day) {
+            case "1", "2", "3", "4", "5" -> System.out.println("工作日");
+            case "6", "7" -> System.out.println("休息日");
+        }
+
+        // ===== 增强 switch：箭头语法 + 代码块 =====
+        switch (day) {
+            case "1" -> {
+                System.out.println("星期一");
+                System.out.println("周一");
+                System.out.println("天不错");
+            }
+            case "2" -> System.out.println("星期二");
+            case "3" -> System.out.println("星期三");
+            case "4" -> System.out.println("星期四");
+            case "5" -> System.out.println("星期五");
+            case "6" -> System.out.println("星期六");
+            case "7" -> System.out.println("星期日");
+        }
+
+        // ===== switch 表达式（返回值） =====
+        String dd = "1";
+        String s = switch (dd) {
+            case "1" -> "星期一";
+            case "2" -> "星期二";
+            case "3" -> "星期三";
+            case "4" -> "星期四";
+            case "5" -> "星期五";
+            case "6" -> "星期六";
+            case "7" -> "星期日";
+            default -> "不知道";
+        };
+        System.out.println("今天是" + s + "，天气真不错");
+    }
+}
+```
+
+### Demo02.java — 循环结构
+
+```java
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description 流程控制-循环结构
+ * @create 2026/7/15
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        /*
+            循环结构：满足条件就不停地循环执行代码
+            Java 三种循环结构：
+            for循环：
+                for(初始化语句; 循环条件; 迭代语句) {
+                    循环体;
+                }
+            执行步骤：
+                1. 执行初始化语句
+                2. 执行循环条件（true 继续，false 退出）
+                3. 执行循环体
+                4. 执行迭代语句，跳回第2步
+
+            while循环：
+                初始化语句;
+                while(循环条件) {
+                    循环体;
+                    迭代语句;
+                }
+
+            do...while循环：
+                初始化语句;
+                do {
+                    循环体;
+                    迭代语句;
+                } while(循环条件);
+                do...while 至少执行一次循环体
+         */
+
+        // 练习：分别使用 for、while 和 do...while 循环 1~100 之间的整数
+    }
+}
+```
+
+---
+
+## 六、随堂练习要点
+
+1. **switch 基本语法**：`switch(变量) { case 常量: 代码块; break; ... default: }`
+2. **break 的作用**：跳出 switch 结构，防止穿透（fall-through）
+3. **传统 switch**：使用 `case 值:` + `break;` 语法
+4. **增强 switch（JDK 17+）**：使用 `case 值 ->` 箭头语法，自带 break
+5. **多值匹配**：`case "1", "2", "3" ->` 一个 case 匹配多个值
+6. **switch 表达式**：switch 可以直接作为表达式返回值，用于赋值
+7. **switch 表达式必须写 default**：确保所有可能值都有对应结果
+8. **循环结构**：重复执行某段代码，满足条件就继续循环
+9. **for 循环**：`for(初始化; 条件; 迭代) { 循环体 }`，先判断后执行
+10. **while 循环**：`while(条件) { 循环体; 迭代; }`，先判断后执行
+11. **do...while 循环**：`do { 循环体; 迭代; } while(条件);`，先执行后判断，至少执行一次
+12. **死循环**：循环条件永远为 true，应避免出现
+13. **迭代语句不能忘**：`while` 和 `do...while` 中必须写 `i++`，否则死循环
+14. **for vs while**：已知循环次数用 `for`，不确定次数用 `while`
+15. **do...while 特点**：无论条件是否满足，循环体至少执行一次
+16. **作业-闰年判断**：`year % 4 == 0 && year % 100 != 0 || year % 400 == 0`
+17. **作业-三数比大小**：`a > b ? (a > c ? a : c) : (b > c ? b : c)`
+18. **作业-水仙花数**：百位 `/100`、十位 `/10%10`、个位 `%10`
+19. **作业-计算器**：除法和取模前必须先判断除数是否为 0
+20. **作业-数字加密**：取每位 → 加5 → 取余10 → 位置互换
+21. **变量交换**：可使用加减法实现不借助第三变量的交换
+22. **进制表示**：`0b` 二进制、`0` 八进制、`0x` 十六进制
+
+---
+
+## 七、拓展阅读
+
+| 概念 | 说明 |
+|------|------|
+| **switch 穿透（fall-through）** | 传统 switch 中，匹配到某个 case 后若不写 break，会继续执行后续所有 case 的代码 |
+| **箭头 case `->`** | JDK 17+ 引入的增强 switch 语法，自带 break，右侧可以是表达式、代码块或 throw |
+| **switch 表达式** | switch 作为表达式使用，可以返回一个值，必须穷举所有可能或提供 default |
+| **循环（Loop）** | 重复执行某段代码的结构，有 for、while、do...while 三种 |
+| **死循环（Infinite Loop）** | 循环条件永远为 true，程序无法退出的循环，会导致程序卡死 |
+| **迭代（Iteration）** | 循环体每执行一次称为一次迭代 |
+| **初始化语句** | 循环开始前执行的语句，在 for 循环中只执行一次 |
+| **循环条件** | 布尔表达式，true 继续循环，false 退出循环 |
+| **迭代语句** | 每次循环结束后执行的语句，通常用于改变循环变量 |
+| **整除 `/` 与取余 `%`** | 常用于数字分解，如获取一个整数的各个位上的数字 |
+| **变量交换算法** | 不借助第三个变量，通过加减法或异或运算交换两个变量的值 |
+| **进制前缀** | `0b`（二进制）、`0`（八进制）、`0x`（十六进制） |