在 Java 的代码开发过程中，为了尽可能提高方法的复用性，明确方法的作用，同时防止一个方法内部过于臃肿的问题，往往会创建许多方法，那么不可避免地会涉及到参数传递的问题。通常来说，我们将 Java 中的参数传递分为两种：值传递和引用传递。

• 值传递：参数在进入方法时，将入参深度复制一个副本，在方法内部操作的是入参的副本，在方法执行完毕之后，外部的入参没有发生任何变化。
• 引用传递：在方法内部操作的是参数本身，对入参做出的修改会保留到方法的外部。

　　那么在 Java 中，哪些情况属于值传递，哪些情况属于引用传递呢？

1.      入参的类型

　　有一种错误的见解被广为流传：如果入参是基本类型，属于值传递；如果入参不是基本类型，则属于引用传递。或者说，再深入探讨一点，和入参存储的位置相关。（基本类型存储在堆栈中，对象存储在堆中）

　　以上这种说法其实并不完全正确。前半句基本认同，但是对于后半句，我可以很轻松地找到如下反例：

　　由上图可知，字符串 String 类型产生的对象，是存储在堆中的非基本类型。根据以上看法，这种参数传递方式应该是引用传递，那么对字符串做出的修改应该会保存到 change(String) 方法之外，然而最终的输出结果并不是这样。把 String 改成 StringBuffer，做类似的操作，得出的结果也和 String 一致的。

　　结论：基本类型的参数传递，一定是值传递；但是非基本类型的参数，其传递方式不一定是引用传递，需要进一步地分析。

2.      方法的返回类型

　　另外有一种错误的看法，参数传递方式，和方法是否拥有返回值有关，如果一个方法有返回值，那么参数一定是按照值传递的。看一下如下的例子：

 1     public static void main(String[] args) {
 2         Person p1 = new Person();
 3         p1.setAge(20);
 4         p1.setGender(0);
 5         p1.setName("哈哈");
 6         Person p2 = new Person();
 7         BeanUtil.copySameFieldsObject(p1, p2);
 8         change1(p1);
 9         System.out.println(p1);
10         change2(p2);
11         System.out.println(p2);
12     }
13
14     private static void change1(Person p) {
15         p.setAge(30);
16         p.setGender(1);
17         p.setName("呵呵");
18     }
19
20     private static Person change2(Person p) {
21         p.setAge(30);
22         p.setGender(1);
23         p.setName("呵呵");
24         return null;
25     }

Test1

　　如果说参数传递的方式，和方法的返回值有关，那么以上的两次输出结果一定是不同的（Person 类已经重写了 toString() 方法），因为根据以上推论，第一种方法是引用传递，第二种方法是值传递，但是实际上两次的输出结果是相同的。

　　结论：参数传递方式，与方法是否有返回值，返回值的类型没有关系。

3.      真正决定入参传递方式的因素

　　对于非基本类型的入参，其参数传递的方式是不定的。可以看一下如下例子：

 1     public static void main(String[] args) {
 2         Person p1 = new Person();
 3         p1.setAge(20);
 4         p1.setGender(0);
 5         p1.setName("哈哈");
 6         Person p2 = new Person();
 7         BeanUtil.copySameFieldsObject(p1, p2);
 8         Person p3 = new Person();
 9         BeanUtil.copySameFieldsObject(p1, p3);
10         change1(p1);
11         System.out.println(p1);
12         change2(p2);
13         System.out.println(p2);
14         change3(p3);
15         System.out.println(p3);
16     }
17
18     private static void change1(Person p) {
19         p.setAge(30);
20         p.setGender(1);
21         p.setName("呵呵");
22     }
23
24     private static void change2(Person p) {
25         p = new Person("呵呵", 1, 30);
26     }
27
28     private static void change3(Person p) {
29         p.setName("呵呵");
30         p = new Person("呵呵", 1, 30);
31     }

Test2

　　以上程序中， BeanUtil.copySameFieldsObject() 方法的作用是深度复制一份第一个参数的内容，给第二个参数，输出结果如下图所示：

通过以上研究可以得出如下结论：

• 可以认为非基本类型的入参的参数传递方式为引用传递，但是根据方法内部执行的代码，这种传递方式存在变数，可能被转化为值传递。
• 可以认为，方法的入参是一个对象的引用，记为 p，存放在堆栈中，这个引用指向堆中的一片内存，记为 q。当整个方法只会修改 q 的内容，而 p 始终指向 q 时，可以把整个参数传递，作为引用传递来看待。
• 当方法内部，如果代码企图将 p 指向另一片内存 t，这时，JVM 会创建另一个引用 r，让 r 指向 t，而 p 仍然指向 q。
• 这种试图更改指针指向的行为，主要是创建一个新的对象。创建对象的具体方法，见上一章节的内容。还包括几种特殊形式，如使用操作符“=”，创建 String 类型的对象。另外需要额外注意的是某些方法，内部实现使用了 new 创建对象，如 String.concat(String) 方法。
• 基本类型的8种包装类型，可以当做基本类型处理，其参数传递方式虽然是引用传递，但是可以认为与值传递等价。因为这8种包装类型和 String 类型相同，其内部的数据是不可变的，这意味着任何的变动，本质上是在内存中开辟了一个新的对象。