算成绩等级的十行代码,复制到了 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 变量;,语法错误,return 后面不许带值方法是有输入输出的料理机(参数进、return 出、传参永远是值拷贝);递归是方法调用自己,先写出口再推进;复制粘贴第三遍出现时,就该拆方法了。