# 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`（十六进制） |