Java值传递还是引用传递：这个问题面试官为什么总考

适读人群：Java初中级开发者、正在准备面试的后端工程师 | 阅读时长：约11分钟 | 文章类型：概念辨析+代码验证

---

开篇故事

这个题目大概是我面试别人时问得最多的一道题了。不是因为它特别难，而是因为它很能考出候选人是否真的理解了Java的内存模型，还是只是"记住了答案"。

有一次面试，一个工作了三年的候选人。我问他：Java是值传递还是引用传递？

他很自信地说：基本类型是值传递，对象是引用传递。

我接着问：那如果我传一个对象进去，在方法里改了它的字段，外面能看到变化吗？

他说：能，因为是引用传递。

我再问：那如果我在方法里把参数重新赋值为一个新对象，外面能看到这个新对象吗？

他想了一下，说：…也能？因为是引用传递……

我让他写个代码验证一下。他写完跑了，惊了——外面根本看不到新对象。

他陷入沉默，说："我之前理解错了。"

其实理解错的人不在少数。今天把这个问题彻底说清楚。

---

一、结论先说：Java永远是值传递

Java只有值传递，没有引用传递。

但"值"是什么，这里有区别：

• 如果传的是基本类型，传的是值本身（int、long、boolean…）
• 如果传的是对象，传的是对象引用的副本（不是对象本身，也不是引用本身）

后面那种情况，很多人叫它"引用传递"，这是误解的根源。

---

二、核心原理深挖

什么是值传递，什么是引用传递

先把术语定义清楚：

值传递（Pass by Value）： 调用方法时，复制实参的值传给形参。方法内对形参的修改，不影响调用方的实参。

引用传递（Pass by Reference）： 调用方法时，将实参的引用（内存地址）直接传给形参，形参和实参指向同一个位置。方法内对形参的修改（包括重新赋值），直接影响调用方的实参。

C++支持真正的引用传递（void f(int& x)），Java不支持。

对象作为参数的本质

void method(Dog dog) {
    dog.name = "Buddy"; // 修改了引用指向的对象
}

调用method(myDog)时，发生了什么？

• Java把myDog这个引用变量的值（假设是内存地址0x1234）复制了一份
• 把这个副本（也是0x1234）传给了形参dog
• 方法内，dog（值为0x1234）和myDog（值也是0x1234）指向同一个对象
• 所以通过dog修改对象字段，myDog也能看到——因为它们指向同一个对象

但如果你在方法里：

void method(Dog dog) {
    dog = new Dog("New Dog"); // 改变了形参dog的指向
}

• 你只是改变了形参dog这个副本的值（从0x1234改成了0x5678）
• 调用方的myDog仍然是0x1234，没有改变
• myDog还是指向原来的对象

这就是为什么说Java是值传递——传的是引用的副本，不是引用本身。

内存图解

---

三、完整代码实现

代码一：全面验证三种场景

package com.laozhang.trap.passby;

/**
 * Java值传递的完整验证
 * 三种场景：基本类型、对象字段修改、对象引用重赋值
 */
public class PassByValueTest {

    // 测试用的Dog类
    static class Dog {
        String name;
        int age;

        Dog(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Dog{name='" + name + "', age=" + age + "}";
        }
    }

    // ===== 场景1：基本类型 =====
    static void incrementInt(int x) {
        x = x + 1; // 修改的是副本
        System.out.println("  方法内 x = " + x); // 101
    }

    // ===== 场景2：修改对象字段（通过引用副本访问同一对象）=====
    static void renameDog(Dog dog) {
        dog.name = "Buddy"; // 通过引用副本修改了堆上的对象
        System.out.println("  方法内 dog = " + dog);
    }

    // ===== 场景3：重新赋值引用（改变副本的指向）=====
    static void replaceDog(Dog dog) {
        dog = new Dog("New Dog", 1); // 只改变了副本的指向，不影响调用方
        System.out.println("  方法内 dog = " + dog);
    }

    // ===== 场景4：同时修改字段再重赋值 =====
    static void modifyThenReplace(Dog dog) {
        dog.name = "Modified"; // 这一步影响外部
        dog = new Dog("Replaced", 0); // 这一步不影响外部
        dog.name = "After Replace"; // 这一步也不影响外部（dog已是新对象）
        System.out.println("  方法内 dog = " + dog);
    }

