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 语句内部	循环外部	循环外部

5. 循环控制语句（结束循环的三种方式）

Java 提供了三种方式控制循环的执行流程：

控制语句	作用	说明
`break`	结束整个循环	跳出循环体，继续执行循环后面的代码
`continue`	结束本轮循环	跳过本次循环剩余代码，继续执行下一轮循环
`return`	结束整个方法	直接结束当前方法，方法中循环后面的代码也不再执行

① break — 结束整个循环

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        break;  // i == 3 时结束整个循环
    }
    System.out.println(i);
}
// 输出：0 1 2
// 循环到此结束，继续执行循环外的代码
System.out.println(".....循环后的代码....");

break 执行后，循环立即终止，程序继续执行循环后面的代码。

② continue — 结束本轮循环

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        continue;  // i == 3 时跳过本轮，不执行输出
    }
    System.out.println(i);
}
// 输出：0 1 2 4 5 6 7 8 9
// 注意：没有 3，因为 i==3 时跳过了本次循环

continue 执行后，本轮循环中剩余的代码不再执行，直接进入下一轮迭代（i++ → 判断条件）。

③ return — 结束整个方法

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        return;  // i == 3 时结束方法，循环后面的代码也不执行了
    }
    System.out.println(i);
}
// 输出：0 1 2
// 注意：循环后面的所有代码都不会执行
System.out.println(".....循环后的代码....");  // ❌ 不会执行

return 比 break 更"狠"——它不仅结束循环，还会直接结束整个 main 方法，方法内循环后面的所有代码都不再执行。

三种控制语句对比

控制语句	影响范围	循环剩余代码	循环外代码	适用场景
`break`	仅当前循环	不执行	继续执行	找到目标后提前退出循环
`continue`	仅本轮循环	不执行（跳到下一轮）	继续执行	跳过某些不符合条件的值
`return`	整个方法	不执行	不执行	方法执行完毕或异常提前返回

6. 流程控制中的常见陷阱

① 浮点类型精度问题

double a = 0.1 + 0.2;
System.out.println(a);   // 0.30000000000000004
if (a == 0.3) {
    System.out.println("相等");
} else {
    System.out.println("不想等");
}
// 输出：不想等

原因：浮点数采用 IEEE 754 标准存储，0.1 + 0.2 在计算机中无法精确表示为 0.3，而是近似值 0.30000000000000004。

② switch 的穿透问题

int x = 2;
switch (x) {
    case 1:
    case 2:
    case 3:
        System.out.println("1~3");
        break;
}
// 输出：1~3
// 如果 case 1、case 2 不加 break，会一直穿透到 case 3

穿透技巧：当多个 case 需要执行相同的代码时，可以利用穿透特性，只在最后一个 case 写 break，减少重复代码。

7. while 循环实战练习

练习 1：统计整数位数

给定一个整数 12345，使用 while 循环统计它有多少位。

/**
 * @author WanJl
 * @title Demo04
 * @description 课堂练习：统计整数位数
 * @create 2026/7/15
 */
public class Demo04 {
    public static void main(String[] args) {
        int n = 12345;
        int t = 0;   // 统计位数
        while (n != 0) {
            n /= 10;  // 每次除以10，缩小10倍
            t++;      // 每缩小一次，位数累计1
        }
        System.out.println(t);  // 输出：5
    }
}

核心思路：一个整数不断除以 10，每除一次就去掉一位，直到变成 0。除的次数就是位数。

for vs while 选择原则：知道循环次数用 for，不知道循环次数用 while。此处我们不知道 12345 是多少位（不确定除以多少次才到 0），所以适合用 while。

练习 2：求各位数字之和

给定一个整数 12345，使用 while 循环求其各位数字之和（1 + 2 + 3 + 4 + 5 = 15）。

/**
 * @author WanJl
 * @title Demo05
 * @description 课堂练习：求各位数字之和
 * @create 2026/7/15
 */
public class Demo05 {
    public static void main(String[] args) {
        int n = 12345;
        int sum = 0;  // 累加和
        while (n != 0) {
            sum += n % 10;  // 获取个位数字，累加到 sum
            n /= 10;        // 去掉个位，缩小10倍
        }
        System.out.println(sum);  // 输出：15
    }
}

核心思路：

n % 10 — 每次取个位数字

n / 10 — 去掉个位，继续取下一个数字

循环直到 n 变成 0

8. 嵌套循环（Nested Loop）

嵌套循环就是循环里面再放一个循环。

