# 2026-07-17 JavaSE 课后作业

> **课程内容**：Java 方法 4 种声明方式（无参无返回值 / 有参无返回值 / 有参有返回值 / 无参有返回值）、方法中调用方法、数组作为方法参数、Random 随机数类  
> **提交方式**：在 `提交\姓名\` 目录下创建对应的 Java 源文件  
> **截止时间**：下次上课前

---

## 一、基础题（必做 · 方法声明与调用）

### 题目 1：无参无返回值 — 打印个人信息卡片

**难度**：⭐  
**知识点**：第 1 种方法（无参无返回值）

定义一个方法 `printInfoCard`，调用后在控制台打印如下格式的信息卡片（内容可自定义）：

```
╔══════════════════════╗
║      个人信息卡       ║
╠══════════════════════╣
║  姓名：张三           ║
║  班级：J260713        ║
║   motto：好好学习！    ║
╚══════════════════════╝
```

**要求**：
- 方法类型：**无参数、无返回值**
- 在 `main` 方法中直接调用

**示例代码框架**：
```java
/**
 * @author 你的姓名
 * @title 题目1：打印个人信息卡片
 * @create 2026/7/17
 */
public class Demo_01_姓名 {
    public static void printInfoCard() {
        // 打印个人信息卡片
    }

    public static void main(String[] args) {
        printInfoCard();
    }
}
```

> 💡 **提示**：`System.out.println()` 逐行打印，可以用特殊符号（╔ ╗ ║ ╚ ╝ ═ ╣）装饰边框。

---

### 题目 2：有参无返回值 — 打印 n 行倒直角三角形

**难度**：⭐⭐  
**知识点**：第 2 种方法（有参无返回值）、嵌套循环

定义一个方法 `printInvertedTriangle`，接收一个整数参数 `n`，打印 n 行的**倒直角三角形**（由 `*` 组成）。

**示例**：
```
调用：printInvertedTriangle(5)
输出：
*****
****
***
**
*
```

**要求**：
- 方法类型：**有参数（int n）、无返回值**
- 在 `main` 方法中分别调用 `printInvertedTriangle(5)` 和 `printInvertedTriangle(3)` 测试

**示例代码框架**：
```java
/**
 * @author 你的姓名
 * @title 题目2：打印倒直角三角形
 * @create 2026/7/17
 */
public class Demo_02_姓名 {
    public static void printInvertedTriangle(int n) {
        // 嵌套循环打印倒直角三角形
    }

    public static void main(String[] args) {
        printInvertedTriangle(5);
        System.out.println();  // 两图之间空一行
        printInvertedTriangle(3);
    }
}
```

> 💡 **提示**：第 i 行打印 `n - i` 个 `*`，外层循环从 `n` 递减到 `1`。

---

### 题目 3：有参有返回值 — 计算平均数

**难度**：⭐⭐  
**知识点**：第 3 种方法（有参有返回值）、数组遍历

定义一个方法 `average`，接收一个 `int[]` 数组参数，计算并返回数组中所有元素的平均值（`double` 类型）。

**示例**：
```
调用：average({80, 90, 100, 70, 85})
返回：85.0

调用：average({60, 75, 80})
返回：71.66666666666667
```

**要求**：
- 方法类型：**有参数（int[] 数组）、有返回值（double）**
- 在 `main` 方法中创建测试数组并调用 `average` 方法输出结果

**示例代码框架**：
```java
/**
 * @author 你的姓名
 * @title 题目3：计算数组平均值
 * @create 2026/7/17
 */
public class Demo_03_姓名 {
    public static double average(int[] arr) {
        // 计算平均值
    }

