JavaSE 基础 — Day03 笔记

日期：2026-07-15
项目：c260715
作者：WanJL

一、流程控制 — switch 分支语句

1. switch 语句概述

switch 语句和 if 不同，if 是范围的匹配，而 switch 是针对某个具体值的匹配。

基本语法格式

switch (变量) {
    case 常量1:
        代码块;
        break;
    case 常量2:
        代码块;
        break;
    case 常量n:
        代码块;
        break;
    default:
        代码块;
}

执行流程：

如果变量的值和 case 常量1 相等，就执行对应的代码块
如果和 case 常量n 相等，就执行对应代码块
如果都不相等，就执行 default 中的代码块
break 的作用：在执行完对应的代码块后，跳出整个 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("不知道");
}
// 输出：a=3

课堂练习：星期转换

定义一个变量（1~7），使用 switch 判断并分别输出星期一 ~ 星期日。

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 可以直接返回一个值

① 箭头语法 + 多值匹配

String day = "1";
switch (day) {
    case "1", "2", "3", "4", "5" -> System.out.println("工作日");
    case "6", "7" -> System.out.println("休息日");
}

② 箭头语法 + 代码块（多条语句）

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 可以直接作为一个表达式使用，返回匹配到的值，可用于赋值等操作：

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 循环

语法格式

for (初始化语句; 循环条件; 迭代语句) {
    循环体;
}

执行步骤

第1步：执行初始化语句（如 int i = 0;）
第2步：执行循环条件（如 i < 10;）
       → 如果结果为 true，执行第3步
       → 如果结果为 false，跳转到第5步（结束循环）
第3步：执行循环体（如 System.out.println(i);）
第4步：执行迭代语句（如 i++），然后跳转回第2步
第5步：跳出循环，继续执行后面的代码

示例：循环 1~100 之间的整数

for (int i = 1; i <= 100; i++) {
    System.out.println(i);
}

3. while 循环

语法格式

初始化语句;
while (循环条件) {
    循环体;
    迭代语句;
}

示例：循环 1~100 之间的整数

int i = 1;
while (i <= 100) {
    System.out.println(i);
    i++;
}

⚠️ 重要：使用 while 或 do...while 时，一定不要忘了写迭代语句（如 i++），否则会变成死循环（无限循环）。

4. do...while 循环

语法格式

初始化语句;
do {
    循环体;
    迭代语句;
} while (循环条件);

示例：循环 1~100 之间的整数

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、逻辑运算符（&&、||）、算术运算符（%）

闰年规则（满足其一即可）：

能被 4 整除但不能被 100 整除
能被 400 整除

代码实现：

/**
 * @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：三个数比大小

知识点：三目运算符嵌套

代码实现：

/**
 * @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³

代码实现：

/**
 * @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 多分支、算术运算符、除零判断

代码实现：

/**
 * @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：数字加密系统

知识点：算术运算符（/、%）、变量交换算法、综合运用

加密规则：

获取 4 位数的每一位
每个数字加 5
对 10 取余
第 1 位与第 4 位互换，第 2 位与第 3 位互换

代码实现：

/**
 * @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);
    }
}

变量交换技巧（不借助第三个变量）：

> 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 之间的整数

} } ```

六、随堂练习要点

switch 基本语法：switch(变量) { case 常量: 代码块; break; ... default: }
break 的作用：跳出 switch 结构，防止穿透（fall-through）
传统 switch：使用 case 值: + break; 语法
增强 switch（JDK 17+）：使用 case 值 -> 箭头语法，自带 break
多值匹配：case "1", "2", "3" -> 一个 case 匹配多个值
switch 表达式：switch 可以直接作为表达式返回值，用于赋值
switch 表达式必须写 default：确保所有可能值都有对应结果
循环结构：重复执行某段代码，满足条件就继续循环
for 循环：for(初始化; 条件; 迭代) { 循环体 }，先判断后执行
while 循环：while(条件) { 循环体; 迭代; }，先判断后执行
do...while 循环：do { 循环体; 迭代; } while(条件);，先执行后判断，至少执行一次
死循环：循环条件永远为 true，应避免出现
迭代语句不能忘：while 和 do...while 中必须写 i++，否则死循环
for vs while：已知循环次数用 for，不确定次数用 while
do...while 特点：无论条件是否满足，循环体至少执行一次
作业-闰年判断：year % 4 == 0 && year % 100 != 0 || year % 400 == 0
作业-三数比大小：a > b ? (a > c ? a : c) : (b > c ? b : c)
作业-水仙花数：百位 /100、十位 /10%10、个位 %10
作业-计算器：除法和取模前必须先判断除数是否为 0
作业-数字加密：取每位 → 加5 → 取余10 → 位置互换
变量交换：可使用加减法实现不借助第三变量的交换
进制表示：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`（十六进制）

20260715-笔记.md 21 KB History Raw

JavaSE 基础 — Day03 笔记

一、流程控制 — switch 分支语句

1. switch 语句概述

基本语法格式

基本示例

课堂练习：星期转换

2. 增强 switch（JDK 17~21）

① 箭头语法 + 多值匹配

② 箭头语法 + 代码块（多条语句）

③ switch 表达式（返回一个值）

3. 传统 switch vs 增强 switch 对比

二、流程控制 — 循环结构

1. 循环概述

2. for 循环

语法格式

执行步骤

示例：循环 1~100 之间的整数

3. while 循环

语法格式

示例：循环 1~100 之间的整数

4. do...while 循环

语法格式

示例：循环 1~100 之间的整数

三种循环的核心区别

三、课后作业讲解（7月14日作业）

题目 1：判断闰年

题目 2：三个数比大小

题目 4：水仙花数判定

题目 5：简易计算器

题目 7：数字加密系统

六、随堂练习要点

七、拓展阅读

20260715-笔记.md 21 KB

History Raw