Is the "Doubts" Java method parameter a reference call or a value call?

Recently to find an internship, in the written test did the following: To find the output of the following code.

public class MyClass {

static void Amethod (StringBuffer sf1,stringbuffer sf2) {
Sf1.append (SF2);
SF2=SF1;
}

public static void Main (string[] args) {
StringBuffer sf1=new stringbuffer ("A");
StringBuffer sf2=new stringbuffer ("B");
Amethod (SF1,SF2);
System.out.println (sf1+ ":" +SF2);
}
}

The output I was thinking of was: Ab:ab. Obviously fell into the trap of the person in the question, the correct answer should be ab:b.

Because long time did not see Java, may have some knowledge point unfamiliar, this question has tested the Java value call.

In the Java programming language, the use of method parameters should be noted in three points:

A method cannot modify a parameter of a base data type (that is, numeric and Boolean)

A method can change the state of an object parameter

A method cannot be implemented so that the object argument references a new object.

To better understand, I read a blogger's blog, the content is as follows:

Reproduced in: http://hxraid.iteye.com/blog/428856

method Invocation (call by) is a standard term for computer science. Method invocations are also divided into value calls (call by reference) and reference calls (call by value) , depending on the arguments passed. There are a lot of definitions of these two calls, the most common is that the value of the transfer value is called, the delivery address is a reference call. This is very inappropriate, this is very easy to let us think that the Java object parameter passing is a reference call, in fact,thejava object parameter pass is still a value call.  

We first use a piece of code to verify why the object parameter passing of Java is a value call.

Java code

2. Public class Employee {
6. Public String name=null;
10. Public Employee (String N) {
12. this.name=n;
14. }
16. //exchange of two employee objects
18. public static void Swap (Employee e1,employee E2) {
20. Employee temp=e1;
22. E1=e2;
24. E2=temp;
26. System.out.println (e1.name+"" +e2.name); //Print Result: Li Shizhang
28. }
30. //Main function
32. public static void Main (string[] args) {
34. Employee worker=New Employee ("Zhang San");
36. Employee manager=New Employee ("John Doe");
38. Swap (Worker,manager);
40. System.out.println (worker.name+"" +manager.name); //Print results are still: Dick and Harry
42. }
44. }

The above results are disappointing, although the parameter object e1,e2 the content exchange, but the argument object Worker,manager is not interchangeable content. The most important reason for this is that the formal parameter e1,e2 is the address copy of the argument Worker,manager.

As you know, in Java, the object variable name actually represents the address of the object in the heap (the jargon is called an object reference ). At the time of the Java method invocation, the argument passes the object's reference. It is important that the memory address of the formal parameter and the argument is not the same, and the content in the formal parameter is only one copy of the object reference stored in the argument.

If you know something about the local variables of the Java stack in the JVM's memory management (see Java Virtual Machine architecture), this is a good thing to understand. When the JVM runs the above program, running the main method and the swap method will successively push two memory spaces called stack frames in the Java stack. The memory in the main stack frame called the local variable area is used to store references to the argument object worker and manager. The local variable area in the swap stack frame stores references to parameter objects E1 and E2. Although the reference values of E1 and E2 are the same as the worker and manager, they take up different memory space. When the E1 and E2 references are exchanged, the following figure is clear that it does not affect the worker and manager reference values at all.

Java Object parameter passing is an address (reference), but is still a value call. It is time to call an exact definition of the invocation and value of the reference.

value Invocation (call by value): during parameter passing, formal parameters and arguments occupy two completely different memory spaces. The content stored by the formal parameter is a copy of the contents of the argument store. In fact, the delivery of a Java object conforms to this definition, except that the contents of the parameters and arguments are not the values of the variables in the general sense, but the addresses of the variables. Well, think back: The address of the variable is not a value!

Reference invocation (call by reference): In the process of parameter passing, the parameters and arguments are exactly the same chunk of memory space, both equals. In fact, formal parameter names and argument names are just different symbols in programming, and in the process of running the program, the space stored in memory is the most important. Different variable names do not indicate that memory storage space is used differently.

In general, the root of the two calls is not whether to pass a value or an address (after all, the address is also a value), but that the parameters and arguments occupy the same piece of memory space. As a matter of fact, the pointer parameter passing is also a value call, do not believe try the following C code it!

C code

2. #include <stdio.h>
4. void swap (int *a1,int *b1) {
6. int *t=a1;
8. A1=B1;
10. b1=t;
12. }
14. int main () {
16. int x1=100;
18. int x2=200;
20. int *a=&x1;
22. int *b=&x2;
24. printf ("%d%d\n", *a,*b);
26. Swap (A, b);
28. printf ("%d%d\n", *a,*b);
30. return 0;
32. }

However, C + + is a reference call, and this is a variable declaration method called a reference: int A; int &ra=a; Where Ra is the alias of a, there is no difference between the two in memory, occupying the same memory space. The argument passed by reference (alias) conforms to the feature of the reference call. We can try it.

void swap (int &a1,int &b1), the running result.

Is the "Doubts" Java method parameter a reference call or a value call?