← 课程目录 🚀 从零到一
📐 学习维度 阶段1 · 第2章 Java 语法基础 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

2.4 方法与递归:把一件事打包反复用

审校 2026-09-26 · 素材来源:乐字节基础讲义、Java核心总结-cxuan
📑 本篇章节导航 (共9节,点击直达)
方法:有输入有输出的料理机重载:同一个名字,多套入参递归:方法自己喊自己什么时候拆方法方法签名与作用域:方法的身份证可变参数:一次收一筐递归再练一题:走台阶踩坑清单一句话总结

算成绩等级的十行代码,复制到了 8 个地方。后来规则变了,你得改 8 处,漏改一处就出 bug。方法(method)就是解决这个问题的:把一段逻辑打包起名,哪里要用喊一声名字。

方法:有输入有输出的料理机

方法是一台料理机:食材从进料口进(参数),成品从出料口出(返回值)。


//        返回类型 方法名(参数类型 参数名)
public static int add(int a, int b) {
    return a + b;    // return:交出成品,方法结束
}

public static void hello(String name) {  // void = 不产出东西,只干活
    System.out.println("你好, " + name);   // 没有返回值就不用 return
}

调用就是喊名字、喂参数:


int sum = add(3, 5);      // sum = 8
hello("小明");              // 打印:你好, 小明

定义方法时的参数叫形参(占位的形,int a),调用时传的叫实参(实际的实,3)。传参是值拷贝:把 3 复制一份给 a,方法里怎么改 a 都不影响外面的变量——这就是所谓「值传递」。

值传递对引用类型的表现,用一段代码看清:


static void fill(int[] arr)  { arr[0] = 99; }        // 改地址条指向的仓库
static void redirect(int[] a) { a = new int[3]; }    // 换的是复印件上的地址

int[] xs = {1, 2, 3};
fill(xs);     System.out.println(xs[0]);  // 99,仓库被改了
redirect(xs); System.out.println(xs[0]);  // 99,外面的条子没被换

口诀:内容会变、指向不变。传进去的永远是复印件——基本类型复印的是值,引用类型复印的是地址。

重载:同一个名字,多套入参


public static int    add(int a, int b)      { return a + b; }
public static double add(double a, double b) { return a + b; }
public static int    add(int a, int b, int c) { return a + b + c; }

同名不同参(个数或类型不同)叫重载(overload)。调用时 Java 按你传的参数自动挑版本:add(1, 2)、add(1.5, 2.5) 各走各的门。你会天天用:println 本身就重载了十几种参数。

重载的裁决发生在编译期,按参数的静态类型挑门——这叫静态分派。跟它相对的「运行期按实际对象类型挑行为」叫多态,是第 3 章的主角。现在先留个坐标:重载是编译期挑参数,多态是运行期挑对象,面试把这两者混为一谈是重灾区。

判定重载只看参数,不看返回值:int add(int,int) 和 double add(int,int) 不算重载,是重复定义,直接编译报错。

递归:方法自己喊自己

递归(recursion)就是方法调用自己。算阶乘(5! = 5×4×3×2×1):


public static long fact(int n) {
    if (n <= 1) return 1;      // 出口:1的阶乘是1,不再往下喊
    return n * fact(n - 1);    // n! = n × (n-1)!
}

它成立的两个充要条件,缺一必死:

1. 出口(base case):什么时候停,n <= 1 就直接返回

2. 推进:每层往出口靠近一步,n - 1 越喊越小

理解递归靠调用栈(call stack):每次调用摞一层盒子,fact(5) 摞到 fact(1) 触底,再一层层乘着回去:


fact(5) 等 fact(4)
  fact(4) 等 fact(3)
    fact(3) 等 fact(2)
      fact(2) 等 fact(1)
        fact(1) = 1   ← 触底反弹
      2×1=2 → 3×2=6 → 4×6=24 → 5×24=120

没有出口会怎样?盒子无限摞,栈被塞爆,抛 StackOverflowError。写递归先写出口,是铁律。

递归的代价也在这张图里:每层调用都占一格栈。算 fact(5) 无感,算 fact(100000) 直接爆栈。递归换的是代码优雅,付的是栈空间——深层递归改循环是工程里的常见操作,第 7 章讲栈帧时你会再遇到这位老朋友。

递归最出名的实战是斐波那契,也顺带看看「重复计算」这个暗坑:


static long fib(int n) {
    if (n <= 2) return 1;
    return fib(n - 1) + fib(n - 2);  // fib(2) 被反复重算
}

fib(50) 能把电脑算到怀疑人生——同一层的结果没人记住。解法是加个「记事本」把算过的存起来,这个思路叫记忆化,动态规划的敲门砖。现在感受气氛即可,手写题专题(第 29 章)会正式拆。

什么时候拆方法

经验法则:一段代码超过一屏、或出现第二处复制粘贴、或需要注释才能看懂——就拆成方法,起个能读出意图的名字。方法名就是最好的注释。

拆的颗粒度也有讲究:一个方法只做一件事,名字能准确说出这件事。名字起不出来,说明它做的就不止一件事,继续拆。processAndSaveAndNotify 这种名字就是拆分不足的自首。

拆完还有个隐性收益:方法名把段落大意写在了目录上,读代码像翻书;出了 bug,报错栈里的方法名直接指路,改哪一段一眼定位。

方法签名与作用域:方法的身份证

方法名加参数列表合称签名(signature),比如 add(int, int)。编译器就靠签名认人:重载是名字相同、签名不同。以后翻 API 文档满眼都是「方法签名」这个词,现在正式对上号。

作用域规则一并立住:变量只活在包住它的最近一对大括号里。方法里的局部变量,方法一结束就消失;两个方法各有一个叫 x 的局部变量,互不认识,各过各的。参数也一样:它是方法被调用那一刻才出生的局部变量。

顺带补 return 的另一个用途:void 方法里也可以写光杆 return;,意思是「提前收工」。开头校验不通过直接 return,主逻辑就不用裹在 else 里——代码又平了一层。

可变参数:一次收一筐


static int sum(int... nums) {    // 本质是数组
    int total = 0;
    for (int n : nums) total += n;
    return total;
}
sum(1, 2);          // 传几个都行
sum(1, 2, 3, 4);

int... 叫可变参数:调用方想传几个传几个,编译器自动把零散的数打包成数组,方法体内当数组用。System.out.printf 就是靠它吃下任意多个占位参数的。规则两条:只能放在参数表最后;一个方法最多一个。

递归再练一题:走台阶

走 n 阶楼梯,每步跨 1 阶或 2 阶,共有几种走法?盯住最后一步:要么从第 n-1 阶迈上来,要么从第 n-2 阶迈上来。两条路不重叠也不遗漏,所以 f(n) = f(n-1) + f(n-2)——转了一圈又是斐波那契。

递归题的通用钥匙就这一把:盯住最后一步,把它之前的局面当成小一号的原问题。出口也想清楚:剩 1 阶只有 1 种,剩 2 阶有 2 种。这个视角比背十道递归题都值钱,第 29 章手写题专题会反复用它。

踩坑清单

一句话总结

方法是有输入输出的料理机(参数进、return 出、传参永远是值拷贝);递归是方法调用自己,先写出口再推进;复制粘贴第三遍出现时,就该拆方法了。