Detailed explanation of the difference between passing by value and passing by reference in Java and their impact

Passing by value and passing by reference in Java are important concepts that every Java programmer must understand. This article will explain the difference between the two in detail and provide relevant code examples to help readers better understand this concept.

In Java, all parameter passing is achieved by value passing. That is, when we pass a variable as a parameter to a method, what is actually passed to the method is a copy of the value of the variable. Therefore, whether it is a primitive type or a reference type, what is passed is a copy of their value, not the actual variable itself.

First, let’s look at an example of value passing. Suppose we have a simple method swap, used to exchange the values ​​​​of two integer variables:

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

public static void main(String[] args) {
    int x = 1;
    int y = 2;
    swap(x, y);
    System.out.println("x = " + x);
    System.out.println("y = " + y);
}

The output result after the above code is executed will be:

x = 1
y = 2

It can be seen that even in The values ​​of a and b are exchanged internally in the swap method, but the values ​​of variables x and y are not changed in the main method. This is because in the swap method, we only exchange the values ​​of x and y by copying them, rather than modifying their values ​​directly.

Next, let’s look at an example of passing by reference. A reference type variable in Java refers to a reference to an object, not the object itself. When we pass a reference type variable as a parameter to a method, what is actually passed to the method is a copy of the reference, that is, a copy of the reference is passed.

Let us look at a code example:

public static void changeName(Student student) {
    student.setName("Alice");
}

public static void main(String[] args) {
    Student s = new Student("Bob");
    System.out.println("Before change: " + s.getName());
    changeName(s);
    System.out.println("After change: " + s.getName());
}

class Student {
    private String name;

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

    public String getName() {
        return name;
    }

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

The output result after the above code is executed will be:

Before change: Bob
After change: Alice

As can be seen, in the changeName method, we pass Modify the properties of the reference type variable student passed in to change the state of the object, so that the state of the original object in the main method is also changed.

To sum up, the difference between value passing and reference passing in Java is whether a copy of the value or a copy of the reference is passed. For basic type variables, a copy of the value is passed, and modifications to the copy in the method will not affect the value of the original variable; while for reference type variables, a copy of the reference is passed, and modifications to the copy in the method will affect the original variable. The state of the object.

In actual programming, understanding the difference between passing by value and passing by reference is very important to avoid unexpected behavior. Therefore, when writing Java programs, we should choose the appropriate way to pass parameters based on their type and requirements.

I hope this article will help readers understand the difference between value passing and reference passing in Java, and can provide some guidance in actual programming.

The above is the detailed content of Detailed explanation of the difference between passing by value and passing by reference in Java and their impact. For more information, please follow other related articles on the PHP Chinese website!