JavaSE 基础 — Day05 笔记

日期：2026-07-17
项目：c260717
作者：WanJL

一、Java 方法（Method）

1. 方法概述

方法（Method） 在 Java 中称为方法，在 C/C++ 中称为函数。它们是给一段代码取名字，以后通过这个名字来调用这段代码。

作用：让代码可以复用，分解整个程序的复杂度，方便测试和调试。

2. 方法的四种声明方式

方法按照 是否具有返回值 和 是否具有参数 可以分为 4 种声明方式：

第 1 种：既没有参数、也没有返回值

public static void 方法名() {
    // 方法体：封装的代码
}

public static：修饰符（后续详细讲解）
void：当方法没有设置返回值类型时，需要使用 void 占位
方法名：调用时使用方法名调用
()：标识这是一个方法，并且可以定义参数

示例：计算用户输入的两个整数，累加后输出

public static void add() {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入第1个数：");
    int n1 = sc.nextInt();
    System.out.println("请输入第2个数：");
    int n2 = sc.nextInt();
    int sum = n1 + n2;
    System.out.println("计算结果为：" + sum);
}

调用方式：add();

第 2 种：有方法参数，但是没有方法返回值

public static void 方法名(参数类型1 参数名1, 参数类型2 参数名2, ..., 参数类型n 参数名n) {
    // 方法体
}

示例：计算两个整数相加并输出

public static void add(int a, int b) {
    int sum = a + b;
    System.out.println(sum);
}

调用方式：add(15, 7); — 传入实际参数值

第 3 种：有参数、有返回值

public static 返回值类型 方法名(参数类型1 参数名1, ..., 参数类型n 参数名n) {
    // 方法体
    return 返回值;  // 返回值类型必须与方法声明一致
}

返回值类型可以是 任何类型（int、double、boolean、int[] 等）
方法体中通过 return 语句返回结果
调用方可以接收返回值，也可以忽略（但一般都会接收使用）

示例：传入 int[] 数组参数，返回数组中的最大值

