你真的真的理解Java的按引用传递吗？

【转自 http://blog.csdn.net/xiaoxian8023 】

       今天在博客上看到《你真的理解Java的按引用传递吗？》这篇博文，就好奇进去看了一下，结果发现，其实说了半天，并没有特别清楚的解释。尤其是对于传递String类型时的例子时，有点发蒙。

       接触Java也有好几年了，本来以为这些简单自己早就懂了，结果在看到最后一个例子时，直接就把答案给猜错了。

[java] view plain copy

 print?

1. public class Test5{  
2.     public static void main(String[] args) {  
3.         Object o = new Object();  
4.         System.out.println(o);  
5.         change(o);  
6.         System.out.println(o);  
7.     }  
8.     public static void change(Object o){  
9.         o = null;  
10.     }  
11. }  

       上面这个demo的结果是：

[java] view plain copy

 print?

1. java.lang.Object@2a139a55  
2. java.lang.Object@2a139a55  

       而不是

[java] view plain copy

 print?

1. java.lang.Object@2a139a55  
2. null  

       仔细研究了一下，现在终于是弄懂了。原来以前都是自以为懂了。

       先不解析上面这个demo，我们拿下面这个来说明：

[java] view plain copy

 print?

1. public class AAA {  
2.     private String str = "123";  
3.     public static void main(String[] args) {  
4.         AAA aaa = new AAA();  
5.         System.out.println(aaa.str);  
6.         aaa.change(aaa);  
7.         System.out.println(aaa.str);  
8.         System.out.println("-------------------------------");  
9.         AAA bbb = new AAA();  
10.         System.out.println(bbb.str);  
11.         bbb.change2(bbb);  
12.         System.out.println(bbb.str);  
13.     }  
14.     public void change(AAA a) {  
15.         a.str = "abc";  
16.     }  
17.     public void change2(AAA a) {  
18.         a = new AAA();  
19.         a.str = "abc";  
20.     }  
21. }  

       答案是什么呢：

       为什么不一样，按照在书上看到的——“java传递的是引用，也就是对象的地址”，那change方法把源对象的str属性给改了，为什么change2不能改呢？

       第一副图，对应对象aaa，第二副图对应对象bbb。

       第一副：首先new了一个对象aaa，里面有一个str，指向字符串“123”的地址。然后调用change(aaa)后，由于java方法传递的是地址值的拷贝，所以参数a对象也是指向了aaa原来的堆空间。然后更改str，把参数a中str的指向了“abc”所在空间，即把aaa的str的地址给换成了“abc”，所以最后在输出的时候就会输出“abc”了。

       第二副：首先new了一个对象bbb，里面有一个str，指向字符串“123”的地址。然后调用change(bbb)后，由于java方法传递的是地址值的拷贝，所以参数a对象也是指向了aaa原来的堆空间。但是，方法里调用了b = new AAA();，这样就把b指向的地址换成了一个新对象的地址，同时里面有一个str，由于也是“123”，所以指向的是同一个“123”所属的地址。然后更改str，只是把参数对象a的str的地址给换成了“abc”（双线粗箭头），但是bbb对象中的str仍然没有变化，所以最后在输出的时候还是输出“123”了。

       所以说在传递对象类型时，就看在方法里参数的地址在修改其他属性前有没有发生改变：

• 如果形参的（引用）地址发生了改变，那对原对象就没有影响；
• 如果形参的（引用）地址未改变，但属性有改变，原对象的属性会有随之改变；
• 如果属性先改变，形参的（引用）地址后改变，那原对象的属性在地址改变前有修改的会随之改变。

       所以我们会经常看到下面的这样的例子：

[java] view plain copy

 print?

1. public static void main(String[] args) {  
2.     BBB bbb = new BBB();  
3.     List<Object> list = new ArrayList<Object>();  
4.     System.out.println(list.size());  
5.     bbb.change(list);  
6.     System.out.println(list.size());  
7. }  
8. public void change(List<Object> list) {  
9.     for (int i = 0; i < 3; i++) {  
10.         list.add("00"+i);  
11.     }  
12. }  

       最后输出list.size=3，因为list的地址没有发生变化，所以方法中对list增删对象，原对象就会有变化。

       所以现在再看传递String的这个方法，是不是就简单多了。因为在方法中参数的地址改变了，所以就不会影响到源对象了。所以还是输出“123”。

[java] view plain copy

 print?

1. public class Test2{  
2.     public static void main(String[] args) {  
3.         String str = "123";  
4.         System.out.println(str);  
5.         change(str);  
6.         System.out.println(str);  
7.     }  
8.     public static void change(String str){  
9.         str = "abc";  
10.     }  
11. }  

       那再回头看看文章里第一个例子是不是就也清楚了。