【Java SE 基础学习打卡】28 方法的定义与调用

编程火箭车2026-01-16 10:09

目录

  • 前言
  • 一、先记死：方法的定义格式
  • [二、逐个拆解：方法定义的 6 个核心组成部分](#二、逐个拆解：方法定义的 6 个核心组成部分)
    • [2.1 修饰符（新手先掌握 public static）](#2.1 修饰符（新手先掌握 public static）)
    • [2.2 返回值类型：方法执行完 "要不要返回结果、返回什么类型的结果"](#2.2 返回值类型：方法执行完 “要不要返回结果、返回什么类型的结果”)
    • [2.3 方法名：给你的 "工具" 起名字（见名知意）](#2.3 方法名：给你的 “工具” 起名字（见名知意）)
    • [2.4 参数列表：给方法的 "原材料"（新手核心难点）](#2.4 参数列表：给方法的 “原材料”（新手核心难点）)
    • [2.5 方法体：方法的 "核心功能代码"](#2.5 方法体：方法的 “核心功能代码”)
    • [2.6 return 语句：方法的 "产出 / 结束信号"](#2.6 return 语句：方法的 “产出 / 结束信号”)
  • [三、实操 1：无参方法的定义与调用（最简单的入门案例）](#三、实操 1：无参方法的定义与调用（最简单的入门案例）)
  • [四、实操 2：带参方法的定义与调用（核心重点）](#四、实操 2：带参方法的定义与调用（核心重点）)
    • [4.1 场景 1：计算两数之和（单个返回值，两个参数）](#4.1 场景 1：计算两数之和（单个返回值，两个参数）)
    • [4.2 场景 2：计算 1 到 n 的和（单个参数，循环逻辑）](#4.2 场景 2：计算 1 到 n 的和（单个参数，循环逻辑）)
    • [4.3 参数传递逻辑（新手必须懂）](#4.3 参数传递逻辑（新手必须懂）)
  • 五、方法调用的执行流程（从内存角度简单说）
    • [5.1 核心概念：方法栈（临时工作台）](#5.1 核心概念：方法栈（临时工作台）)
    • [5.2 执行流程拆解（以 add (10,20) 为例）](#5.2 执行流程拆解（以 add (10,20) 为例）)
    • [5.3 生活化类比](#5.3 生活化类比)
  • [六、新手必避的 7 个 "致命坑"（反例 + 正例 + 后果）](#六、新手必避的 7 个 “致命坑”（反例 + 正例 + 后果）)
    • [6.1 坑 1：返回值类型和 return 值类型不匹配](#6.1 坑 1：返回值类型和 return 值类型不匹配)
    • [6.2 坑 2：有返回值的方法漏写 return 语句](#6.2 坑 2：有返回值的方法漏写 return 语句)
    • [6.3 坑 3：调用方法时参数个数不匹配](#6.3 坑 3：调用方法时参数个数不匹配)
    • [6.4 坑 4：调用方法时参数类型不匹配](#6.4 坑 4：调用方法时参数类型不匹配)
    • [6.5 坑 5：方法名写错（调用和定义不一致）](#6.5 坑 5：方法名写错（调用和定义不一致）)
    • [6.6 坑 6：在方法体里定义方法（方法嵌套）](#6.6 坑 6：在方法体里定义方法（方法嵌套）)
    • [6.7 坑 7：void 方法里 return 后跟值](#6.7 坑 7：void 方法里 return 后跟值)
  • 总结

前言

上一节咱们搞懂了方法的核心概念 ------ 方法是可复用的代码块，就像生活里的 "工具"。但光知道 "工具好用" 还不够，得学会 "怎么造工具（定义方法）" 和 "怎么用工具（调用方法）"：比如想造一个 "计算两数之和的工具"，该怎么给工具起名、定规则？想使用这个工具时，该怎么传递数字、怎么拿到计算结果？

这一节咱们就从 "实操" 角度讲透方法：先记牢方法的定义格式，再拆解每个组成部分的规则（重点是返回值和参数），然后通过无参、带参两个场景的完整例子，掌握定义和调用的全流程，最后从内存角度简单理解方法调用的执行逻辑。

一、先记死：方法的定义格式

方法的定义就像 "造工具的图纸"，必须按固定格式写，少一个关键部分都不行。先记住完整模板，后续再拆解每部分的作用：

java 复制代码 
// 方法定义完整模板
修饰符 返回值类型 方法名(参数列表) {
    // 方法体：工具的核心功能代码
    执行语句;
    // return语句：根据返回值类型决定是否写、写什么
    return 返回值;
}

举个直观的 "成品例子"（计算两数之和的方法），对应模板看结构：

java 复制代码 
// 修饰符：public static | 返回值类型：int | 方法名：add | 参数列表：int num1, int num2
public static int add(int num1, int num2) {
    // 方法体：求和逻辑
    int result = num1 + num2;
    // return语句：返回求和结果（类型和返回值类型int一致）
    return result;
}

二、逐个拆解：方法定义的 6 个核心组成部分

咱们把模板拆成 6 个部分，逐个讲清楚 "是什么、怎么写、要注意什么"，重点攻克返回值和参数两个新手难点：

2.1 修饰符（新手先掌握 public static）

  • 作用 ：规定方法的 "访问权限" 和 "调用方式"，新手阶段不用深究，先固定写public static（后续学面向对象再细化）；

  • 写法 ：public static是固定组合，写在返回值类型前面；

  • 注意：新手不用改这部分，按模板写就行，避免出错。

2.2 返回值类型：方法执行完 "要不要返回结果、返回什么类型的结果"

这是新手最容易错的部分，核心规则：返回值类型决定了 return 语句要返回什么类型的数据。

  • 两种核心类型：
返回值类型 含义 对应 return 语句 例子（工具类比）
void 方法执行完不返回任何结果 可以写return;（可选）或不写 打印欢迎语的工具（只输出，不返回东西）
具体类型 方法执行完返回对应类型的结果 必须写return 对应类型的值; 求和工具（返回 int 类型的和）、求平均分工具（返回 double 类型的平均分）

注意：

  • 返回值类型可以是 int、double、boolean 等基本类型，也可以是后续学的字符串、数组等；

  • 不能乱写类型，比如返回值类型写 int，return 就不能返回字符串（编译报错）。

2.3 方法名：给你的 "工具" 起名字（见名知意）

  • 命名规则（新手必守）：

    1. 小驼峰命名：第一个单词小写，后续单词首字母大写（比如addNum、printWelcome、calcAvg）；

    2. 见名知意：用动词 + 名词，一眼知道功能（比如calcAvg=calculate average，计算平均分；print99Table= 打印 99 乘法表）；

    3. 不能用关键字（比如 if、for、while），不能以数字开头。

  • 反例（新手别踩） ：add123（无意义）、PrintWelcome（大驼峰）、123add（数字开头）。

2.4 参数列表：给方法的 "原材料"（新手核心难点）

参数列表就是调用方法时，需要传给方法的 "原材料"------ 比如调用求和方法，需要传两个数字作为 "原材料"。

  • 核心概念：

    • 形参（形式参数）：方法定义时写的参数（比如int num1），相当于 "工具的原材料入口"；

    • 实参（实际参数）：方法调用时传的具体值（比如add(10,20)里的 10、20），相当于 "实际放进工具的原材料"。

  • 语法规则：

    1. 格式：类型1 参数名1, 类型2 参数名2, ...（多个参数用逗号分隔）；

    2. 每个参数必须指定类型（哪怕都是 int，也要分别写：int a, int b，不能写int a,b？不，其实可以，但新手建议分开写，更清晰）；

    3. 无参数：括号里空着（()），表示方法不需要原材料；

    4. 参数名不能重复（比如int a, int a是错的）。

  • 例子：

    • 无参：printWelcome()（打印欢迎语，不用原材料）；

    • 单个参数：sumToN(int n)（计算 1 到 n 的和，需要传 n）；

    • 多个参数：calcAvg(int chinese, int math, int english)（计算三科平均分，需要传三个成绩）。

2.5 方法体：方法的 "核心功能代码"

  • 作用：存放实现方法功能的所有代码（循环、判断、运算等）；

  • 注意：

    1. 必须用{}包裹，哪怕只有一行代码；

    2. 方法体里可以调用其他方法（比如在calcAvg里调用add方法求和）；

    3. 不能在方法体里再定义方法（比如在 add 方法里再定义 print 方法，编译报错）。

2.6 return 语句：方法的 "产出 / 结束信号"

return 语句的作用分两种，和返回值类型强绑定：

  • 情况 1：返回值类型是 void（无返回值）：

    • 可以不写 return 语句；

    • 如果写，只能写return;（表示立即结束方法），后面不能跟任何值。

    java 复制代码 
    // 例子：打印欢迎语（void类型）
public static void printWelcome() {
    System.out.println("欢迎学习Java方法！");
    return; // 可选，写了表示立即结束方法（这里写不写效果一样）
}

  • 情况 2：返回值类型是具体类型（比如 int、double）：

    • 必须写return 对应类型的值;；

    • return 后面的值类型必须和返回值类型一致（比如返回值类型是 int，return 就不能返回 10.5）；

    • return 语句执行后，方法立即结束，后面的代码不会执行。

    java 复制代码 
    // 例子：求和方法（int类型返回值）
public static int add(int num1, int num2) {
    int result = num1 + num2;
    return result; // 必须写，且类型是int
    System.out.println("这行代码永远执行不到"); // return后不可达，编译报错
}

三、实操 1：无参方法的定义与调用（最简单的入门案例）

无参方法就是 "不需要原材料的工具"，比如 "打印固定欢迎语""打印 99 乘法表"（不需要传参数，直接执行）。

完整例子：定义并调用 "打印欢迎语" 的无参方法

java 复制代码 
public class MethodDemo1 {
    // 1. 定义无参方法（返回值类型void，参数列表为空）
    public static void printWelcome() {
        // 方法体：核心功能（打印欢迎语）
        System.out.println("======================");
        System.out.println("  欢迎学习Java方法！");
        System.out.println("  今天学方法的定义与调用～");
        System.out.println("======================");
        // void类型，return可选（这里省略）
    }

    // 程序入口：main方法（所有代码从这里开始执行）
    public static void main(String[] args) {
        // 2. 调用无参方法：方法名+()
        System.out.println("调用方法前...");
        printWelcome(); // 调用printWelcome方法
        System.out.println("调用方法后...");
    }
}

执行结果：

java 复制代码 
调用方法前...
======================
  欢迎学习Java方法！
  今天学方法的定义与调用～
======================
调用方法后...

调用执行流程拆解（新手必懂）：

  1. 程序从 main 方法开始执行，先打印 "调用方法前..."；

  2. 执行printWelcome()，跳转到 printWelcome 方法的定义处；

  3. 执行 printWelcome 方法体里的所有打印语句；

  4. printWelcome 方法执行完，回到 main 方法的调用处，继续执行后面的 "调用方法后..."。

四、实操 2：带参方法的定义与调用（核心重点）

带参方法是最常用的场景，比如 "计算两数之和""计算 1 到 n 的和""计算平均分"，需要传参数才能执行。

4.1 场景 1：计算两数之和（单个返回值，两个参数）

java 复制代码 
public class MethodDemo2 {
    // 1. 定义带参方法：返回值类型int，参数列表int num1, int num2
    public static int add(int num1, int num2) {
        // 方法体：求和逻辑
        int sum = num1 + num2;
        // return返回求和结果（类型和返回值类型int一致）
        return sum;
    }

    public static void main(String[] args) {
        // 2. 调用带参方法：方法名+(实参1, 实参2)
        // 方式1：直接传字面量（固定值）
        int result1 = add(10, 20);
        System.out.println("10+20=" + result1); // 输出30

        // 方式2：传变量（更灵活）
        int a = 30, b = 40;
        int result2 = add(a, b);
        System.out.println("30+40=" + result2); // 输出70

        // 方式3：嵌套调用（方法返回值作为实参）
        int result3 = add(result1, result2);
        System.out.println("30+70=" + result3); // 输出100
    }
}

4.2 场景 2：计算 1 到 n 的和（单个参数，循环逻辑）

java 复制代码 
public class MethodDemo3 {
    // 定义带参方法：参数n表示计算到的数字，返回值是求和结果
    public static int sumToN(int n) {
        int sum = 0;
        // 方法体里可以用循环（之前学的知识）
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum; // 返回求和结果
    }

    public static void main(String[] args) {
        // 调用方法，传不同的实参
        System.out.println("1-10的和：" + sumToN(10)); // 55
        System.out.println("1-100的和：" + sumToN(100)); // 5050
    }
}

4.3 参数传递逻辑（新手必须懂）

Java 中参数传递的核心是 "值传递"------ 把实参的 "值" 复制一份传给形参，形参的修改不会影响实参：

java 复制代码 
public class ParamDemo {
    public static void changeNum(int num) {
        num = 100; // 修改形参的值
    }

    public static void main(String[] args) {
        int a = 10;
        changeNum(a); // 传实参a的值（10）给形参num
        System.out.println(a); // 输出10，实参a的值没被修改
    }
}

类比理解：你有一张 10 元纸币（实参），复制了一张假币（形参）给别人，别人把假币改成 100 元，你的真币还是 10 元 ------ 形参是实参的 "副本"，修改副本不影响原数据。

五、方法调用的执行流程（从内存角度简单说）

新手不用深入理解内存模型，只需记住 "方法栈帧" 的核心逻辑，能解释执行顺序即可：

5.1 核心概念：方法栈（临时工作台）

JVM 中有一块内存叫 "方法栈"，就像工厂里的 "临时工作台"：

  • 调用方法时：JVM 为这个方法创建一个 "栈帧"（工作台），把参数、局部变量等放在里面；

  • 方法执行时：在自己的栈帧里运行代码；

  • 方法执行完：栈帧被销毁（工作台被拆掉），回到调用处继续执行。

5.2 执行流程拆解（以 add (10,20) 为例）

5.3 生活化类比

你（main 方法）在办公室干活，需要算 10+20：

  1. 你喊 "add 工具帮我算 10+20"（调用方法）；

  2. 仓库给 add 工具搭一个临时工作台（创建栈帧），把 10、20 放到台上（传参）；

  3. add 工具在台上算出 30（执行方法体）；

  4. add 工具把 30 递给你，拆掉工作台（销毁栈帧）；

  5. 你把 30 记下来，继续干自己的活（回到 main 方法）。

六、新手必避的 7 个 "致命坑"（反例 + 正例 + 后果）

6.1 坑 1：返回值类型和 return 值类型不匹配

  • 错误示例：

    java 复制代码 
    public static int add(int a, int b) {
    double sum = a + b;
    return sum; // 返回值类型是int，却返回double
}

  • 后果：编译报错！提示 "不兼容的类型：double 无法转换为 int"；

  • 正确示例：

    java 复制代码 
    public static int add(int a, int b) {
    int sum = a + b;
    return sum; // 类型一致
}

6.2 坑 2：有返回值的方法漏写 return 语句

  • 错误示例：

    java 复制代码 
    public static int sumToN(int n) {
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum += i;
    }
    // 漏写return
}

  • 后果：编译报错！提示 "缺少返回语句"；

  • 正确示例：

    java 复制代码 
    public static int sumToN(int n) {
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum += i;
    }
    return sum; // 加上return
}

6.3 坑 3：调用方法时参数个数不匹配

  • 错误示例：

    java 复制代码 
    public static int add(int a, int b) {
    return a + b;
}
// 调用时只传1个参数
int result = add(10);

  • 后果：编译报错！提示 "方法 add (int,int) 未定义参数类型为 (int) 的版本"；

  • 正确示例：

    java 复制代码 
    int result = add(10, 20); // 参数个数一致

6.4 坑 4：调用方法时参数类型不匹配

  • 错误示例：

    java 复制代码 
    public static int add(int a, int b) {
    return a + b;
}
// 传字符串类型参数
int result = add("10", 20);

  • 后果：编译报错！提示 "不兼容的类型：String 无法转换为 int"；

  • 正确示例：

    java 复制代码 
    int result = add(10, 20); // 类型一致

6.5 坑 5：方法名写错（调用和定义不一致）

  • 错误示例：

    java 复制代码 
    // 定义方法名：addNum
public static int addNum(int a, int b) {
    return a + b;
}
// 调用时写：addnum（小写）
int result = addnum(10, 20);

  • 后果：编译报错！提示 "无法找到符号 addnum"；

  • 正确示例：

    java 复制代码 
    int result = addNum(10, 20); // 方法名大小写一致

6.6 坑 6：在方法体里定义方法（方法嵌套）

  • 错误示例：

    java 复制代码 
    public static int add(int a, int b) {
    // 在add方法里定义print方法（错误）
    public static void print() {
        System.out.println("求和");
    }
    return a + b;
}

  • 后果：编译报错！提示 "方法内不能定义方法"；

  • 正确示例：

    java 复制代码 
    // 方法平级定义，不能嵌套
public static int add(int a, int b) {
    print(); // 调用其他方法
    return a + b;
}
public static void print() {
    System.out.println("求和");
}

6.7 坑 7：void 方法里 return 后跟值

  • 错误示例：

    java 复制代码 
    public static void printWelcome() {
    return "欢迎"; // void方法不能返回值
}

  • 后果：编译报错！提示 "void 方法不能返回值"；

  • 正确示例：

    java 复制代码 
    public static void printWelcome() {
    System.out.println("欢迎");
    return; // 可选，无值
}

总结

这一节咱们掌握了方法的核心实操技能，记住 3 个核心点：

  1. 方法定义按模板写：修饰符→返回值类型→方法名→参数列表→方法体→return；

  2. 核心规则：返回值类型和 return 值类型必须一致，调用方法时参数个数 / 类型要匹配；

  3. 执行流程：调用方法创建栈帧，执行完销毁栈帧，回到调用处继续执行。

方法的定义与调用是 Java 编程的核心技能，掌握后就能把重复代码封装成 "工具"，让程序结构更清晰、复用性更高。

相关推荐
编程彩机1 天前
互联网大厂Java面试：从Java SE到大数据场景的技术深度解析
java·大数据·spring boot·面试·spark·java se·互联网大厂
编程火箭车2 天前
【Java SE 基础学习打卡】37 二维数组
二维数组·数组遍历·java se·java 基础·二维数组初始化·不规则二维数组·表格型数据存储
梵得儿SHI10 天前
Vue 高级特性：混入（Mixin）使用场景与问题、Vue3 组合式 API 替代方案精讲
前端·javascript·vue.js·组合式api·参数传递·mixin机制·显式调用
编程火箭车12 天前
【Java SE 基础学习打卡】36 数组的常见操作
冒泡排序·java se·java 基础·线性查找·数组常见操作·数组增删改·数组拷贝
编程火箭车13 天前
【Java SE 基础学习打卡】35 数组元素的访问与遍历
数组索引·java se·java 基础·java 数组·数组元素访问与遍历·普通 for 循环·增强 for 循环
编程火箭车16 天前
【Java SE 基础学习打卡】34 数组的定义与初始化
java se·java 基础·java 数组·数组定义与初始化·静态初始化·动态初始化·length 属性
编程火箭车17 天前
【Java SE 基础学习打卡】33 数组的概述
java se·java 基础·数组概述·数组核心特征·java 数组·批量存储数据·连续内存存储
编程火箭车18 天前
【Java SE 基础学习打卡】32 方法的嵌套调用与递归调用
java se·java 基础·java 方法·方法嵌套调用·方法递归调用·递归终止条件·递归应用场景
编程火箭车19 天前
【Java SE 基础学习打卡】31 方法的返回值与void关键字
java se·java 基础·return 语句·编程小白入门·java 方法·方法返回值·void 关键字
热门推荐
01GitHub 镜像站点02Vue-skills的中文文档03一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示04Claude Code Skills 实用使用手册05Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services06让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南07UV安装并设置国内源08Linux下V2Ray安装配置指南09在Trae中使用Pencil MCP10OpenClaw部署与配置教程：在Mac mini上接入国产大模型与飞书