Java中值传递（pass-by-value）与引用传递详解

实际参数是如何传递到java方法的

　　（HOW ARGUMENTS ARE PASSED TO JAVA METHODS）

　　Suppose you're doing some Java programming, and you have a simple program like this:

　　假如你正在编写java程序，然后你写了以下一个程序：

　1　public　class　CallDemo1　{
　2　　　　　　　　　static　void　f(int　arg1)　{
　3　　　　　　　　　　　　　arg1　=　10;
　4　　　　　　　　　}
　5　　　　　
　6　　　　　　　　　public　static　void　main(String　args[])　{
　7　　　　　　　　　　　　　int　arg1;
　8　　　　　
　9　　　　　　　　　　　　　arg1　=　5;
10　　　　　
11　　　　　　　　　　　　　f(arg1);
12　　　　　
13　　　　　　　　　　　　　System.out.println("arg1　=　"　+　arg1);
14　　　　　　　　　}
15　　　　　}
16　

　　In the main method, the variable arg1 is given the value 5, and then passed as an argument to the method f. This method declares a parameter of the same name, arg1, used to access the argument.

　　在main方法中，变量arg1赋值5，然后作为实际参数传递到方法f。这个方法声明一个相同名字的形式参数arg1，被用于访问实际参数。

　　What happens when you run this simple program? The method f modifies the value of arg1, so what value gets printed, 5 or 10? It turns out that 5 is the right answer. This implies that setting arg1 to 10 in method f has no effect outside of the method.

　　当你执行这个程序会发生什么事情呢？方法f修改了arg1的值，所以会打印什么呢，5还是10？这里5是正确的答案。这就意味着在方法f中，将arg1设为10并不影响到方法的外部。

　　Why does it work this way? The answer has to do with the distinction between the pass-by-value and pass-by-reference approaches to passing arguments to a method. The Java language uses pass-by-value exclusively. Before explaining what this means, let's look at an example of pass-by-reference, using C++ code:

　　为什么呢？答案在于区分使用“值传递”方式和“引用传递”方式给方法传递参数。Java语言使用与众不同的“值传递”方式。在解释它的意思之前，让我们看看以下一个值传递的例子，这是用C++写的。

　1　#include　<iostream>
　2　　　　　
　3　　　　　using　namespace　std;
　4　　　　　
　5　　　　　void　f(int　arg1,　int&　arg2)
　6　　　　　{
　7　　　　　　　　　arg1　=　10;
　8　　　　　　　　　arg2　=　10;
　9　　　　　}
10　　　　　
11　　　　　int　main()
12　　　　　{
13　　　　　　　　　int　arg1,　arg2;
14　　　　　
15　　　　　　　　　arg1　=　5;
16　　　　　　　　　arg2　=　5;
17　　　　　
18　　　　　　　　　f(arg1,　arg2);
19　　　　　
20　　　　　　　　　cout　<<　"arg1　=　"　<<　arg1　<<　"　arg2　=　"<<　arg2　<<　endl;
22　　　　　}
23　

　　Function f has two parameters. The first parameter is a pass-by-value parameter, the second a pass-by-reference one. When you run this program, the first assignment in function f has no effect in the caller (the main function). But the second assignment does, in fact, change the value of arg2 in main. The & in int& says that arg2 is a pass-by-reference parameter. This particular example has no equivalent in Java programming.

　　函数f有两个形参。第一个是值传递，第二个是引用传递。当你运行这个程序的时候，第一个参数赋值不影响调用者（main函数）。但是第二个参数赋值却会，事实上，修改了main中arg2的值。在int&中的&表示arg2是一个引用传递的形参。这个特别的例子与java有所不同。

　　So what does pass-by-value actually mean? To answer this, it's instructive to look at some JVM¹ bytecodes that result from the following two commands:

　　那值传递到底是什么意思?要回答这个问题，有需要看一下运行以下两行命令后的JVM的字节码：

　　　 javac CallDemo1.java

　　　 javap -c -classpath . CallDemo1

Here is an excerpt from the output:

　　这里是输出的片段：

