【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 编程的核心技能，掌握后就能把重复代码封装成 "工具"，让程序结构更清晰、复用性更高。

相关推荐
编程火箭车13 天前
【Java SE 基础学习打卡】27 方法的概述
编程语法·java se·代码复用·编程小白入门·方法概述·功能模块化·java 方法
编程火箭车1 个月前
【Java SE 基础学习打卡】24 循环结构 - while
java·编程基础·循环结构·while循环·java se·do-while循环·避免死循环
编程火箭车1 个月前
【Java SE 基础学习打卡】23 分支语句 - switch
编程语法·java se·switch 语句·新手避坑·java 分支结构·编程小白入门·等值判断
编程火箭车1 个月前
【Java SE 基础学习打卡】22 分支结构 - if
java·流程控制·编程基础·if语句·分支结构·条件判断·新手避坑
BillKu4 个月前
Java核心概念详解：JVM、JRE、JDK、Java SE、Java EE (Jakarta EE)
java·jvm·jdk·java ee·jre·java se·jakarta ee
零叹7 个月前
篇章九 论坛系统——业务开发——主页结构 AND 个人中心
返回值·主页结构·个人中心·登录拦截器
一条叫做nemo的鱼7 个月前
从汇编的角度揭开C++ this指针的神秘面纱(下)
java·汇编·c++·函数调用·参数传递
叶 落7 个月前
[Java 基础]正则表达式
java·正则表达式·java 基础
热门推荐
01GitHub 镜像站点02Linux下V2Ray安装配置指南03Labelme从安装到标注：零基础完整指南04Claude Code Skills 实用使用手册05AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南06网站改了域名，如何查找？07UV安装并设置国内源08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09百度网盘偷偷给电脑“降频”？102025年大语言模型技术全景报告