方法参数传递

Java 方法参数传递：彻底理解 “值传递” 本质

在 Java 中，方法参数的传递机制一直是初学者容易混淆的问题。尽管经常有人讨论 “值传递” 与 “引用传递” 的区别，但Java 中只有值传递—— 无论传递的是基本数据类型还是引用数据类型，方法接收的都是参数值的一份 “拷贝”。本文将通过实例深入解析这一机制，澄清常见误解。

值传递的核心定义

值传递（Pass-by-Value）是指：方法在被调用时，会创建参数值的一个副本，并将副本传递给方法。方法内部对参数的修改，只会影响这个副本，不会影响原始参数。

与之相对的 “引用传递”（Pass-by-Reference）是指：方法接收的是参数的内存地址，对参数的修改会直接影响原始对象。但Java 并不支持这种传递方式。

基本数据类型的参数传递

基本数据类型（如 int、char、boolean 等）的值传递行为非常直观：方法接收的是原始值的拷贝，修改拷贝不会影响原始值。

示例代码：

public class PrimitivePassing {
    public static void main(String[] args) {
        int num = 10;
        System.out.println("调用前：" + num); // 输出：10
        modify(num);
        System.out.println("调用后：" + num); // 输出：10（原始值未变）
    }

    private static void modify(int value) {
        value = 20; // 修改的是副本，与原始值无关
        System.out.println("方法内：" + value); // 输出：20
    }
}

原理分析：

main 方法中的 num 是原始变量，值为 10；
调用 modify(num) 时，Java 创建 num 的副本（值为 10），并将副本传递给 modify 方法的 value 参数；
modify 方法中修改的是 value（副本），原始变量 num 不受影响。

引用数据类型的参数传递

引用数据类型（如 String、Object、数组、自定义类等）的传递机制容易产生误解。许多人认为这是 “引用传递”，但实际上，传递的是引用地址的拷贝。

示例 1：修改引用指向的对象内容

public class ObjectPassing {
    static class Person {
        String name;
        Person(String name) { this.name = name; }
    }

    public static void main(String[] args) {
        Person p = new Person("张三");
        System.out.println("调用前：" + p.name); // 输出：张三
        modifyName(p);
        System.out.println("调用后：" + p.name); // 输出：李四（内容被修改）
    }

    private static void modifyName(Person person) {
        person.name = "李四"; // 修改的是副本指向的对象内容
    }
}

原理分析：

main 方法中的 p 是引用变量，存储的是 Person 对象的内存地址（如 0x123）；
调用 modifyName(p) 时，Java 创建引用地址的副本（0x123），传递给 modifyName 方法的 person 参数；
person 和 p 指向同一个对象（地址都是 0x123），因此修改 person.name 会影响原始对象。

示例 2：修改引用变量本身（指向新对象）

public class ReferencePassing {
    static class Person {
        String name;
        Person(String name) { this.name = name; }
    }

    public static void main(String[] args) {
        Person p = new Person("张三");
        System.out.println("调用前：" + p.name); // 输出：张三
        reassign(p);
        System.out.println("调用后：" + p.name); // 输出：张三（原始引用未变）
    }

    private static void reassign(Person person) {
        person = new Person("李四"); // 修改副本的指向，与原始引用无关
        System.out.println("方法内：" + person.name); // 输出：李四
    }
}

原理分析：

main 方法中的 p 指向对象 A（地址 0x123）；
modify 方法的 person 参数是 0x123 的副本，最初也指向对象 A；
方法内 person = new Person("李四") 让副本指向新对象 B（地址 0x456），但原始引用 p 仍指向 A，因此原始对象不受影响。

常见误解：为什么引用类型修改会影响原始对象？

这是因为引用类型的 “值” 是对象的内存地址。当副本与原始引用指向同一个对象时，修改对象内容会同时反映在两者上，但这并不意味着是 “引用传递”—— 本质上传递的还是地址的拷贝，只是拷贝与原始值指向了同一个对象。

用一句话总结：

基本类型：传递值的拷贝，修改拷贝不影响原始值；
引用类型：传递地址的拷贝，修改拷贝的指向不影响原始引用，但修改地址指向的对象内容会影响原始对象。

特殊案例：String 类型的 “不可变性”

String 是引用类型，但由于其不可变性（一旦创建就无法修改内容），修改 String 参数的行为看起来与基本类型类似：

public class StringPassing {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println("调用前：" + str); // 输出：hello
        modifyString(str);
        System.out.println("调用后：" + str); // 输出：hello（原始值未变）
    }

    private static void modifyString(String s) {
        s = "world"; // 创建新字符串，副本指向新地址
        System.out.println("方法内：" + s); // 输出：world
    }
}

原理：

String 的 s = "world" 并非修改原有字符串，而是让副本指向新创建的字符串 world，原始引用 str 仍指向 hello，因此原始值不变。这是 String 不可变性导致的特殊表现，并非传递机制不同。

结论：Java 中只有值传递

无论参数是基本类型还是引用类型，Java 始终采用值传递：

基本类型：传递值的拷贝；
引用类型：传递地址的拷贝