for (int i = 0; i < 10; i++) {       // 外层循环
    System.out.println("i=" + i);
    for (int j = 0; j < 10; j++) {   // 内层循环
        System.out.print("j=" + j);
    }
    System.out.println();
}

执行规律：外层循环执行一轮，内层循环完整执行一次。

内层循环总共执行的次数 = 外层循环次数 × 内层循环次数

练习 3：打印矩形星号图案（4 行 5 列）

/**
 * @author WanJl
 * @title Demo06
 * @description 课堂练习：打印4行5列矩形星号
 * @create 2026/7/15
 */
public class Demo06 {
    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {        // 外层：控制行数
            for (int j = 0; j < 5; j++) {    // 内层：控制每行星号个数
                System.out.print("*");       // 不换行
            }
            System.out.println();            // 一行结束，换行
        }
    }
}
// 输出：
// *****
// *****
// *****
// *****

练习 4：打印空心矩形星号图案（5 行 5 列）

/**
 * @author WanJl
 * @title Demo07
 * @description 课堂练习：打印5行5列空心矩形星号
 * @create 2026/7/15
 */
public class Demo07 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {       // 外层：控制行数
            for (int j = 1; j <= 5; j++) {   // 内层：控制列数
                // 第1行、第5行：全部输出 *
                // 第2~4行：第1列和第5列输出 *，其余输出空格
                if (i == 1 || i == 5) {
                    System.out.print("*");
                } else {
                    if (j == 1 || j == 5) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();  // 换行
        }
    }
}
// 输出：
// *****
// *   *
// *   *
// *   *
// *****

练习 5：打印菱形星号图案（5 行）

/**
 * @author WanJl
 * @title Demo08
 * @description 课堂练习：打印5行菱形星号图案
 * @create 2026/7/15
 */
public class Demo08 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5; j++) {
                if (i == 3) {                  // 第3行：全星号
                    System.out.print("*");
                } else {
                    if (i == 1 || i == 5) {    // 第1、5行：中间星号
                        if (j == 3) {
                            System.out.print("*");
                        } else {
                            System.out.print(" ");
                        }
                    } else if (i == 2 || i == 4) {  // 第2、4行：两侧星号
                        if (j == 1 || j == 5) {
                            System.out.print(" ");
                        } else {
                            System.out.print("*");
                        }
                    }
                }
            }
            System.out.println();
        }
    }
}
// 输出：
//   *
//  ***
// *****
//  ***
//   *

嵌套循环 + 条件判断是解决二维图形打印问题的核心思路：

外层循环控制行数

内层循环控制列数

if 判断决定某个位置输出 * 还是空格

三、数组（Array）

1. 数组概述

数组是一种用来存储多个相同类型数据的容器。

Java 数据类型回顾

Java 中的数据类型分为两类： | 类型 | 说明 | |------|------| | 基本数据类型 | byte、short、int、long、float、double、char、boolean | | 引用数据类型 | 类（class）、数组（[]）、接口（interface）、枚举（enum）、注解（@interface） |

之前学过的 String 就是引用数据类型（类），现在学习的数组也是引用数据类型。

数组的特点

特点	说明
① 连续存储	数组中的每个元素（值）存储在连续的内存空间中
② 通过索引访问	使用索引值（下标）来访问数组中的元素
③ 固定长度	数组有一个 `length` 属性，表示数组的长度，创建后不能改变
④ 同类型	数组中只能存储同一种类型的元素
⑤ 指定类型	创建数组时必须指定要存储的元素类型
⑥ 索引从 0 开始	第一个元素的索引为 `0`，最后一个元素的索引为 `length - 1`

2. 定义数组的格式

数据类型[] 数组名;

示例：

int[] a;    // 声明一个 int 类型的数组变量 a

int[] a 表示 a 是一个 int 类型的数组变量，为它赋值时对应的数组必须是整数类型。

3. 数组的初始化

数组的初始化分为两种方式：动态初始化 和 静态初始化。

① 动态初始化

程序员负责定义数组长度，计算机负责为数组元素赋默认值。

// 语法：数组变量名 = new 数组类型[数组长度];
int[] a = new int[10];

各类型元素的默认值： | 元素类型 | 默认值 | |---------|-------| | byte、short、int、long | 0 | | float、double | 0.0 | | char | （空字符） | | boolean | false | | 引用数据类型 | null |

数组在内存中的地址

int[] a = new int[10];
System.out.println(a);  // 输出类似：[I@b4c966a

地址值含义：