Method　void　f(int)

　　　　　　　　0　bipush　10

　　　　　　　　2　istore_0

　　　　　　　　3　return

　　　　Method　void　main(java.lang.String[])

　　　　　　　　0　iconst_5

　　　　　　　　1　istore_1

　　　　　　　　2　iload_1

　　　　　　　　3　invokestatic　#2　<Method　void　f(int)>

　　In the main method, the instruction iconst_5 pushes the value 5 onto the operand stack of the Java virtual machine. This value is then stored in the second local variable (arg1, with args as the first local variable). iload_1 pushes the value of the second local variable onto the operand stack, where it will serve as an argument to the called method.

　　在main方法中，iconst_5指令将值5压入JVM的操作数堆栈（operand stack）。然后这个值随后存储第二个本地变量（arg1的值存在第一个本地变量处）。iload_1指令将第二个本地变量的值再压入操作数堆栈，作为被调用方法的形参。

　　Then the method f is invoked using the invokestatic instruction. The argument value is popped from the stack, and is used to create a stack frame for the called method. This stack frame represents the local variables in f, with the method parameter (arg1) as the first of the local variables.

　　然后方法f通过invokestatic指令调用。形参的值出栈，被用于为被调用的方法创建一个栈框架（stack frame）。这个栈框架表示所有f中的所有本地变量，而arg1实参将作为栈框架内的第一个本地变量。

　　What this means is that the parameters in a method are copies of the argument values passed to the method. If you modify a parameter, it has no effect on the caller. You are simply changing the copy's value in the stack frame that is used to hold local variables. There is no way to "get back" at the arguments in the calling method. So assigning to arg1 in f does not change arg1 in main. Also, the arg1 variables in f and in main are unrelated to each other, except that arg1 in f starts with a copy of the value of arg1 in main. The variables occupy different locations in memory, and the fact that they have the same name is irrelevant.

　　这里的的意思是形式参数作为实际参数的拷贝，被传入方法当中。如果你（在方法体内）修改了一个实际参数，它并不影响调用者，你只是修改了栈框架内的拷贝而已。不可能在调用方法中“取回”实参的值。因此在f中给arg1赋值不会改变main中的arg1，而且这两个arg1毫无关联，除了main中的arg1是f中的arg1的一个拷贝之外。这两个变量存在内存的不同区域，事实上虽然它们有同样的名字，但是毫不相干。

　　By contrast, a pass-by-reference parameter is implemented by passing the memory address of the caller's argument to the called function. The argument address is copied into the parameter. The parameter contains an address that references the argument's memory location so that changes to the parameter actually change the argument value in the caller. In low-level terms, if you have the memory address of a variable, you can change the variable's value at will.

　　对比值传递，引用传递的参数是指传递调用者实参的内存地址给被调用的函数。实参地址拷贝给形参。形参指向了实参的内存区域，所以对形参的修改同样会修改到实参。从底层的角度来说，你可以任意修改变量的值，只要你有该变量的内存地址。

　　The discussion of argument passing is complicated by the fact that the term "reference" in pass-by-reference means something slightly different than the typical use of the term in Java programming. In Java, the term reference is used in the context of object references. When you pass an object reference to a method, you're not using pass-by-reference, but pass-by-value. In particular, a copy is made of the object reference argument value, and changes to the copy (through the parameter) have no effect in the caller. Let's look at a couple of examples to clarify this idea:

　　关于参数传递的讨论会复杂化，这是因为以上引用传递中的术语“引用”与Java编程中使用的（术语）存在微妙的区别。在java中，术语“引用”用于对象所有引用的上下文。当你给方法传递一个对象引用，你并不是使用引用传递，更像是值传递。尤其是，这样会拷贝一份实际参数的对象引用，（通过形参）对该拷贝的修改不会影响到调用者。让我们用以下两个例子来证明这个观点。

