Java 方法参数：实参、值传递与返回值

参数让方法能够接收输入

一个永远只做同一件事的方法用处有限。参数是你在方法括号里声明的输入，有了它，同一个方法每次调用时都能处理不同的值。

每个参数都要写上类型和名字。在方法体内，参数就像一个普通的局部变量，里面已经存好了调用者传进来的值。

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name 是形参。"Sam" 和 "Alex" 是实参，也就是调用时提供的具体值。一个方法定义，两种不同的输出。

形参与实参

这两个词经常被混着用，但值得把区别弄清楚：

• 形参是声明中的占位符：String name。
• 实参是你实际传入的值："Sam"。

所以 void greet(String name) 声明了一个形参，greet("Sam") 传入了一个实参。有人说“这个方法有两个参数”，指的是声明；说“我传了两个实参”，指的是调用。

多个参数

用逗号分隔多个参数，并给每个参数写上自己的类型。你不能像声明变量那样让两个参数共用一个类型：

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

实参严格按位置对应到形参，而不是按名字。describe("Sam", 30, true) 能正常工作，是因为顺序与 (String name, int age, boolean active) 一致。如果把两个类型兼容的实参调换位置，你得到的是一个不声不响的逻辑 bug，而不是编译错误，所以顺序很重要。

一个常见错误是写成 int add(int a, b)。每个参数都需要自己的类型：int add(int a, int b)。

返回值

参数是数据流入的方式，返回值是结果流出的方式。在方法名前面声明返回类型，再用 return 把值交回给调用者：

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 forces floating-point division
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

返回类型（double）必须与你实际 return 的值相符。声明为 void 的方法什么都不返回：它仍然可以用单独的 return; 提前退出，但不能返回值。return 一执行，方法就结束，控制权回到调用处。

Java 是值传递

几乎每个人一开始都会在这里犯糊涂。传递实参时，Java 会把值复制到形参中。对于基本类型，这意味着方法拿到的是自己的副本，修改形参永远不会影响调用者的变量：

public class Main {
    static void tryToChange(int n) {
        n = 999;   // changes only this local copy
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // still 5
    }
}

x 仍然是 5。方法修改的是它自己的那份数字副本，而不是原来的值。

传递对象：仍然是值传递，但要留意引用

对象看起来像是例外，但其实不是。被复制的是引用（指向对象的那个箭头），而不是对象本身。所以方法指向的是同一个对象，并且可以修改它。这正是为什么在方法里往共享的 ArrayList 添加元素，调用者能看到变化：

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // mutates the shared object - visible to caller
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // reassigns the local copy only - NOT visible
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // still [a, b, new] - reassignment didn't escape
    }
}

两种不同的结果，同一条规则。addItem 顺着引用找到并修改了真正的列表，所以调用者能看到 new 出现。replace 把形参重新赋值为一个全新的列表，但这只是让引用的局部副本指向了别处，调用者的 list 完全没有受到影响。要点是：你可以通过形参修改一个对象，但永远无法让调用者的变量指向一个新的对象。

下一页：方法重载

现在你已经知道如何给方法传入它需要的输入了。但如果你想让同一个方法名接收不同组合的参数呢，比如 print(int) 和 print(String)？这就是方法重载，也是下一页的内容。