前言

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• 两种核心类型：

注意：

• 返回值类型可以是 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;（表示立即结束方法），后面不能跟任何值。

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

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

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

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

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

  // 例子：求和方法（int类型返回值）publicstaticintadd(intnum1,intnum2){intresult=num1+num2;returnresult;// 必须写，且类型是intSystem.out.println("这行代码永远执行不到");// return后不可达，编译报错}

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

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

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

publicclassMethodDemo1{// 1. 定义无参方法（返回值类型void，参数列表为空）publicstaticvoidprintWelcome(){// 方法体：核心功能（打印欢迎语）System.out.println("======================");System.out.println(" 欢迎学习Java方法！");System.out.println(" 今天学方法的定义与调用～");System.out.println("======================");// void类型，return可选（这里省略）}// 程序入口：main方法（所有代码从这里开始执行）publicstaticvoidmain(String[]args){// 2. 调用无参方法：方法名+()System.out.println("调用方法前...");printWelcome();// 调用printWelcome方法System.out.println("调用方法后...");}}

执行结果：

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

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

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

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

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

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

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

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

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

publicclassMethodDemo2{// 1. 定义带参方法：返回值类型int，参数列表int num1, int num2publicstaticintadd(intnum1,intnum2){// 方法体：求和逻辑intsum=num1+num2;// return返回求和结果（类型和返回值类型int一致）returnsum;}publicstaticvoidmain(String[]args){// 2. 调用带参方法：方法名+(实参1, 实参2)// 方式1：直接传字面量（固定值）intresult1=add(10,20);System.out.println("10+20="+result1);// 输出30// 方式2：传变量（更灵活）inta=30,b=40;intresult2=add(a,b);System.out.println("30+40="+result2);// 输出70// 方式3：嵌套调用（方法返回值作为实参）intresult3=add(result1,result2);System.out.println("30+70="+result3);// 输出100}}

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

publicclassMethodDemo3{// 定义带参方法：参数n表示计算到的数字，返回值是求和结果publicstaticintsumToN(intn){intsum=0;// 方法体里可以用循环（之前学的知识）for(inti=1;i<=n;i++){sum+=i;}returnsum;// 返回求和结果}publicstaticvoidmain(String[]args){// 调用方法，传不同的实参System.out.println("1-10的和："+sumToN(10));// 55System.out.println("1-100的和："+sumToN(100));// 5050}}

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

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

publicclassParamDemo{publicstaticvoidchangeNum(intnum){num=100;// 修改形参的值}publicstaticvoidmain(String[]args){inta=10;changeNum(a);// 传实参a的值（10）给形参numSystem.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 值类型不匹配

• 错误示例：

  publicstaticintadd(inta,intb){doublesum=a+b;returnsum;// 返回值类型是int，却返回double}

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

• 正确示例：

  publicstaticintadd(inta,intb){intsum=a+b;returnsum;// 类型一致}

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

• 错误示例：

  publicstaticintsumToN(intn){intsum=0;for(inti=1;i<=n;i++){sum+=i;}// 漏写return}

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

• 正确示例：

  publicstaticintsumToN(intn){intsum=0;for(inti=1;i<=n;i++){sum+=i;}returnsum;// 加上return}

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

• 错误示例：

  publicstaticintadd(inta,intb){returna+b;}// 调用时只传1个参数intresult=add(10);

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

• 正确示例：

  intresult=add(10,20);// 参数个数一致

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

• 错误示例：

  publicstaticintadd(inta,intb){returna+b;}// 传字符串类型参数intresult=add("10",20);

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

• 正确示例：

  intresult=add(10,20);// 类型一致

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

• 错误示例：

  // 定义方法名：addNumpublicstaticintaddNum(inta,intb){returna+b;}// 调用时写：addnum（小写）intresult=addnum(10,20);

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

• 正确示例：

  intresult=addNum(10,20);// 方法名大小写一致

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

• 错误示例：

  publicstaticintadd(inta,intb){// 在add方法里定义print方法（错误）publicstaticvoidprint(){System.out.println("求和");}returna+b;}

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

• 正确示例：

  // 方法平级定义，不能嵌套publicstaticintadd(inta,intb){print();// 调用其他方法returna+b;}publicstaticvoidprint(){System.out.println("求和");}

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

• 错误示例：

  publicstaticvoidprintWelcome(){return"欢迎";// void方法不能返回值}

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

• 正确示例：

  publicstaticvoidprintWelcome(){System.out.println("欢迎");return;// 可选，无值}

总结

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

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

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

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

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