public static int getMaxElement(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

调用方式：

int[] scores = {80, 85, 77, 63, 84, 95, 86, 88};
int maxScore = getMaxElement(scores);   // 接收返回值
System.out.println("最高分：" + maxScore);  // 输出：最高分：95

3. main 方法调用示例

public static void main(String[] args) {
    sub(15, 7);        // 第2种：有参无返回值
    printFor();        // 第1种：无参无返回值
    getMax(7, 8, 9);   // 第2种：有参无返回值
    
    // 第3种：有参有返回值 — 接收返回值使用
    int[] scores = {80, 85, 77, 63, 84, 95, 86, 88};
    int maxScore = getMaxElement(scores);
    System.out.println("最高分：" + maxScore);
}

4. 方法练习（完整实现）

以下为课堂练习，使用上述方法知识完成实现：

练习 1：两数相减

/**
 * 声明一个计算2个整数相减的方法
 * @param a 被减数
 * @param b 减数
 */
public static void sub(int a, int b) {
    System.out.println(a - b);
}

调用方式：sub(15, 7); // 输出 8

练习 2：循环输出 1~100

/**
 * 声明一个循环输出1~100的整数的方法
 */
public static void printFor() {
    for (int i = 1; i <= 100; i++) {
        System.out.print(i + " ");
    }
    System.out.println();
}

练习 3：三个数中取最大值

/**
 * 声明一个获取三个变量中最大值的方法
 * @param a
 * @param b
 * @param c
 */
public static void getMax(int a, int b, int c) {
    int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
    System.out.println(max);
}

知识点：使用三元运算符嵌套实现三个数的最大值比较。

main 方法调用

public static void main(String[] args) {
    sub(15, 7);       // 两数相减
    printFor();       // 输出1~100
    getMax(7, 8, 9);  // 三个数取最大值
}

5. 第 3 种方法练习（有参有返回值）

以下练习对应第 3 种方法声明方式 —— public static 返回值类型方法名(参数) { return 值; }

练习 4：计算矩形周长

/**
 * 定义一个计算矩形周长的方法
 * @param length 长
 * @param width  宽
 * @return 矩形的周长
 */
public static double recPerimeter(double length, double width) {
    return 2 * (length + width);
}

调用方式：double p = recPerimeter(5.0, 3.0); // 返回 16.0

练习 5：计算矩形面积

/**
 * 定义一个计算矩形面积的方法
 * @param length 长
 * @param width  宽
 * @return 矩形的面积
 */
public static double recArea(double length, double width) {
    return length * width;
}

练习 6：计算圆形周长

/**
 * 定义一个计算圆形周长的方法
 * @param radius 半径
 * @return 圆形的周长
 */
public static double rotundityPerimeter(double radius) {
    return 2 * 3.1415926 * radius;
}

练习 7：计算圆形面积

/**
 * 定义一个计算圆形面积的方法
 * @param radius 半径
 * @return 圆形的面积
 */
public static double rotundityArea(double radius) {
    return 3.1415926 * radius * radius;
}

练习 8：判断闰年

/**
 * 定义一个判断年份是否是闰年的方法
 * @param year 年份
 * @return true 表示闰年，false 表示平年
 */
public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

闰年规则：能被 4 整除但不能被 100 整除，或者能被 400 整除。

二、方法进阶 —— 数组作为方法参数（Demo02）

1. 概念

方法不仅可以接收 int、double 等基本类型参数，还可以接收数组类型的参数。

public static void 方法名(数据类型[] 数组名) {
    // 方法体
}

2. 示例：将排序算法封装为方法

import java.util.Arrays;

public class Demo02 {

    // 冒泡排序方法
    public static void bubbleSort(int[] arr) {
        System.out.println("排序前：" + Arrays.toString(arr));
        // 排序代码（略）
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    // 选择排序方法（占位）
    public static void selectionSort(int[] arr) {}

    // 插入排序方法（占位）
    public static void insertionSort(int[] arr) {}

    public static void main(String[] args) {
        int[] myScore = {80, 85, 77, 63, 84, 95, 86, 88};
        bubbleSort(myScore);  // 传入数组名
    }
}

3. 关键点

项目	说明
参数声明	`(int[] arr)` — 参数类型为 `int[]` 数组
调用方式	`bubbleSort(myScore);` — 直接传入数组名（不带方括号）
数组toString	`Arrays.toString(arr)` — 将数组转换为可读的字符串形式
封装意义	将排序算法封装到方法中，方便复用和测试

4. Arrays.toString() 工具方法

Arrays.toString() 是 java.util.Arrays 类提供的静态方法，用于将数组转换为格式化的字符串：

int[] arr = {80, 85, 77, 63, 84, 95, 86, 88};
System.out.println(Arrays.toString(arr));
// 输出：[80, 85, 77, 63, 84, 95, 86, 88]

四、课后作业 —— 三种排序算法复习

二、课后作业 —— 三种排序算法复习

本日作业巩固了 7 月 16 日学习的三种排序算法。

作业 1：冒泡排序（HomeWork01）

// 冒泡排序 — 优化版本（带提前结束标记）
int[] arr = {29, 10, 14, 37, 13, 33, 48, 22};

// arr.length - 1 是比较的轮数
for (int i = 0; i < arr.length - 1; i++) {
    boolean b = false;  // 标记是否出现提前排完序的情况
    
    for (int j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
            // 通过加减法交换两数（不使用临时变量）
            arr[j] = arr[j] + arr[j + 1];
            arr[j + 1] = arr[j] - arr[j + 1];
            arr[j] = arr[j] - arr[j + 1];
            b = true;  // 标记本轮有交换，说明还没排完序
        }
    }
    
    // 如果 b == false，说明已经排序完成，提前跳出循环
    if (!b) {
        break;
    }
}

冒泡排序核心思想

项目	说明
排序方式	比较相邻元素的大小，较大的交换位置
最多轮数	长度 - 1 轮
每轮比较次数	逐次减少，最长 - 1 次
优化手段	通过 `boolean` 标记判断是否提前完成排序
交换技巧	使用加减法交换两数，无需临时变量

作业 2：选择排序 — 降序（HomeWork02）

选择排序：选出来最小的元素，和第 1 个元素进行交换。每一轮外层循环只交换 1 次。

// 选择排序（降序）— 选最大的
int[] arr = {56, 23, 89, 12, 45, 67, 34, 78};

// 外层循环，i 既是已排序区间的末尾边界，也是当前要确定的位置
for (int i = 0; i < arr.length - 1; i++) {
    // 假设当前未排序区间的第 1 个元素是最大的
    int maxIndex = i;
    
    // 通过一轮循环，选出最大元素的索引值
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[j] > arr[maxIndex]) {
            maxIndex = j;
        }
    }
    
    // 如果最大值不在 i 的位置，则交换
    if (maxIndex != i) {
        arr[maxIndex] = arr[maxIndex] + arr[i];
        arr[i] = arr[maxIndex] - arr[i];
        arr[maxIndex] = arr[maxIndex] - arr[i];
    }
}

选择排序核心思想

项目	说明
排序方式	每轮选出最大（或最小）元素，与当前位置交换
交换次数	每轮最多交换 1 次
降序实现	每轮选出最大值放到前面
交换条件	仅当 `maxIndex != i` 时才交换

作业 3：插入排序 — 升序（HomeWork03）

把一个数组分为两部分：已排序部分和未排序部分。从未排序部分取出第 1 个元素，与已排序部分从最后一个元素开始比较，直到找到比这个元素小的元素，放到它后面。

// 插入排序（升序）
int[] studentScores = {88, 72, 93, 65, 81, 97, 78, 85};

// 从第 2 个元素开始（假设第 1 个元素是已排序部分）
for (int i = 1; i < studentScores.length; i++) {
    // 当前要插入的元素
    int current = studentScores[i];
    // 已排序部分的最后一个元素的索引
    int j = i - 1;
    
    // 从后往前扫描已排序部分，寻找插入位置
    while (j >= 0 && studentScores[j] > current) {
        studentScores[j + 1] = studentScores[j];  // 往后移动一位
        j--;
    }
    
    // j + 1 就是 current 应该插入的位置
    studentScores[j + 1] = current;
}