    public static void main(String[] args) {
        System.out.println("========== 场景1：基本类型 ==========");
        int num = 100;
        System.out.println("调用前 num = " + num);
        incrementInt(num);
        System.out.println("调用后 num = " + num); // 还是100

        System.out.println("\n========== 场景2：修改对象字段 ==========");
        Dog dog1 = new Dog("Rex", 3);
        System.out.println("调用前 dog1 = " + dog1);
        renameDog(dog1);
        System.out.println("调用后 dog1 = " + dog1); // name变成了Buddy

        System.out.println("\n========== 场景3：重新赋值引用 ==========");
        Dog dog2 = new Dog("Max", 5);
        System.out.println("调用前 dog2 = " + dog2);
        replaceDog(dog2);
        System.out.println("调用后 dog2 = " + dog2); // 还是Max，age=5

        System.out.println("\n========== 场景4：先改字段再重赋值 ==========");
        Dog dog3 = new Dog("Original", 2);
        System.out.println("调用前 dog3 = " + dog3);
        modifyThenReplace(dog3);
        System.out.println("调用后 dog3 = " + dog3); // name是Modified，因为改字段有效；age还是2

        System.out.println("\n========== 场景5：String特殊情况 ==========");
        String str = "Hello";
        System.out.println("调用前 str = " + str);
        modifyString(str);
        System.out.println("调用后 str = " + str); // 还是Hello，String是不可变的
    }

    static void modifyString(String s) {
        s = s + " World"; // 创建了新String对象，副本指向新对象，原来的str不变
        System.out.println("  方法内 s = " + s);
    }
}

代码二：常见误区和实用技巧

package com.laozhang.trap.passby;

/**
 * 基于值传递特性的实用技巧
 */
public class PassByValuePractice {

    // ===== 误区1：以为可以通过方法"返回"多个值 =====

    // 错误理解：以为这样能修改外部的两个变量
    static void swapWrong(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
        // 只改了副本，调用方的a、b没变
    }

    // 正确方式1：返回数组或包装对象
    static int[] swapCorrect(int a, int b) {
        return new int[]{b, a};
    }

    // 正确方式2：用holder对象（不优雅，但有时候有用）
    static class IntHolder {
        int value;
        IntHolder(int v) { this.value = v; }
    }

    static void swapHolder(IntHolder a, IntHolder b) {
        int temp = a.value;
        a.value = b.value;
        b.value = temp;
        // 通过修改Holder对象的字段，可以影响外部
    }

    // ===== 误区2：以为传对象进去modify方法可以替换对象 =====

    static class Builder {
        private String name;
        private int value;

        // 错误：想在方法里构建好再赋给外部变量
        static void buildWrong(Builder builder) {
            builder = new Builder(); // 只改了副本
            builder.name = "built";
        }

        // 正确方式1：让方法返回新对象
        static Builder buildCorrect() {
            Builder b = new Builder();
            b.name = "built";
            return b;
        }

        // 正确方式2：修改传入对象的字段（但不重赋值引用）
        static void populateExisting(Builder builder) {
            builder.name = "built"; // 有效
            builder.value = 42;    // 有效
        }
    }

    // ===== 实践：如何在方法里让调用方拿到"新对象" =====

    // Java里做不到C++的引用传递效果
    // 但可以通过以下方式实现类似目的：

    // 方法1：返回值（最自然）
    static String transform(String input) {
        return input.toUpperCase(); // 返回新字符串
    }

    // 方法2：用容器（数组/List）包装
    static void transformInPlace(String[] container) {
        container[0] = container[0].toUpperCase();
        // 数组是对象，container[0]是数组的字段，可以修改
    }

    // 方法3：回调（Java 8+）
    static void processAndCallback(String input,
                                   java.util.function.Consumer<String> callback) {
        String result = input.toUpperCase();
        callback.accept(result);
    }