　1　class　A　{
　2　
　3　　　　　　　　　public　int　x;
　4　
　5　　　　　　　　　A(int　x)　{
　6　　　　　　　　　　　　　this.x　=　x;
　7　　　　　　　　　}
　8　
　9　　　　　　　　　public　String　toString()　{
10　　　　　　　　　　　　　return　Integer.toString(x);
11　　　　　　　　　}
12　
13　　　　　}
14　
15　　　　　public　class　CallDemo2　{
16　
17　　　　　　　　　static　void　f(A　arg1)　{
18　　　　　　　　　　　　　arg1　=　null;
19　　　　　　　　　}
20　
21　　　　　　　　　public　static　void　main(String　args[])　{
22　　　　　　　　　　　　　A　arg1　=　new　A(5);
23　　　　　　　　　　　　　f(arg1);
24　　　　　　　　　　　　　System.out.println("arg1　=　"　+　arg1);
25　　　　　　　　　}
26　
27　　　　　}

　　In this example, a reference to an A object is passed to f. Setting arg1 to null in f has no effect on the caller, just as in the previous example. The value 5 gets printed. The caller passes a copy of the object reference value (arg1), not the memory address of arg1. So the called method cannot get back at arg1 and change it.

　　在这个例子中，A的引用传递给f。把arg1设置为null不影响调用者，就像前一个例子一样。程序会打印5。调用者传递一份对象引用（arg1）的拷贝，而不是arg1的内存地址。所以调用方法无法取回到（调用者的）arg1变量并修改它。

　　Here's another example:

　1　class　A　{
　2　
　3　　　　　　　　　public　int　x;
　4　
　5　　　　　　　　　public　A(int　x)　{
　6　　　　　　　　　　　　　this.x　=　x;
　7　　　　　　　　　}
　8　
　9　　　　　　　　　public　String　toString()　{
10　　　　　　　　　　　　　return　Integer.toString(x);
11　　　　　　　　　}
12　
13　　　　　}
14　
15　　　　
16　
17　　　　　public　class　CallDemo3　{
18　
19　　　　　　　　　static　void　f(A　arg1)　{
20　　　　　　　　　　　　　arg1.x　=　10;
21　　　　　　　　　}
22　
23　　　　　　　　　public　static　void　main(String　args[])　{
24　　　　　　　　　　　　　A　arg1　=　new　A(5);
25　　　　　　　　　　　　　f(arg1);
26　　　　　　　　　　　　　System.out.println("arg1　=　"　+　arg1);
27　　　　　　　　　}
28　
29　　　　　}

　　What gets printed here is 10. How can that be? You've already seen that there's no way to change the caller's version of arg1 in the called method. But this code shows that the object referenced by arg1 can be changed. Here, the calling method and the called method have an object in common, and both methods can change the object. In this example, the object reference (arg1) is passed by value. Then a copy of it is made into the stack frame for f. But both the original and the copy are object references, and they point to a common object in memory that can be modified.

　　这个例子会打印10。为什么呢?通过之前那个例子，你已经知道无法改变在调用方法中修改（实参）arg1。但是这里的代码显示arg1能够被修改。这里调用方法和被调用方法有个共同的对象，两个方法都能修改这个对象。在这个例子中，对象的引用（arg1）是值传递。他的一个拷贝被加入到f的栈框架。但是原来的和拷贝的对象都是对象引用，它们指向相同的内存区域中的对象，因此可以修改。

　　In Java programming, it's common to say things like "a String object is passed to method f" or "an array is passed to method g." Technically speaking, objects and arrays are not passed. Instead, references or addresses to them are passed. For example, if you have a Java object containing 25 integer fields, and each field is 4 bytes, then the object is approximately 100 bytes long. But when you pass this object as an argument to a method, there is no actual copy of 100 bytes. Instead, a pointer, reference, or address of the object is passed. The same object is referenced in the caller and the called method. By contrast, in a language like C++, it's possible to pass either an actual object or a pointer to the object.

　　在java编程中，经常可以听到“一个String对象被传递到方法f”或者“一个数组被传到方法g”。从技术上来说，不是传递一些对象或数组，而是传递引用或地址。例如，如果你有一个java对象包含25个整型的属性，每个属性占4 字节，那这个对象大约是占100字节。但是作为形式参数传递的时候，不会拷贝100 字节。而是传递一个指针、引用或地址。这样调用者和被调用的方法都指向同一个对象。对比而言，与C++类似的语言，它可以传递真实的对象，也可以传递该对象的指针。

