Java参数传递机制与内存模型深度解析

在Java技术面试中，有一个看似基础却不断刷掉候选人的问题：Java中的参数传递到底是值传递还是引用传递？很多候选人能脱口而出“只有值传递”，但一旦被追问“那为什么修改对象属性会生效”“为什么给引用重新赋值又不生效”，回答就开始含糊。这道题真正的分水岭，不在结论，而在对栈内存与堆内存存储差异的理解深度。

本文将从这个经典问题出发，逐层拆解Java参数传递的底层机制，并通过代码验证每一个关键结论。

一、核心结论：Java只有值传递

先给出明确定论：Java中方法参数的传递方式只有一种——值传递（pass-by-value）。这意味着，无论传入的是基本数据类型还是对象引用，方法收到的永远是调用方变量的一个副本。

区别只在于这个“值”是什么：

• 对于基本数据类型，传递的值就是变量本身的数值副本；
• 对于引用类型，传递的值是对象在堆中的地址，而这个地址本身也是一个值，同样会被复制一份。

理解这句话的关键在于区分两个动作：通过引用修改对象内部状态 与 对引用本身重新赋值。这两件事在内存层面的效果完全不同。

二、内存视角：栈与堆的分工

要彻底理解值传递，必须先看清变量到底存在哪里。

• 栈内存：存放方法调用时产生的局部变量。基本类型的变量，其数值直接存放在栈帧中；引用类型的变量，栈中存放的是一个指向堆的地址。
• 堆内存：存放通过 new 创建的对象实例。对象的字段数据都在堆中。

当一个方法被调用时，实参的值会被复制到被调方法的栈帧中的形参变量里。也就是说，形参是一个独立的局部变量，只是它的初始值与实参相同。

三、代码验证：三种典型场景

下面用一个完整示例，覆盖基本类型、修改对象属性、重新赋值引用三种情况。

public class PassByValueDemo {
    static class User {
        private String name;
        User(String name) { this.name = name; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
    }
    public static void main(String[] args) {
        int num = 5;
        modifyNumber(num);
        System.out.println(num); // 输出 5
        User user = new User("张三");
        modifyAttribute(user);
        System.out.println(user.getName()); // 输出 李四
        reassignReference(user);
        System.out.println(user.getName()); // 仍输出 李四
    }
    static void modifyNumber(int n) {
        n = 10; // 修改的是栈中副本
    }
    static void modifyAttribute(User u) {
        u.setName("李四"); // 通过地址找到堆中对象，改其属性
    }
    static void reassignReference(User u) {
        u = new User("王五"); // 只改变了局部引用的指向
    }
}

场景一：基本类型——副本互不影响

调用 modifyNumber(num) 时，num 的值 5 被复制给形参 n。方法内 n = 10 修改的是被调方法栈帧中的副本，与 main 栈帧中的 num 完全无关。因此输出仍为 5。

场景二：通过引用修改对象属性——命中同一堆对象

调用 modifyAttribute(user) 时，user 中保存的地址被复制给形参 u。此时 user 和 u 是两个不同的栈变量，但它们保存的地址相同，都指向堆中同一个 User 对象。因此 u.setName("李四") 修改的是该对象在堆中的字段，方法返回后 user.getName() 自然读到“李四”。

场景三：重新赋值引用——切断副本的指向

调用 reassignReference(user) 时，形参 u 同样是地址副本。u = new User("王五") 只是让 u 这个局部变量重新指向了一个新对象，实参 user 中保存的地址并未改变，仍指向原来的“李四”对象。因此输出依旧是“李四”。

四、为什么 String 表现得更“特殊”

String 是不可变类（immutable）。任何看似“修改”String 的操作，例如拼接、替换，实际上都会在字符串常量池或堆中创建一个新的 String 对象，并把这个新对象的地址赋给相应变量。

static void changeString(String s) {
    s = s + " world"; // 生成了新对象，赋给局部变量 s
}
public static void main(String[] args) {
    String str = "hello";
    changeString(str);
    System.out.println(str); // 输出 hello
}

这里依然遵循值传递规则：形参 s 得到的是原字符串地址的副本，s + " world" 产生新对象后只改变了副本的指向，原变量 str 不受影响。理解这一点，就不会再对“为什么String传进去改了没效果”感到困惑。

五、为什么说这是资深面试题

这道题的价值不在于记忆结论，而在于考察候选人能否清晰区分以下边界：

1. 变量本身与变量所指向的对象是两个层级的概念；
2. 方法的形参是独立局部变量，其生命周期仅限于方法栈帧；
3. 修改对象内部状态与改变引用指向是两种不同操作；
4. 引用类型传递的“值”是地址，方式与基本类型在语义上完全一致。

能把这四点讲清楚的人，往往在实际开发中也更少犯“以为方法内重新赋值能影响外部引用”这类隐蔽错误，尤其是在集合处理、对象构建、递归与回调等场景中。

六、实践中的常见建议

• 需要方法返回修改结果时，应通过返回值显式返回，而不是依赖参数被“改掉”；
• 希望在方法内改变调用方引用指向时，可考虑返回新对象并让调用方接收，或使用持有者/容器对象封装引用；
• 避免在方法内对入参引用重新赋值，这会降低代码可读性并容易引发误解；
• 防御性拷贝：当不希望方法修改传入对象的内部状态时，可在方法入口进行拷贝，明确边界。

七、总结

Java 的参数传递机制可以用一句话概括：传递的永远是值的副本，引用类型传的也是地址这个值。基本类型传数值副本，引用类型传地址副本；通过副本可以操作同一个堆对象，但无法改变外部变量自身的指向。

真正拉开水平差距的，不是背下结论，而是能在脑海里画出栈帧与堆对象的对应关系，随时说清“此刻改的是哪个内存区域”。当你能用内存模型解释每一行代码的行为时，这个问题就不再是面试陷阱，而成了展示功底的舞台。