Question: When an object is passed as a parameter to a method, the method can change the properties of the object and return the changed result. So, is it passed by value or by reference?
Answer: It is value transfer . In the Java language, only parameters are passed by value ; when an object instance is passed to a method as a parameter, the value of the parameter is a copy of the object reference. Pointing to the same object, the content of the object can be changed in the called method, but the object reference (not a copy of the reference) will never change .
Java parameters: regardless of whether it is a primitive type or a reference type, what is passed is a copy (there is another way of saying that is passing by value, passing by value is generally relative to passing by address)
If the parameter type is a basic data type , then what is passed is a copy of the parameter, that is , the value of the original parameter , which is the same as the value passing mentioned earlier. If the value of the copy is changed in the function, the original value will not be changed
If the parameter type is a reference type , then what is passed is a copy of the reference parameter. This copy stores the address of the parameter . If the address of the copy is not changed in the function, but the value in the address is changed, then in the function Changes within will affect the incoming parameters. If the address of the copy is changed in the function, such as a new one, the copy will point to the new address. At this time, the passed-in parameter still points to the original address, so the original value will not be changed .
Basic data type parameter passing: does not change the value
public static void test(int a){
a=20;
}
public static void main(String[] args) {
int a=10;
test(a);
System.out.println(a);
}
The result is: 10
Variable object parameter passing: change the value
public static void test2(StringBuffer sb){
sb.append("add");
}
public static void main(String[] args) {
int a=10;
StringBuffer sb = new StringBuffer();
sb.append("init:");
test2(sb);
System.out.println(sb);
}
The result is: init: add
The encapsulated object is passed as a parameter, if the attribute value is modified in the method, the value will be changed
Since the object is created before the method is passed, it is the same reference, so the content of the object will be changed
public static void test3(A bean){
bean.setName("李四");
}
public static void main(String[] args) {
A bean = new A();
bean.setName("张三");
test3(bean);
System.out.println(bean.getName());
}
class A {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
The result is: Li Si
The encapsulated object is passed as a parameter, if the object is reassigned in the method, the value will be changed
Since the object in the method is re-created, the reference is different, and the change of the object in the method will not affect the content of the outside object
public static void test4(A bean){
A bean2 = new A();
bean2.setName("李四");
bean = bean2;
bean.setName("王犊子");
}
public static void main(String[] args) {
A bean = new A();
bean.setName("张三");
test4(bean);
System.out.println(bean.getName());
}
class A {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
The result is: Zhang San