　　What are the implications of pass-by-value? One is that when you pass objects or arrays, the calling method and the called method share the objects, and both can change the object. So you might want to employ defensive copying techniques, as described in the September 4, 2001 Tech Tip, "Making Defensive Copies of Objects"

　　那什么是隐含的值传递呢？其一是当你传递对象或数组，由调用方法和被调用方法共享，双方都可修改对象。因此你可能想请入保护性拷贝技术，就像2001年9月4 日技术贴士“使用保护性拷贝技术。”

　　You can fix the case above, where the called method modifies an object, by making the class immutable. An immutable class is one whose instances cannot be modified. Here's how you to do this:

　　你可以修正以上的例子，当被调用方法修改一个对象时，让这个类成为不可变的。一个不可变类是指其实例不可修改的类。这里教你怎样去定义它。

　1　final　class　A　{
　2　
　3　　　　　　　　　private　final　int　x;
　4　
　5　　　　　　　　　public　A(int　x)　{
　6　　　　　　　　　　　　　this.x　=　x;
　7　　　　　　　　　}
　8　
　9　　　　　　　　　public　String　toString()　{
10　　　　　　　　　　　　　return　Integer.toString(x);
11　　　　　　　　　}
12　　　　　}
13　
14　　　　
15　
16　　　　　public　class　CallDemo4　{
17　
18　　　　　　　　　static　void　f(A　arg1)　{
19　　　　　　　　　　　　　//arg1.x　=　10;
20　　　　　　　　　}
21　
22　　　　　　　　　public　static　void　main(String　args[])　{
23　　　　　　　　　　　　　A　arg1　=　new　A(5);
24　　　　　　　　　　　　　f(arg1);
25　　　　　　　　　　　　　System.out.println("arg1　=　"　+　arg1);
26　
27　　　　　　　　　}
28　
29　　　　　}

　　The printed result is 5. Now uncomment the modification of A in f and recompile the program. Notice that it results in a compile error. You have made A immutable, so it can't be legally modified by f.

　　打印结果是5，现在去掉CallDemo4中f方法内的注释和重新编译。注意它会编译出错。因为你已经让A不可变了，所以f不能合法修改它。

　　Another implication of pass-by-value is that you can't use method parameters to return multiple values from a method, unless you pass in a mutable object reference or array, and let the method modify the object. There are other ways of returning multiple values, such as returning an array from the method, or creating a specialized class and returning an instance of it.

　　另一个隐含的值传递是你不能利用方法的形参在一个方法中返回多个值，除非你传入一个不可变对象引用或数组，然后让方法修改该对象。还有另外的方式返回多个值，例如从方法中返回一个数组，或者创建一个特别定义的类的实例。

　　For more information about how arguments are passed to Java Methods, see Section 1.8.1, Invoking a Method, and section 2.6.4, Parameter Values, in "The Java Programming Language Third Edition" by Arnold, Gosling, and Holmes. Also see item 13, Favor immutability, and item 24, Make defensive copies when needed, in "Effective Java Programming Language Guide" by Joshua

　　想知道更多关于Java方法中的实际参数的传递的信息，请看Arnold, Gosling, and Holmes的《The Java Programming Language Third Edition》中的1.8.1节“Invoking a Method”和2.6.4节“Parameter Values”。还有Joshua的《Effective Java Programming Language Guide》条款13 “Favor immutability”和24 “Make defensive copies when needed”。

　　术语对照翻译

英文	中文
Argument	实际参数（实参）
Parameter	形式参数（形参）
Method	方法
Function	函数
pass-by-value	值传递
pass-by-reference	引用传递
operand stack	操作数堆栈
Stack frame	栈框架
Caller	调用者

　　程序员的一生其实可短暂了，这电脑一开一关，一天过去了，嚎；电脑一开不关，那就成服务器了，嚎……