    public static void main(String[] args) {
        int[] scores = {80, 90, 100, 70, 85};
        double avg = average(scores);
        System.out.println("平均分：" + avg);
    }
}
```

> 💡 **提示**：先求和再除以数组长度 `arr.length`，注意整数除法会丢失小数。

---

### 题目 4：无参有返回值 — 获取当前时间问候语

**难度**：⭐⭐  
**知识点**：第 4 种方法（无参有返回值）、条件判断

定义一个方法 `getGreeting`，根据当前系统时间返回对应的问候语字符串：
- 6:00 ~ 11:59 → `"上午好"`
- 12:00 ~ 17:59 → `"下午好"`
- 18:00 ~ 23:59 → `"晚上好"`
- 0:00 ~ 5:59 → `"夜深了，注意休息"`

**示例**（假设现在下午 3 点）：
```
调用：getGreeting()
返回："下午好"
```

**要求**：
- 方法类型：**无参数、有返回值（String）**
- 使用 `java.time.LocalTime.now().getHour()` 获取当前小时数
- 在 `main` 方法中调用并拼接输出完整语句

**示例代码框架**：
```java
import java.time.LocalTime;

/**
 * @author 你的姓名
 * @title 题目4：获取问候语
 * @create 2026/7/17
 */
public class Demo_04_姓名 {
    public static String getGreeting() {
        int hour = LocalTime.now().getHour();
        // 根据 hour 返回对应的问候语
    }

    public static void main(String[] args) {
        String greeting = getGreeting();
        System.out.println("亲爱的同学，" + greeting + "！");
    }
}
```

---

### 题目 5：方法中调用方法 — 摄氏温度转华氏温度

**难度**：⭐⭐  
**知识点**：方法中调用另一个方法

现实生活中不同国家使用不同的温度单位，我国使用**摄氏度（℃）**，美国等国家使用**华氏度（℉）**。

要求按如下层次定义方法：

| 方法 | 类型 | 说明 |
|------|------|------|
| `celsiusToFahrenheit(double c)` | 有参有返回值 | 将摄氏度转为华氏度：`℉ = ℃ × 9/5 + 32` |
| `fahrenheitToCelsius(double f)` | 有参有返回值 | 将华氏度转为摄氏度：`℃ = (℉ - 32) × 5/9` |
| `printTemperature(double c)` | 有参无返回值 | 调用上面两个方法，输出摄氏度与华氏度的对照 |

**示例**：
```
调用：printTemperature(25.0)
输出：
摄氏温度：25.00℃
华氏温度：77.00℉
```

**示例代码框架**：
```java
/**
 * @author 你的姓名
 * @title 题目5：温度转换
 * @create 2026/7/17
 */
public class Demo_05_姓名 {
    public static double celsiusToFahrenheit(double c) {
        return c * 9.0 / 5.0 + 32.0;
    }

    public static double fahrenheitToCelsius(double f) {
        return (f - 32.0) * 5.0 / 9.0;
    }

    public static void printTemperature(double c) {
        // 调用 celsiusToFahrenheit() 方法
        // 格式化输出摄氏度和华氏度（保留2位小数）
    }

    public static void main(String[] args) {
        printTemperature(25.0);
        printTemperature(100.0);
        printTemperature(0.0);
    }
}
```

> 💡 **提示**：可以使用 `System.out.printf("%.2f", 数值)` 保留两位小数；摄氏度符号用 `℃`、华氏度用 `℉`。

---

## 二、进阶题（必做 · 综合应用）

### 题目 6：数组作为方法参数 — 冒泡排序方法封装

**难度**：⭐⭐⭐  
**知识点**：数组作为方法参数、冒泡排序、`Arrays.toString()`

将冒泡排序封装为一个独立的方法 `bubbleSort`，接收 `int[]` 数组参数，在方法内部完成排序并打印结果。

**要求**：
- 定义一个方法 `bubbleSort(int[] arr)` — 按**升序**排序（从小到大）
- 方法内部使用 `Arrays.toString()` 输出排序前和排序后的数组
- 在 `main` 方法中测试以下两个数组：
  - `{64, 34, 25, 12, 22, 11, 90}`
  - `{5, 1, 4, 2, 8}`

**示例输出**：
```
测试数组1：
排序前：[64, 34, 25, 12, 22, 11, 90]
排序后：[11, 12, 22, 25, 34, 64, 90]