插入排序核心思想

项目	说明
排序方式	将数组分为已排序和未排序两部分
起始状态	`studentScores[0]` 为已排序部分
插入方式	从后往前扫描已排序部分，找到合适位置插入
移动方式	比当前元素大的元素均向后移动一位

五、课后作业 —— Scanner 学生信息采集系统（HomeWork04）

使用 Scanner 键盘输入，采集学生信息并计算 BMI 指数。

信息采集表

信息项	数据类型	提示语
姓名	`String`	`请输入您的姓名：`
学号	`String`	`请输入您的学号：`
年龄	`int`	`请输入您的年龄：`
性别	`String`	`请输入您的性别（男/女）：`
身高（米）	`double`	`请输入您的身高（米）：`
体重（公斤）	`double`	`请输入您的体重（公斤）：`
是否在校	`boolean`	`请输入您是否在校（true/false）：`

开发中常用的类型选择

场景	推荐类型	说明
整数	`int`	大部分整数使用 int
字符、数字、符号	`String`	其余所有情况基本都用 String
小数	`double`	所有小数都使用 double
二值选择	`boolean`	可能出现 2 个值的，一般用于判断

完整代码示例

public static void main(String[] args) {
    // 1、创建 Scanner 对象
    Scanner sc = new Scanner(System.in);
    
    System.out.println("请输入您的姓名：");
    String name = sc.next();
    System.out.println("请输入您的学号：");
    String id = sc.next();
    System.out.println("请输入您的年龄：");
    int age = sc.nextInt();
    System.out.println("请输入您的性别（男/女）：");
    String gender = sc.next();
    System.out.println("请输入您的身高（米）：");
    double height = sc.nextDouble();
    System.out.println("请输入您的体重（公斤）：");
    double weight = sc.nextDouble();
    System.out.println("请输入您是否在校（true/false）：");
    boolean isStudent = sc.nextBoolean();
    
    System.out.println("======== 学生信息卡 ========");
    System.out.println("姓名：" + name);
    System.out.println("学号：" + id);
    System.out.println("年龄：" + age);
    System.out.println("性别：" + gender);
    System.out.println("身高：" + height);
    System.out.println("体重：" + weight);
    System.out.println("在校学生：" + isStudent);
    
    // BMI = 体重 ÷ (身高 × 身高)
    double bmi = weight / (height * height);
    System.out.printf("BMI：%.2f", bmi);
    System.out.println();
    
    // 体型判定
    int b;
    if (bmi < 18.5) {
        b = 1;
    } else if (bmi >= 18.5 && bmi < 24) {
        b = 2;
    } else if (bmi >= 24 && bmi < 28) {
        b = 3;
    } else {
        b = 4;
    }
    
    System.out.print("体型判定：");
    switch (b) {
        case 1 -> System.out.println("偏瘦");
        case 2 -> System.out.println("正常");
        case 3 -> System.out.println("偏胖");
        default -> System.out.println("肥胖");
    }
    System.out.println("============================");
}

BMI 判定标准

BMI 范围	体型判定
BMI < 18.5	偏瘦
18.5 ≤ BMI < 24	正常
24 ≤ BMI < 28	偏胖
BMI ≥ 28	肥胖

知识点回顾

Scanner 基础方法：
- sc.next() — 读取字符串
- sc.nextInt() — 读取整数
- sc.nextDouble() — 读取小数
- sc.nextBoolean() — 读取布尔值
printf 格式化输出：System.out.printf("BMI：%.2f", bmi); — 保留两位小数
switch 箭头语法：case 1 -> System.out.println("偏瘦"); — Java 14+ 新特性

六、本日总结

知识点	主要内容
Java 方法	方法的定义、4 种声明方式、参数传递、方法调用
第 1 种：无参无返回值	`void 方法名()` — 打印菜单、输出固定内容
第 2 种：有参无返回值	`void 方法名(参数)` — sub、printFor、getMax、打印三角形
第 3 种：有参有返回值	`返回值类型方法名(参数)` — getMaxElement、recPerimeter、recArea、rotundityPerimeter、rotundityArea、isLeapYear
方法练习实现	`sub` 两数相减、`printFor` 输出1~100、`getMax` 三元运算符求最大值
数组作为方法参数	`bubbleSort(int[] arr)` 将数组传入方法、`Arrays.toString()` 打印数组
冒泡排序	相邻比较、交换、提前结束优化
选择排序	每轮选最大值、降序排列
插入排序	已排序/未排序分区、从后往前插入
Scanner 综合应用	学生信息采集、BMI 计算与体型判定
switch 箭头语法	`case ->` 新式写法
printf 格式化	`%.2f` 保留两位小数

20260717-笔记.md 16 KB Lịch sử Raw