[ — 表示这是一个一维数组

I — 表示元素类型为 int

@ — 分隔符

b4c966a — 数组在堆内存中的地址值（十六进制）

② 静态初始化

程序员负责为数组元素赋值，计算机负责计算数组的长度。

完整语法：

int[] arr1 = new int[]{1, 3, 5, 7, 9, 6, 2, 4};

简写语法（最常用）：

int[] arr2 = {1, 3, 5, 7, 9, 6, 2, 4};

4. 数组元素的访问与赋值

为数组元素赋值

数组名[索引值] = 值;

// 示例
arr[0] = 1;       // 直接赋一个字面量
int x = 15;
arr[1] = x;       // 赋一个变量的值

访问（读取）数组元素

数组名[索引值]

// 示例
System.out.println(arr[0]);  // 输出第一个元素（已被赋值为 1）
System.out.println(arr[1]);  // 输出第二个元素（已被赋值为 15）
System.out.println(arr[2]);  // 输出第三个元素（未赋值，输出默认值 0）

使用 for 循环遍历数组

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

arr.length — 获取数组的长度（元素个数）

索引越界风险

int[] arr = new int[5];
System.out.println(arr[5]);  // ❌ 索引越界！ArrayIndexOutOfBoundsException
// 索引范围：0 ~ length-1，即 0 ~ 4

⚠️ 访问数组元素时，索引值必须在 0 ~ length-1 之间，否则会抛出 ArrayIndexOutOfBoundsException（数组下标索引异常）。

5. 数组初始化方式对比

特性	动态初始化	静态初始化
谁指定长度	程序员	计算机（根据元素个数自动计算）
谁赋值	计算机（默认值）	程序员（手动指定）
语法	`new int[10]`	`new int[]{1,2,3}` 或 `{1,2,3}`
适用场景	暂时不知道元素的具体值	已知元素的具体值

四、课后作业讲解（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）。

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 的循环称为死循环（无限循环），应避免出现：

// 死循环示例（不要运行！）
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

int bin = 0b1100;  // 二进制 → 12
int oct = 014;     // 八进制 → 12
int dec = 12;      // 十进制 → 12
int hex = 0xC;     // 十六进制 → 12

六、完整代码汇总

Demo01.java — switch 分支语句

/**
 * @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 — 循环结构 + 流程控制陷阱

/**
 * @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 至少执行一次循环体
         */

        // ========== 流程控制中的陷阱 ==========

        // 陷阱 1：浮点类型精度问题
        double a = 0.1 + 0.2;
        System.out.println(a);   // 0.30000000000000004
        if (a == 0.3) {
            System.out.println("相等");
        } else {
            System.out.println("不想等");
        }

        // 陷阱 2：switch 的穿透问题
        // 如果不加 break，case 会一直穿透
        int x = 2;
        switch (x) {
            case 1:
            case 2:
            case 3:
                System.out.println("1~3");
                break;
        }
    }
}

Demo03.java — 循环控制语句（break / continue / return）

/**
 * @author WanJl
 * @version 1.0
 * @title Demo03
 * @description 结束循环的语句
 * @create 2026/7/15
 */
public class Demo03 {
    public static void main(String[] args) {
        /*
            有 3 种方式可以结束循环
            break;      结束循环，继续执行循环后面的代码
            continue;   结束本轮循环，继续执行下一轮循环
            return;     结束方法，顺便结束循环
         */

        // ===== continue：结束本轮循环 =====
        for (int i = 0; i < 10; i++) {
            if (i == 3) {
                continue;   // i==3 时跳过本轮，不输出 3
            }
            System.out.println(i);
        }
        // 输出：0 1 2 4 5 6 7 8 9

        System.out.println("---------------------------------------");

        // ===== break：结束整个循环 =====
        for (int i = 0; i < 10; i++) {
            if (i == 3) {
                break;      // i==3 时结束整个循环
            }
            System.out.println(i);
        }
        // 输出：0 1 2
        System.out.println(".....循环后的代码....");

        System.out.println("---------------------------------------");

        // ===== return：结束整个方法 =====
        for (int i = 0; i < 10; i++) {
            if (i == 3) {
                return;     // i==3 时结束方法，循环后的代码也不执行
            }
            System.out.println(i);
        }
        // 输出：0 1 2
        // 以下代码不会执行！
        System.out.println(".....循环后的代码....");
    }
}

Demo04.java — while 循环实战：统计整数位数

/**
 * @author WanJl
 * @version 1.0
 * @title Demo04
 * @description 课堂练习：统计整数位数
 * @create 2026/7/15
 */
