Is Java "pass-by-reference" or "pass-by-value"?

Is Java “pass-by-reference” or “pass-by-value”?

技术背景

在计算机科学中，“按值传递（pass-by-value）”和“按引用传递（pass-by-reference）”具有精确的定义。这两个术语在不同编程语言中的表现和理解可能会导致混淆。在Java里，关于方法参数是按值传递还是按引用传递，常常是开发者们讨论的话题。

实现步骤

理解按值传递和按引用传递的概念

按值传递：将变量的值复制一份传递给函数或方法。在函数内部对参数的修改不会影响到原始变量。
按引用传递：将变量的引用传递给函数，函数可以通过该引用修改原始变量的内容。

分析Java中的传递方式

Java严格遵循按值传递。对于基本数据类型，传递的是其实际值的副本；对于对象类型，传递的是对象引用的副本。

基本数据类型示例

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

    public static void changeNumber(int n) {
        n = 10;
    }
}

在这个例子中，changeNumber 方法接收的是 num 的值的副本，对副本的修改不会影响到原始的 num 变量。

对象类型示例

class Dog {
    String name;

    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class ObjectPassByValue {
    public static void main(String[] args) {
        Dog aDog = new Dog("Max");
        changeDog(aDog);
        System.out.println(aDog.getName()); // 输出 Max
    }

    public static void changeDog(Dog d) {
        d = new Dog("Fifi");
    }
}

在这个例子中，changeDog 方法接收的是 aDog 引用的副本。在方法内部将副本指向了一个新的 Dog 对象，但原始的 aDog 引用并没有改变。

容易产生混淆的情况

虽然Java是按值传递，但在处理对象时，由于可以通过引用修改对象的属性，可能会让人误以为是按引用传递。

public class ModifyObjectPassByValue {
    public static void main(String[] args) {
        Dog aDog = new Dog("Max");
        modifyDog(aDog);
        System.out.println(aDog.getName()); // 输出 Fifi
    }

    public static void modifyDog(Dog d) {
        d.setName("Fifi");
    }
}

在这个例子中，modifyDog 方法通过引用的副本修改了对象的属性，这看起来像是按引用传递，但实际上传递的还是引用的副本。

核心代码

交换字符串缓冲区的尝试（失败示例）

public class SwapExample {
    public static void swap(StringBuffer s1, StringBuffer s2) {
        StringBuffer temp = s1;
        s1 = s2;
        s2 = temp;
    }

    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer("Hello");
        StringBuffer s2 = new StringBuffer("World");
        swap(s1, s2);
        System.out.println(s1); // 输出 Hello
        System.out.println(s2); // 输出 World
    }
}

在 swap 方法中，交换的是引用的副本，不会影响到原始的引用。

修改字符串缓冲区（成功示例）

public class AppendExample {
    public static void appendWorld(StringBuffer s1) {
        s1.append(" World");
    }

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("Hello");
        appendWorld(s);
        System.out.println(s); // 输出 Hello World
    }
}

在 appendWorld 方法中，通过引用的副本修改了对象的内容。

包装字符串以实现修改

class StringWrapper {
    public String value;

    public StringWrapper(String value) {
        this.value = value;
    }
}

public class StringWrapperExample {
    public static void appendWorld(StringWrapper s) {
        s.value = s.value + " World";
    }

    public static void main(String[] args) {
        StringWrapper s = new StringWrapper("Hello");
        appendWorld(s);
        System.out.println(s.value); // 输出 Hello World
    }
}