[转]Java方法参数是引用调用还是值调用?

原文：http://hxraid.iteye.com/blog/428856

      方法调用(call by) 是一个标准的计算机科学术语。方法调用根据参数传递的情况又分为值调用( call by reference ) 和引用调用( call by value ) 。江湖上有很多关于这两种调用的定义 ，最通常的说法是传递值的是值调用，传递地址的是引用调用。这其实很不恰当，这种 这些说法很容易让我们联想到Java的对象参数传递是引用调用，实际上，Java的对象参数传递仍然是值调用 。 

      我们首先用一段代码来证实一下为什么Java的对象参数传递 是值调用。

Java代码  

1. public class Employee {  
2.   
3.     public String name=null;  
4.       
5.     public Employee(String n){  
6.         this.name=n;  
7.     }  
8.     //将两个Employee对象交换  
9.     public static void swap(Employee e1,Employee e2){  
10.         Employee temp=e1;  
11.         e1=e2;  
12.         e2=temp;  
13.                 System.out.println(e1.name+" "+e2.name); //打印结果：李四 张三  
14.     }  
15.     //主函数  
16.     public static void main(String[] args) {  
17.         Employee worker=new Employee("张三");  
18.         Employee manager=new Employee("李四");  
19.         swap(worker,manager);  
20.         System.out.println(worker.name+" "+manager.name); //打印结果仍然是： 张三 李四  
21.     }  
22. }  

      上面的结果让人很失望，虽然形参对象e1,e2的内容交换了，但实参对象worker,manager并没有互换内容。这里面最重要的原因就在于形参e1,e2是实参worker,manager的地址拷贝。

      大家都知道，在Java中对象变量名实际上代表的是对象在堆中的地址(专业术语叫做对象引用 )。在Java方法调用的时候，参数传递的是对象的引用。重要的是，形参和实参所占的内存地址并不一样，形参中的内容只是实参中存储的对象引用的一份拷贝。

       如果大家对JVM内存管理中Java栈 的局部变量区 有所了解的话(可以参见《 Java 虚拟机体系结构 》)，就很好理解上面这句话。在JVM运行上面的程序时，运行main方法和swap方法，会在Java栈中先后push两个叫做栈帧的内存空间。main栈帧中有一块叫局部变量区的内存用来存储实参对象worker和manager的引用。而swap栈帧中的局部变量区则存储了形参对象e1和e2的引用。虽然e1和e2的引用值分别与worker和manager相同，但是它们占用了不同的内存空间。当e1和e2的引用发生交换时，下面的图很清晰的看出完全不会影响worker和manager的引用值。

             

      Java对象参数传递虽然传递的是地址(引用)，但仍然是值调用。是时候需要给引用调用和值调用一个准确的定义了。

 

      值调用(call by value) ： 在参数传递过程中，形参和实参占用了两个完全不同的内存空间。形参所存储的内容是实参存储内容的一份拷贝。实际上，Java对象的传递就符合这个定义，只不过形参和实参所储存的内容并不是常规意义上的变量值，而是变量的地址。咳，回过头想想：变量的地址不也是一种值吗！

      引用调用(call by reference) ： 在参数传递的过程中，形参和实参完全是同一块内存空间，两者不分彼此。实际上，形参名和实参名只是编程中的不同符号，在程序运行过程中，内存中存储的空间才是最重要的。不同的变量名并不能说明占用的内存存储空间不同。

 

      大体上说，两种调用的根本并不在于传递的是值还是地址(毕竟地址也是一个值)，而是在于形参和实参是否占用同一块内存空间。事实上，C/C++的指针参数传递也是值调用，不信试试下面的C代码吧！

C代码  

1. #include<stdio.h>  
2. void swap(int *a1,int *b1){  
3.     int *t=a1;  
4.     a1=b1;  
5.     b1=t;  
6. }  
7. int main(){  
8.     int x1=100;  
9.     int x2=200;  
10.         int *a=&x1;  
11.     int *b=&x2;  
12.     printf("%d %d\n",*a,*b);  
13.     swap(a,b);  
14.     printf("%d %d\n",*a,*b);  
15.     return 0;  
16. }  

         但C/C++是有引用调用的，这就是C/C++一种叫做引用的变量声明方法： int a; int &ra=a; 其中ra是a的别名，两者在内存中没有区别，占用了同一个内存空间。而通过引用(别名)的参数传递就符合引用调用的特点了。大家可以去试试

void swap(int &a1,int &b1);的运行结果。

 

-----------------------------------------------------------------------------------------------------------------------

public class StackTest {
	public static void main(String[] args){
		List<String> list = new ArrayList<String>();
		 list.add("111");
		 list.add("222");
		 list.add("333");
		 update(list);
		 System.out.println(list);
	}
	
	public static void update(List<String> list){
		List<String> result = new ArrayList<String>();
		 result.add("111");
		 result.add("222");
		 list.remove(0);
		 list = result;
	}
}

 

这里补充一个知识：一个java程序运行过程中，所有方法开辟的对象的内容都保存在唯一的一段内存中，这个内存我们叫“堆”，而每个方法运行时的局部变量和对象的引用全部短暂的保存在JVM为方法创建的独立的栈桢中，每个方法对应一个栈桢，所有栈桢存放在一段内存空间中，我们叫“堆栈”。

我们分析一下过称:
(1)main函数首先在内存堆中开辟了一个ArrayList的对象list，里面存放的是[111,222,333]，这个对象list在堆中有一个地址，不妨假设是0x1111。
(2)然后要注意了：main函数调用update函数传递的是对象list的引用，也就是0x1111这样一个值，这个值保存在内存栈空间的update栈桢中。，这个值传给了update的参数list，也就是说在update这个方法的栈桢中也开辟了一个空间，存放的是main传递过来的0x1111这个值。
(3) 在update运行时也会在内存堆中开辟一个ArrayList的对象result，里面存放的是[111,222]，这个对象的地址我们假设为Ox2222。这个值也是存放在update的栈桢中。
此时要注意了，update栈桢中有两个值，一个是形参list的0x1111，另一个是刚开辟的result的Ox2222。
(4) 当执行list.remove("111")的时候，JVM是将栈桢中0x1111地址所指向的内存堆中的对象[111,222,333]中的一个元素"111"删除。这句执行之后，Ox1111地址中的内容已经少了一个"111"了。
(5) 比较迷惑的是下面的赋值语句:list = result;
    这句话是引用赋值，只是将update栈桢中原本存放Ox1111这个值的位置赋值成了Ox2222。而并没有将Ox2222所指向的内存堆中的[111,222]对象全部覆盖掉Ox1111所指向的内存堆中的[222,333]，注意Ox1111所指向的对象内容已经被第(4)步remove掉了一个。
    更重要的是，main主函数栈桢中的存放Ox1111这个值的位置并没有被赋值掉，所以在main中最后打印的仍然是Ox1111所指向的对象[222,333]

这次方法调用仍然是引用传递，是值传递，而非地址传递。想搞清楚JVM内部的运行情况，建议看《深入JVM》。