测试数组2：
排序前：[5, 1, 4, 2, 8]
排序后：[1, 2, 4, 5, 8]
```

**示例代码框架**：
```java
import java.util.Arrays;

/**
 * @author 你的姓名
 * @title 题目6：冒泡排序方法封装
 * @create 2026/7/17
 */
public class Demo_06_姓名 {
    public static void bubbleSort(int[] arr) {
        System.out.println("排序前：" + Arrays.toString(arr));
        // 冒泡排序代码
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    public static void main(String[] args) {
        int[] arr1 = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr1);
        System.out.println();
        int[] arr2 = {5, 1, 4, 2, 8};
        bubbleSort(arr2);
    }
}
```

---

### 题目 7：Random + 方法 — 随机密码生成器

**难度**：⭐⭐⭐  
**知识点**：`Random` 类、第 4 种方法（无参有返回值）、字符串拼接

定义一个方法 `generatePassword`，生成并返回一个 8 位随机密码，密码由**大写字母**和**数字**混合组成。

> **规则**：
> - 密码长度为 8 位
> - 每一位随机是大写字母（A~Z）或数字（0~9）
> - 使用 `Random` 类生成随机数

**提示**：
- 大写字母 `A~Z` 的 ASCII 码范围是 65~90
- 数字 `0~9` 的 ASCII 码范围是 48~57
- 可以先生成一个随机数决定当前位是字母还是数字，再生成具体字符
- 用 `String` 拼接每一位（`str += ch`）

**示例**（每次运行结果不同）：
```
调用：generatePassword()
返回："A3K9Q7B2"

调用：generatePassword()
返回："5X1P8M4J"
```

**示例代码框架**：
```java
import java.util.Random;

/**
 * @author 你的姓名
 * @title 题目7：随机密码生成器
 * @create 2026/7/17
 */
public class Demo_07_姓名 {
    public static String generatePassword() {
        Random ran = new Random();
        String password = "";
        // 循环8次，每次生成一个字符拼接
        return password;
    }

    public static void main(String[] args) {
        String pwd = generatePassword();
        System.out.println("生成的密码：" + pwd);
        System.out.println("密码长度：" + pwd.length() + " 位");
    }
}
```

> 💡 **提示**：`ran.nextInt(2)` 可以随机生成 0 或 1，用来决定当前位是字母还是数字；使用 `(char)(ran.nextInt(26) + 65)` 生成随机大写字母。

---

### 题目 8：Random + 方法 — 数组随机打乱（Fisher-Yates 洗牌算法）

**难度**：⭐⭐⭐⭐  
**知识点**：数组作为方法参数、`Random` 类、数组交换

定义一个方法 `shuffleArray`，接收一个 `int[]` 数组，使用 Fisher-Yates 洗牌算法**随机打乱**数组元素的顺序（在原数组上操作，不创建新数组）。

**要求**：
- 方法类型：**有参数（int[]）、无返回值**（直接修改原数组）
- 使用 `Random` 类生成随机索引
- 在 `main` 方法中测试 `{1, 2, 3, 4, 5, 6, 7}` 数组

**算法思路**（Fisher-Yates）：
```
从数组最后一个元素开始往前遍历（i 从 length-1 到 1）：
    1. 生成一个随机索引 j，范围 [0, i]
    2. 交换 arr[i] 和 arr[j]
```

**示例**（每次运行结果不同）：
```
打乱前：[1, 2, 3, 4, 5, 6, 7]
打乱后：[4, 7, 2, 1, 6, 3, 5]

再次运行：
打乱前：[1, 2, 3, 4, 5, 6, 7]
打乱后：[3, 1, 5, 7, 2, 6, 4]
```

**示例代码框架**：
```java
import java.util.Arrays;
import java.util.Random;

