1、探究java方法参数传递——引用传递？值传递！

原创博文，转载请注明出处。谢谢~~

---

java程序运行时，其对象是怎么进行放置和安排的呢？内存是怎么分配的呢？理解好这个很有好处！java有5个地方可以存储数据：

1、寄存器。这是最快的存储区，位于处理器内部。java程序员无法感知到它的存在，所以不用深究。

2、堆栈。位于内存中，通过堆栈指针可以获得直接的内存分配。对象引用和基本数据（int,boolean等）存放于堆栈中。注意：是对象的引用，对象数据本身却是存放在堆中的。于对象而言，在堆中存放的只是对象数据的一个地址（类似于C语言的指针），通过它可以访问到对象本身的属性和方法。

3、堆。同样位于内存中，用于存放所有的java对象。需要一个对象的时候，只需要用new写一行简单的代码，当执行这行代码的时候，会直接在堆中进行空间分配。

4、常量存储。常量值直接存放在代码内部，保证安全。

5、非RAM存储。比如，流对象和持久化对象，可以存放在磁盘文件中。

先来看一看下面这个对象是如何存放的

String s = new String("hello");

下图表示了其存储状态：

new String("hello") 语句中用关键字 new 定义了一个String的对象，并为其在 “堆内存” 中分配了合适的存储空间。

s 是一个String型对象的引用，实际上就是堆内存中一个String型对象的地址。引用 s 保存在 “堆栈” 中。

清楚了对象和其引用的存储方式以后，我们再来看看方法的参数传递是怎么一回事情。看看下面语句：

List-1：

 public static void main(String[] args) {

     Func f = new Func();

     A a1 = new A();
     f.modify(a1);
 }

语句很简单，在main方法中首先定义了一个Func对象f和A对象a1，然后将a1作为参数传递给f的modify方法中。程序在第6行的时候会从main方法跳转到f.modify(...)方法内部执行。下图展示了数据的保存状态：

可以清楚的看到main方法向modify方法中传递的是对象引用 a1 的一份拷贝（为了方便区分，将拷贝命名为aa1），这两个引用都指向同一块堆内存区域（同一个A对象）。所以，我们可以想象，在modify方法中可以通过 aa1 来修改A对象的属性，而且其变化在由modify返回main以后依然会保留下来。

下面通过一个例子来分析一下：

List-2:

 package com;

 public class A {
     int cunt = 5;
     String str = "hello";

     public String toString() {
         return "A [cunt=" + cunt + ", str=" + str + "]";
     }
 }

 package com;

 public class Func {

     public void modify(A a){
         //通过“对象引用”来修改对象的属性
         a.cunt = 111;
         a.str = "modify";
     }

     public void newObj(A a){
         //创建了一个新的对象，企图在方法中将新对象引用赋值给形参a的
         //方式来达到修改外围方法中实参引用的目的。
         //注意：这个是做不到的。
         a = new A();
         a.cunt = 222;
         a.str = "newObj";
     }

     public A reNewObj(A a){
         //返回一个新对象，在外围方法中将返回的对象引用赋值给实参
         //这种方法是可以实现的。
         a = new A();
         a.cunt = 333;
         a.str = "reNewObj";
         return a;
     }

     public static void main(String[] args) {

         Func f = new Func();

         //在modify方法中通过形参来改变a1对象的属性，在modify
         //方法返回以后，修改的属性可以保留下来。
         A a1 = new A();
         f.modify(a1);
         System.out.println(a1);

         //企图通过newObj方法让a2指向新的对象。
         //但是，这样做不可能达到目的。
         A a2 = new A();
         f.newObj(a2);
         System.out.println(a2);

         //reNewObj方法会返回一个新的对象引用，并将其赋值给a3
         //这种方式可以让a3指向一个新的对象。
         A a3 = new A();
         a3 = f.reNewObj(a3);
         System.out.println(a3);

     }
 }

运行结果：

我们知道，A对象初始化的时候 cunt = 5, str = "hello" 。现在来分析上面的三个结果的原理。

1、第一个结果是 “cunt = 111, str = "modify" 说明 f.modify(a1) 方法中通过形参a1对A对象属性的修改被保留了下来。现在来分析，为什么会保留下来？？

解释：

①. 在main方法中，a1指向堆内存中的一个A对象，a1是作为A对象的一个引用，其值是“引用”（对空间的地址值）。

调用f.modify(a1)的时候，a1作为实参传递给modify方法，由于java参数传递是属于“值传递”（值的拷贝），所以在modify堆栈中会有a1的一份拷贝，两个a1指向同一个A对象。

②. 通过modify堆栈中的引用a1可以操作其所指向的对内存中的对象。在modify方法中将堆内存中的A对象属性值修改为“cunt = 111, str = "modify"”。

③. modify方法返回以后，modify堆栈中的a1引用所占内存被回收，main堆栈中的a1依然指向最开始的那个对象空间。由于在modify方法中已经将对象的属性修改了，所以在main中的a1可以看见被修改后的属性值。

2、第二个结果是 “cunt = 5, str = "hello"，说明main方法中的a2所指向的对象没有变化。42行中 f.newObj(a2); 方法的原本意图是：在newObj方法中新创建一个A对象，并将其赋值给newObj的形参a2，并且期望在newObj方法返回以后main方法的局部变量a2也指向新的A对象。

可是，从打印的结果来看，main方法中的局部变量a2依然指向原来的A对象，并没有指向newObj方法中新建的A对象。

那么，这个是为什么呢？？

解释：

①. 前面两个图和1中的解释是一样的，无非就是一个参数的“值传递问题”。

②. 在newObj方法中有这样的三条语句：a = new A();　a.cunt = 222; a.str = "newObj";

　  其执行过程是这样的：在堆内存中开辟一块新的A对象空间，让newObj堆栈中的a2引用指向新的对象空间 → 后两句语句会修改新对象的属性值。

注意，此时main堆栈中的a2依然指向最开始的那个对象空间，而newObj堆栈中的a2却指向了新的对象。

③. newObj方法返回，newObj堆栈空间被回收，堆空间中的新对象没有任何变量引用它，在合适的时机会被JVM回收。此时，返回到main方法中，此时的a2依然指向

依然指向最开始的那个A对象，其属性值没有发生变化。

所以，外围方法中的实参无法看见在内部方法中新创建的对象。除非，新创建的对象作为内部方法的返回值，并且在外围方法中将其赋值给实参变量。就像47~49行所做的那样：在reNewObj方法中新创建一个对象并赋值给形参，同时在方法最后将新对象作为返回值返回给外围方法，进一步在外围方法中将返回的对象赋值为a3，从而达到目的。