Java is value passing. For basic types, the copy of the actual value is passed, and the modification within the method does not affect the external variables; for reference types, the copy of the reference address is passed, and modifying the object content within the method will affect the external object, but the reassignment reference is invalid. For example, modifying the int parameter of the changeValue method does not affect external variables; modifyList modifying the content of the list through reference copy; repointing to the new list in the reassignList does not affect external original reference. In development, try to reassign references within methods to change external objects, but modify the state by calling the object method.

Java is pass by value, not pass by reference.

Although objects in Java are operated by reference, when a method is passed, the reference itself is passed by value. That is to say, the modification of parameters inside the method will not affect the external variable itself.

Passing parameters in basic types and reference types in Java

In Java, variables are divided into basic types (such as int , double ) and reference types (such as objects, arrays):

• Basic type : The actual value is passed.
• Reference type : It is passed a copy of the object reference, not the object itself.

To give a simple example:

 void changeValue(int x) {
    x = 100;
}

int a = 10;
changeValue(a);
System.out.println(a); // Output is still 10

Here the value of a is copied to x , and the method internally changes x , which does not affect a .

Let's look at the reference type:

 void modifyList(List<String> list) {
    list.add("new item");
}

List<String> myList = new ArrayList<>();
modifyList(myList);
System.out.println(myList.size()); // Output 1

Although list is a value passed (the copy of the reference is passed), the two references point to the same object, so the modification will be reflected.

Why is Java not passed in reference?

Some people mistakenly believe that Java is a reference pass because the object's behavior looks like "passing a reference". But in fact, Java is always passed in value, but this "value" may be a numeric value of the basic type or a reference address of the object.

If you try to change the reference itself in the method, the outside will not change:

 void reassignList(List<String> list) {
    list = new ArrayList<>();
    list.add("new list");
}

List<String> myData = new ArrayList<>();
reassignList(myData);
System.out.println(myData.isEmpty()); // Output true, myData or point to the original empty list

This means that you just copied the list reference into the method and pointed to the new object within the method. The original reference myData is not affected.

Things to note in actual development

Understanding Java's argument transfer mechanism can help avoid some common mistakes:

• ? Attempt to reassign a reference object in a method to affect external variables - will not take effect.
• ? If you want the method to modify the object state, you can do it by calling the object's methods (such as setter or add method, etc.).
• ?? Modifying a collection or object attribute will affect all places holding references to the object.

For example, the following situations will take effect:

 class Person {
    String name;
}

void changeName(Person p) {
    p.name = "Tom";
}

Person person = new Person();
changeName(person);
System.out.println(person.name); // Output Tom

Because p.name = "Tom" changes the content of the object, not the reference itself.

Basically that's it. Java's parameter transfer mechanism is not complicated, but it is easily misunderstood. Understanding the difference between value passing and reference passing can help you write clearer and more stable code.

The above is the detailed content of Java pass by value or pass by reference?. For more information, please follow other related articles on the PHP Chinese website!