In-depth study of parameter passing methods in Java: the principles and mechanisms of value passing and reference passing

Explore the parameter passing mechanism in Java: the working principle of value passing and reference passing

Java is an object-oriented programming language based on classes and objects. It has Powerful and flexible parameter passing mechanism. In Java, parameter passing can be divided into two methods: value passing and reference passing. This article will delve into how these two parameter passing mechanisms work and provide specific code examples.

Value passing refers to copying the value of the actual parameter to the formal parameter. The change of the formal parameter to the actual parameter will not affect the actual parameter itself. In Java, all basic data types (such as int, float, boolean, etc.) pass parameters by value.

Let us use a simple example to illustrate the mechanism of value passing:

public class ValuePassingExample {
    public static void main(String[] args) {
        int num = 10;
        System.out.println("Before calling method: " + num);
        
        changeValue(num);
        
        System.out.println("After calling method: " + num);
    }
    
    public static void changeValue(int n) {
        n = 20;
        System.out.println("Inside Method: " + n);
    }
}

In the above code, we define a changeValue method that accepts an integer Parameter n and change its value to 20. In the main method, we create an integer variable num and initialize it to 10. We then called the changeValue method and passed it num as a parameter.

Output result:

Before calling method: 10
Inside Method: 20
After calling method: 10

As you can see, although we changed the value of n to 20 in the changeValue method, when the method is called After finishing, the value of num is still 10. This is because in Java, value passing is achieved by copying the value of the actual parameter to the formal parameter, so any changes to the formal parameter will not affect the actual parameter itself.

Next, we will discuss the mechanism of reference passing. Passing by reference means passing a reference to an object so that the actual parameters and formal parameters point to the same object in memory. In Java, except for basic data types, all other types such as arrays and objects pass parameters by reference.

Let us use an example to illustrate the mechanism of reference passing:

public class ReferencePassingExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println("Before calling method: " + Arrays.toString(arr));
        
        changeValue(arr);
        
        System.out.println("After calling method: " + Arrays.toString(arr));
    }
    
    public static void changeValue(int[] array) {
        array[0] = 10;
        System.out.println("Inside Method: " + Arrays.toString(array));
    }
}

In the above code, we have defined a changeValue method that accepts an array of integers as parameter and change the value of the first element of the array to 10. In the main method, we create an array arr containing three integers and pass it to the changeValue method.

Output result:

Before calling method: [1, 2, 3]
Inside Method: [10, 2, 3]
After calling method: [10, 2, 3]

It can be seen that although we changed the value of the first element of the array in the changeValue method, after the method call ends, arr still points to the same array, and the value of the first element of the array has also been changed. This is because in reference passing, the actual parameters and formal parameters point to the same object, so any changes to the formal parameters will affect the object referenced by the actual parameters.

To summarize, the parameter passing mechanism in Java can be divided into value passing and reference passing. Passing by value works for all basic data types, while passing by reference works for all non-basic data types. In value passing, the value of the actual parameter is copied to the formal parameter, and any changes to the formal parameter will not affect the actual parameter itself; in reference passing, the actual parameter and the formal parameter point to the same object, and any changes to the formal parameter will not affect the actual parameter itself. Changes will affect the object referenced by the actual parameter.

By deeply understanding the working principles of these two parameter passing mechanisms, we can better understand method calls and object operations in Java and use them correctly in programming.

The above is the detailed content of In-depth study of parameter passing methods in Java: the principles and mechanisms of value passing and reference passing. For more information, please follow other related articles on the PHP Chinese website!