public class Demo04 {
    public static void main(String[] args) {
        int n = 12345;
        int t = 0;   // 统计位数
        while (n != 0) {
            n /= 10;  // 每次除以10，缩小10倍
            t++;      // 每缩小一次，位数累计1
        }
        System.out.println(t);  // 输出：5
    }
}

Demo05.java — while 循环实战：求各位数字之和

/**
 * @author WanJl
 * @version 1.0
 * @title Demo05
 * @description 课堂练习：求各位数字之和
 * @create 2026/7/15
 */
public class Demo05 {
    public static void main(String[] args) {
        int n = 12345;
        int sum = 0;  // 累加和
        while (n != 0) {
            sum += n % 10;  // 获取个位数字，累加到 sum
            n /= 10;        // 去掉个位，缩小10倍
        }
        System.out.println(sum);  // 输出：15
    }
}

Demo06.java — 嵌套循环：打印矩形星号图案

/**
 * @author WanJl
 * @version 1.0
 * @title Demo06
 * @description 课堂练习：打印4行5列矩形星号
 * @create 2026/7/15
 */
public class Demo06 {
    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {        // 外层：控制行数
            for (int j = 0; j < 5; j++) {    // 内层：控制每行星号个数
                System.out.print("*");
            }
            System.out.println();            // 换行
        }
    }
}

Demo07.java — 嵌套循环：打印空心矩形星号图案

/**
 * @author WanJl
 * @version 1.0
 * @title Demo07
 * @description 课堂练习：打印5行5列空心矩形星号
 * @create 2026/7/15
 */
public class Demo07 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {       // 外层：控制行数
            for (int j = 1; j <= 5; j++) {   // 内层：控制列数
                if (i == 1 || i == 5) {
                    System.out.print("*");
                } else {
                    if (j == 1 || j == 5) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}

Demo08.java — 嵌套循环：打印菱形星号图案

/**
 * @author WanJl
 * @version 1.0
 * @title Demo08
 * @description 课堂练习：打印5行菱形星号图案
 * @create 2026/7/15
 */
public class Demo08 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5; j++) {
                if (i == 3) {
                    System.out.print("*");
                } else {
                    if (i == 1 || i == 5) {
                        if (j == 3) {
                            System.out.print("*");
                        } else {
                            System.out.print(" ");
                        }
                    } else if (i == 2 || i == 4) {
                        if (j == 1 || j == 5) {
                            System.out.print(" ");
                        } else {
                            System.out.print("*");
                        }
                    }
                }
            }
            System.out.println();
        }
    }
}

Demo09.java — 数组（Array）

/**
 * @author WanJl
 * @version 1.0
 * @title Demo09
 * @description java引用数据类型
 * @create 2026/7/15
 */
public class Demo09 {
    public static void main(String[] args) {
        // ===== 声明数组变量 =====
        int[] a;    // int类型的数组变量

        // ===== 动态初始化 =====
        a = new int[10];
        System.out.println(a);  // 输出数组在堆内存中的地址值

        // ===== 直接声明并动态初始化 =====
        int[] arr = new int[10];

        // ===== 为数组元素赋值 =====
        arr[0] = 1;
        int x = 15;
        arr[1] = x;

        // ===== 访问数组元素 =====
        System.out.println(arr[0]);  // 1
        System.out.println(arr[1]);  // 15
        System.out.println(arr[2]);  // 0（默认值）

        // ===== 使用 for 循环遍历数组 =====
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // ===== 静态初始化（完整写法） =====
        int[] arr1 = new int[]{1, 3, 5, 7, 9, 6, 2, 4};

        // ===== 静态初始化（简写方式，最常用） =====
        int[] arr2 = {1, 3, 5, 7, 9, 6, 2, 4};
    }
}

