图解Java中的值传递与引用传递（更新版）

编程的人，都会遇到值传递与引用传递的困惑，不过很快都会迎刃而解。本文通过图文并茂的形式，解释Java的值传递与引用传递。并且会通过String这个特殊的类，进一步加深您的对值传递与引用传递的印象。

 声明：

为了图解方便，图中的术语不精确、甚至是“自创的”，请不要把图中的概念与JVM或者真正的内存相结合，只是为了说明方便!!

 防止误解。 

 

说明： 

图的标号在图的下方；

栈1表示main方法的栈，栈2表示doSomething的栈；

绿色的栈，表示当前的正在运行的栈；红色的栈，表示挂起的栈；白色的栈，表示废弃的栈。

 

 

一般的解释：

 

Java代码  

1. public class ReferenceCrack {  
2.   
3.     public void doSomething(int a, Name b) {// --> 见图1.2  
4.         a = 100;  
5.         b.setName("World");//--> 见图1.3  
6.     }  
7.   
8.     public static void main(String[] args) {  
9.         int numb = 1;  
10.         Name obj = new Name();  
11.         obj.setName("Hello"); //--> 见图1.1  
12.         new ReferenceCrack().doSomething(numb, obj); // --> 见图1.2  
13.         //-->见图1.4  
14.         System.out.println("numb = " + numb + " ; obj.name = " + obj.getName());  
15.     }  
16.   
17. }  
18.   
19. class Name {  
20.     private String name;  
21.   
22.     public String getName() {  
23.         return name;  
24.     }  
25.   
26.     public void setName(String name) {  
27.         this.name = name;  
28.     }  
29. }  

 

   输出结果：

numb = 1 ; obj.name = World

图1.1  执行到obj.setName("Hello"); //--> 见图1.1时，值栈中的内容

 

 图1.2 public void doSomething(int a, Name b) {// --> 见图1.2 刚刚进入另一个函数

 当调用函数doSomething时，Main函数挂起。

 注意： 此时栈2中的a指向的是另一个值“1”。这就是常说的 值传递！！

 

 图1.3 被调用的函数执行过程中。

 doSomething的方法，改变了一些内容 。

 

 图1.4 函数执行完毕，返回Main函数时，值栈中的内容：

 由于栈1中的obj 和 栈2中的b 指向的是 同一个内容，而该内容被b修改了，所以obj的内容就是修改后的内容。

 因此输出是: numb = 1 ; obj.name = World

 

 

传统的方式，大家看完图后都明白的。让我们更进一步：

 

Java代码  

1. public class ReferenceCrack01 {  
2.   
3.     public void doSomething(int a, String b) {//--> 见图2.2  
4.         a = 100;  
5.         b = b.trim();//--> 见图2.3  
6.     }  
7.   
8.     public static void main(String[] args) {  
9.   
10.         int numb = 1;  
11.         String str = "Hello World     ";//--> 见图2.1  
12.           
13.         new ReferenceCrack01().doSomething(numb, str);//--> 见图2.2  
14.         //--> 见图2.4  
15.         System.out.println(numb);  
16.         System.out.println(str+"|");  
17.     }  
18.   
19. }  

 

 图2.1

 图2-2

 图2-3

 注意：这个图与1-3的图不一样。（下文解释）

 

 图2-4

图2-3的解释：

Java中的String类是Final的，是不允许修改的。因此在对String做任何操作时，要么返回自身（this）要么返回一个新的对象！

 

Java代码  

1. public String trim() {  
2.         int len = count;  
3.         int st = 0;  
4.         int off = offset; /* avoid getfield opcode */  
5.         char[] val = value; /* avoid getfield opcode */  
6.   
7.         while ((st < len) && (val[off + st] <= ' ')) {  
8.             st++;  
9.         }  
10.         while ((st < len) && (val[off + len - 1] <= ' ')) {  
11.             len--;  
12.         }  
13.         return ((st > 0) || (len < count)) ? substring(st, len) : this;  
14.     }  

 

Java代码  

1. public String substring(int beginIndex, int endIndex) {  
2.     if (beginIndex < 0) {  
3.         throw new StringIndexOutOfBoundsException(beginIndex);  
4.     }  
5.     if (endIndex > count) {  
6.         throw new StringIndexOutOfBoundsException(endIndex);  
7.     }  
8.     if (beginIndex > endIndex) {  
9.         throw new StringIndexOutOfBoundsException(endIndex - beginIndex);  
10.     }  
11.     return ((beginIndex == 0) && (endIndex == count)) ? this :  
12.         new String(offset + beginIndex, endIndex - beginIndex, value);  
13.     }  

 

有JDK源码可以清楚地看到，生成了一个新的String。所以在图2-3中，栈2中的b变量的指向发生了变化。