/**
 * @author 你的姓名
 * @title 题目8：数组随机打乱
 * @create 2026/7/17
 */
public class Demo_08_姓名 {
    public static void shuffleArray(int[] arr) {
        Random ran = new Random();
        // 从后往前遍历，实现 Fisher-Yates 洗牌
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        System.out.println("打乱前：" + Arrays.toString(arr));
        shuffleArray(arr);
        System.out.println("打乱后：" + Arrays.toString(arr));
    }
}
```

> 💡 **提示**：`ran.nextInt(i + 1)` 生成 0 ~ i 的随机索引；遍历时 `i` 从 `arr.length - 1` 递减到 `1`。

---

## 三、挑战题（选做）

### 题目 9：综合大作业 — 随机抽奖系统

**难度**：⭐⭐⭐⭐⭐  
**知识点**：方法 4 种声明方式综合、数组作为方法参数、Random 类、方法中调用方法

实现一个**随机抽奖系统**，将程序拆分为多个方法：

| 方法 | 类型 | 说明 |
|------|------|------|
| `initParticipants()` | 无参有返回值 | 创建并返回一个包含 10 个参与者姓名的 `String[]` 数组（姓名自拟） |
| `printParticipants(String[] names)` | 有参无返回值 | 遍历打印所有参与者的编号和姓名 |
| `luckyDraw(String[] names)` | 有参无返回值 | 从参与者数组中随机抽取一个姓名并输出中奖信息 |
| `shuffleArray(String[] arr)` | 有参无返回值 | 使用 Fisher-Yates 算法随机打乱数组（参考题目 8） |

**要求**：
- `luckyDraw` 方法内部调用 `shuffleArray` 打乱数组，然后取第 1 个元素作为中奖者
- `main` 方法中调用以上方法完成完整的抽奖流程

**示例输出**：
```
======== 随机抽奖系统 ========
参与人员：
1. 张三
2. 李四
3. 王五
4. 赵六
5. 钱七
6. 孙八
7. 周九
8. 吴十
9. 郑十一
10. 陈十二
==============================
🎉 恭喜 王五 中奖！🎉
```

**示例代码框架**：
```java
import java.util.Arrays;
import java.util.Random;

/**
 * @author 你的姓名
 * @title 题目9：随机抽奖系统
 * @create 2026/7/17
 */
public class Demo_09_姓名 {
    public static String[] initParticipants() {
        // 返回包含10个姓名的数组
    }

    public static void printParticipants(String[] names) {
        // 遍历打印编号+姓名
    }

    public static void shuffleArray(String[] arr) {
        // Fisher-Yates 洗牌算法
    }

    public static void luckyDraw(String[] names) {
        // 1. 调用 shuffleArray 打乱数组
        // 2. 取第1个元素作为中奖者输出
    }

    public static void main(String[] args) {
        System.out.println("======== 随机抽奖系统 ========");
        String[] participants = initParticipants();
        System.out.println("参与人员：");
        printParticipants(participants);
        System.out.println("==============================");
        luckyDraw(participants);
    }
}
```

> 💡 **提示**：`String[]` 数组的洗牌算法和 `int[]` 完全一样，只是元素类型不同。

---

## 四、提交要求

1. 在 `提交` 文件夹下创建【以你名字命名】的文件夹，然后将 Java 源文件复制进去
2. 每个题目一个文件，命名格式：`Demo_题目编号_姓名.java`
   - 例如：`Demo_01_张三.java`
3. 文件头部使用文档注释，包含：
   ```java
   /**
    * @author 你的姓名
    * @title 题目X：题目名称
    * @create 2026/7/17
    */
   ```
4. 代码整洁，有必要的注释
5. **基础题（1~5）为必做**
6. **进阶题（6~8）为必做**
7. **挑战题（9）为选做**，鼓励学有余力的同学尝试