七、随堂练习要点

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 十六进制
循环控制语句：break 结束整个循环，continue 结束本轮循环，return 结束整个方法
break：跳出当前循环体，继续执行循环后面的代码
continue：跳过本轮循环中剩余代码，直接进入下一轮迭代
return：直接结束整个方法，方法内循环后的所有代码都不再执行
浮点精度陷阱：0.1 + 0.2 不等于 0.3，浮点数不能直接用 == 比较
switch 穿透利用：多个 case 执行相同代码时，可以利用穿透特性只在最后一个 case 写 break
while 实战-统计位数：不断除以10直到0，除的次数就是位数
while 实战-数字求和：n % 10 取个位，n / 10 去掉个位，循环累加
for vs while 选择：知道次数用 for，不知道次数用 while
嵌套循环：循环里面再放一个循环，外层循环执行一轮，内层循环完整执行一次
嵌套循环执行次数：内层总次数 = 外层次数 × 内层次数
图形打印核心思路：外层循环控制行数，内层循环控制列数，if 判断决定每个位置输出什么
打印矩形：所有位置都输出 *
打印空心矩形：首行/末行全 *，中间行首列/末列 *，其余空格
打印菱形：根据行号决定每行星号的排列位置
数组：用来存储多个相同类型数据的容器，是引用数据类型
数组六要素：连续存储、索引访问、固定长度、同类型、指定类型、索引从0开始
数组 length 属性：数组名.length 获取数组长度，创建后不可改变
动态初始化：程序员定义长度，计算机赋默认值，如 new int[10]
静态初始化：程序员赋值，计算机算长度，如 {1,3,5,7,9}
数组遍历：使用 for 循环配合 arr.length 遍历所有元素
索引越界异常：访问 0 ~ length-1 范围外的索引会抛出 ArrayIndexOutOfBoundsException

八、拓展阅读

概念	说明
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`（十六进制）
`break`	结束整个循环，继续执行循环后的代码
`continue`	结束本轮循环，跳过本轮剩余代码，直接进入下一轮
`return`	结束当前方法，方法内所有剩余代码都不执行
浮点精度	IEEE 754 标准导致 `0.1 + 0.2 ≠ 0.3`，避免用 `==` 直接比较浮点数
switch 穿透	不写 `break` 时 case 会穿透到下个 case，可利用此特性合并相同逻辑
嵌套循环	循环中嵌套循环，外层每轮内层完整执行一次，总次数 = 外层 × 内层
数字拆位	`n % 10` 取个位，`n / 10` 去掉个位，`while` 循环可逐位取出所有数字
图形打印	外层行、内层列、if 判断输出 `*` 或空格，是嵌套循环的经典二维应用
数组（Array）	引用数据类型，用于存储多个相同类型元素的容器
动态初始化	`new int[10]`，程序员指定长度，计算机赋默认值
静态初始化	`{1,2,3}`，程序员赋值，计算机计算长度
数组遍历	使用 `for` + `arr.length` 逐一访问每个元素
length 属性	数组的固有属性，表示数组的长度，创建后不可修改
索引越界	访问 `0 ~ length-1` 范围外的索引抛出 `ArrayIndexOutOfBoundsException`
数组默认值	int→0、double→0.0、char→''、boolean→false、引用类型→null

20260715-笔记.md 43 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 之间的整数

三种循环的核心区别

5. 循环控制语句（结束循环的三种方式）

① break — 结束整个循环

② continue — 结束本轮循环

③ return — 结束整个方法

三种控制语句对比

6. 流程控制中的常见陷阱

① 浮点类型精度问题

② switch 的穿透问题

7. while 循环实战练习

练习 1：统计整数位数

练习 2：求各位数字之和

8. 嵌套循环（Nested Loop）

练习 3：打印矩形星号图案（4 行 5 列）

练习 4：打印空心矩形星号图案（5 行 5 列）

练习 5：打印菱形星号图案（5 行）

三、数组（Array）

1. 数组概述

Java 数据类型回顾

数组的特点

2. 定义数组的格式

3. 数组的初始化

① 动态初始化

数组在内存中的地址

② 静态初始化

4. 数组元素的访问与赋值

为数组元素赋值

访问（读取）数组元素

使用 for 循环遍历数组

索引越界风险

5. 数组初始化方式对比

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

题目 1：判断闰年

题目 2：三个数比大小

题目 4：水仙花数判定

题目 5：简易计算器

题目 7：数字加密系统

五、知识拓展

1. break 在 switch 中的作用

2. 死循环

3. 整数的进制表示

六、完整代码汇总

Demo01.java — switch 分支语句

Demo02.java — 循环结构 + 流程控制陷阱

Demo03.java — 循环控制语句（break / continue / return）

Demo04.java — while 循环实战：统计整数位数

Demo05.java — while 循环实战：求各位数字之和

Demo06.java — 嵌套循环：打印矩形星号图案

Demo07.java — 嵌套循环：打印空心矩形星号图案

Demo08.java — 嵌套循环：打印菱形星号图案

Demo09.java — 数组（Array）

七、随堂练习要点

八、拓展阅读

20260715-笔记.md 43 KB

History Raw