    public static void main(String[] args) {
        // swap验证
        System.out.println("=== swap测试 ===");
        int a = 1, b = 2;
        swapWrong(a, b);
        System.out.println("swapWrong后: a=" + a + ", b=" + b); // a=1, b=2，没变

        int[] result = swapCorrect(a, b);
        System.out.println("swapCorrect返回: a=" + result[0] + ", b=" + result[1]); // a=2, b=1

        IntHolder ha = new IntHolder(1), hb = new IntHolder(2);
        swapHolder(ha, hb);
        System.out.println("swapHolder后: a=" + ha.value + ", b=" + hb.value); // a=2, b=1

        // 回调方式
        System.out.println("\n=== 回调获取结果 ===");
        String[] output = new String[1];
        processAndCallback("hello", s -> output[0] = s);
        System.out.println("回调结果: " + output[0]); // HELLO
    }
}

---

四、踩坑实录

坑1：以为方法里重赋值对象引用能影响调用方

报错现象：

没有Exception，但调用方的对象没有被替换成预期的新对象，变量还是指向原来的对象。

触发代码：

User user = userCache.get(userId);
refreshUser(user); // 想刷新user，让外部变量指向新的User对象
System.out.println(user); // 还是老user！

static void refreshUser(User u) {
    u = userService.fetchFromDB(u.getId()); // 只改了副本u
}

具体解法：

// 方案1：让方法返回新对象
user = refreshUser(user);
static User refreshUser(User u) {
    return userService.fetchFromDB(u.getId());
}

// 方案2：原地修改对象字段
static void refreshUser(User u) {
    User fresh = userService.fetchFromDB(u.getId());
    u.setName(fresh.getName()); // 修改字段，影响外部
    u.setEmail(fresh.getEmail());
    // ...
}

坑2：swap方法根本不work

报错现象：

写了个swap方法，调用后两个变量的值根本没有交换。

int x = 10, y = 20;
swap(x, y);
System.out.println(x + " " + y); // 10 20，没有交换

根本原因：

Java基本类型是值传递，swap里交换的是副本，不影响原始变量。

具体解法：

如果一定要交换两个变量的值，直接在调用处操作：

int temp = x;
x = y;
y = temp;

// 或者利用算术（仅限整数，且可能溢出，不推荐）
x = x ^ y;
y = x ^ y;
x = x ^ y;

坑3：String类型以为是可变的

报错现象：

传String进方法，在方法里拼接了字符串，调用方的String没有变化。

String result = "";
appendToResult(result, "part1");
appendToResult(result, "part2");
System.out.println(result); // 还是""

根本原因：

String是不可变对象，任何对String的"修改"（拼接、替换）都会创建新对象。方法里s = s + part只是改变了副本的指向，外部的result不变。

具体解法：

// 方案1：返回新String
result = appendToResult(result, "part1");

// 方案2：用StringBuilder（可变），传进去修改
StringBuilder sb = new StringBuilder();
appendToSB(sb, "part1");
appendToSB(sb, "part2");
String result = sb.toString();

static void appendToSB(StringBuilder sb, String part) {
    sb.append(part); // 修改StringBuilder对象的内容，有效
}

---

五、总结与延伸

"Java是值传递"这个结论，加上对"传的是引用的副本"的理解，可以推导出所有场景的行为：

操作	影响外部？	原因
方法内修改基本类型参数	否	复制了值，改副本
方法内修改对象字段	是	副本和原变量指向同一对象
方法内重新赋值对象引用	否	只改了副本的指向
方法内对String拼接	否	String不可变，拼接产生新对象，改了副本指向
方法内修改数组元素	是	数组是对象，元素是对象的"字段"

面试官为什么总考这道题？因为它不是一个孤立的知识点，而是牵连着对Java内存模型（栈、堆、引用）的理解。理解了这个，很多其他问题（对象共享、并发修改、防御性拷贝）也就顺理成章了。

顺便说一句：如果你在做API设计，要特别注意防御性拷贝。如果你的方法返回一个内部列表，调用方拿到列表引用之后可以修改它，这可能破坏你的内部状态。应该返回一个副本：

public List<String> getItems() {
    return new ArrayList<>(this.items); // 防御性拷贝，不暴露内部引用
}