Java 面试高频题：如何正确理解值传递与引用传递

一、问题背景：为什么这道题值得反复讨论

在 Java 工程师的面试过程中，关于“值传递”和“引用传递”的问题出现频率非常高。很多候选人的第一反应是：Java 中既有值传递，也有引用传递，因为方法可以修改对象内容，也可以修改数组元素等内容。但这个回答并不准确，甚至会在后续追问中暴露出概念混乱。

要真正理解这个问题，不能只停留在“能不能修改对象”的现象层面，而要回到语言参数传递机制的本质：方法调用时，实参和形参之间到底发生了什么。

Java 语言规范明确采用值传递机制。也就是说，方法接收到的永远是实参的一个副本，而不是实参本身。这里的关键不是“传的是什么类型”，而是“传的是不是值”。对于基本类型，传递的是数值副本；对于引用类型，传递的是引用地址的副本，而这个地址本身仍然是值。

二、从代码看基本类型的传递行为

下面这段代码展示了基本类型在方法调用中的表现：

public class PassByValueDemo {
    public static void main(String[] args) {
        int num = 5;
        changeNumber(num);
        System.out.println(num); // 输出 5
    }
    public static void changeNumber(int n) {
        n = 10;
    }
}

在 main 方法中，变量 num 的值是 5。当调用 changeNumber(num) 时，会先将 num 的值复制一份，传递给形参 n。此时内存中存在两个独立变量：main 中的 num 和方法栈帧中的 n。方法内部将 n 改为 10，只影响 changeNumber 内部的局部变量，不会影响 main 中的 num。

这个例子是值传递最直观的体现。基本类型变量保存的就是实际数值，因此方法无法通过形参修改外部基本类型变量。

三、引用类型为什么会造成“引用传递”的假象

再看引用类型的场景。很多候选人认为，方法可以修改对象内容，所以 Java 支持引用传递。这种看法来源于对“引用”一词的误读。

定义如下类：

class User {
    private String name;
    public User(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

然后执行：

public class PassByValueDemo {
    public static void main(String[] args) {
        User user = new User("张三");
        changeName(user);
        System.out.println(user.getName()); // 输出 李四
    }
    public static void changeName(User u) {
        u.setName("李四");
    }
}

这里 user 变量保存的不是对象本身，而是对象在堆内存中的地址。调用 changeName(user) 时，会将这个地址值复制一份传给形参 u。于是，user 和 u 都指向同一个 User 对象。

方法内部通过 u.setName("李四") 修改对象属性时，实际上是通过地址找到堆中的对象，再修改对象内部字段。由于 main 中的 user 也指向同一个对象，因此外部能看到变化。

这就是“引用传递假象”的来源。但要注意，不是引用传递，而是值传递。传过去的引用地址仍然是一个值，是被复制过的。

四、重新赋值引用与方法内对象修改的本质区别

最容易混淆的地方，是方法内部对引用形参重新赋值的情况：

public class PassByValueDemo {
    public static void main(String[] args) {
        User user = new User("张三");
        resetReference(user);
        System.out.println(user.getName()); // 输出 张三
    }
    public static void resetReference(User u) {
        u = new User("王五");
    }
}

有人会误以为方法内创建新对象后，外部的 user 也会指向新对象。但实际输出仍然是“张三”。原因在于，u 只是接收了 user 地址的一个副本。当执行 u = new User("王五") 时，只是让局部变量 u 保存了新的地址，而 main 中的 user 仍然保存原来的地址。

将两个场景放在一起比较会更清晰：

public class PassByValueDemo {
    public static void main(String[] args) {
        User user = new User("张三");
        modifyObject(user);
        System.out.println(user.getName()); // 输出 李四
        replaceReference(user);
        System.out.println(user.getName()); // 输出 李四
    }
    public static void modifyObject(User u) {
        u.setName("李四");
    }
    public static void replaceReference(User u) {
        u = new User("王五");
    }
}

modifyObject 修改的是地址指向的对象内部状态，因此外部可见；replaceReference 改变的是方法内局部变量保存的地址，因此外部不可见。

这两件事的核心区别可以概括为：

• 通过引用操作对象：改变的是对象本身，外部引用可以看到结果。
• 对引用本身赋值：改变的是局部变量保存的地址，不会影响外部变量。

五、数组、集合与自定义类型的同类问题

这一结论不仅适用于自定义对象，也适用于数组和集合。例如：

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        changeElement(arr);
        System.out.println(arr[0]); // 输出 99
        createNewArray(arr);
        System.out.println(arr[0]); // 仍然输出 99
    }
    public static void changeElement(int[] a) {
        a[0] = 99;
    }
    public static void createNewArray(int[] a) {
        a = new int[]{7, 8, 9};
    }
}

数组变量同样保存地址值。changeElement 通过地址修改元素，外部可见；createNewArray 重新赋值局部变量，外部不可见。集合类型的行为也完全一致。

理解这一点后，可以推导出 Java 中一个更普遍的规则：

方法参数传递的本质是副本传递。对于基本类型，副本是数据本身；对于引用类型，副本是地址值。无论哪种情况，方法都无法改变调用方变量本身的值。

六、面试中如何组织高质量回答

如果面试中被问到“Java 是值传递还是引用传递”，建议按以下逻辑回答：

1. 直接给出结论：Java 只有值传递。
2. 解释基本类型：传入的是值的副本，方法内修改不影响外部变量。
3. 解释引用类型：传入的是地址值的副本，因此方法可以通过地址修改对象内容，但无法改变外部引用指向。
4. 区分两种操作：修改对象属性与重新赋值引用形参。
5. 可以用简短代码或内存模型口头说明，展示对底层机制的理解。

例如可以这样回答：

Java 中只有值传递。基本类型传递的是数值副本，引用类型传递的是对象地址的副本。由于地址副本和原引用指向同一对象，所以方法内可以修改对象内容，但如果在方法内重新给引用赋值，只会改变局部变量的指向，不会影响外部引用。

这样回答既准确又完整，能够体现出候选人对语言机制的理解，而不是停留在表面现象。

七、常见误区与延伸思考

一些候选人会把“能修改对象内容”作为引用传递的依据，这是最常见的误区。实际上，引用传递的定义是：方法接收的是实参本身，对形参的修改会直接影响实参变量。Java 显然不满足这一点。

另一个误区是认为字符串类型特殊。例如：

public class StringDemo {
    public static void main(String[] args) {
        String text = "hello";
        changeText(text);
        System.out.println(text); // 输出 hello
    }
    public static void changeText(String s) {
        s = "world";
    }
}

String 是不可变对象，但其传递方式与其他引用类型没有区别。方法内 s = "world" 改变的是局部变量地址，因此外部不变。

还可以进一步思考：如果需要在方法内“替换”外部引用，可以使用返回值、数组包装、容器对象等间接方式。但那是程序设计手段，与参数传递机制无关。

理解值传递与引用传递，不仅有助于通过面试，也能帮助开发者在实际项目中更准确地预判方法行为，减少因对象状态变化导致的问题。对底层机制掌握得越清楚，越容易在复杂业务中做出正确设计。