Java变量之间传值时可分为值传递和引用传递, 那么它们有何区别？
1. 简单类型是按值传递的
Java 方法的参数是简单类型的时候，是按值传递的(pass by value)，需要注意的是，对于基本类型的包装类型，因为JVM的自动拆箱操作，包装类型变成基本类型后也会按基本类型来进行操作，那么也是按值进行传递。这一点我们可以通过一个简单的例子来说明：
- public class PrimitiveValuePass {
- public static void main(String[] args) {
- boolean test = true ;
- System.out.println( " ======= Test Pass1 ======= " );
- System.out.println( "Before pass : test = " + test);
- pass1(test);
- System.out.println( "After pass : test = " + test);
- System.out.println( " ======= Test Pass2 ======= " );
- Boolean test2 = true ;
- System.out.println( "Before pass : test = " + test);
- pass2(test2);
- System.out.println( "After pass : test = " + test);
- }
- // Primitive value pass
- public static void pass1( boolean test) {
- test = !test;
- System.out.println( "in pass : test = " + test);
- }
- // 会自动拆箱为基本类型
- public static void pass2(Boolean test) {
- test = !test;
- System.out.println( "in pass : test = " + test);
- }
- }
输出结果：
======= Test Pass1 =======
Before pass : test = true
in pass : test = false
After pass : test = true
======= Test Pass2 =======
Before pass : test = true
in pass : test = false
After pass : test = true
不难看出，虽然在pass1(boolean)方法中改变了传进来的参数的值，但对这个参数源变量本身并没有影响，即对main(String[])方法里的test变量没有影响。那说明，参数类型是简单类型的时候，是按值传递的。以参数形式传递简单类型的变量时，实际上是将参数的值作了一个拷贝传进方法函数的，那么在方法函数里再怎么改变其值，其结果都是只改变了拷贝的值，而不是源值。
2. 什么是引用
Java 是传值还是传引用，问题主要出在对象的传递上，因为Java 中简单类型没有引用。既然争论中提到了引用这个东西，为了搞清楚这个问题，我们必须要知道引用是什么？
简单的说，引用其实就像是一个对象的名字或者别名(alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似C语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。
如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间来保存。但是它们的值是相同的，都指示同一个对象在内存的中位置。比如
- String a = "Hello" ;
- String b = a;
这里，a 和b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象"Hello"。也许你还觉得不够直观，因为String 对象的值本身是不可更改的(像b = "World"; b = a; 这种情况不是改变了"World" 这一对象的值，而是改变了它的引用b 的值使之指向了另一个String 对象a)。那么我们用StringBuffer 来举一个例子：
- public class Test {
- public static void main(String[] args) {
- StringBuffer a = new StringBuffer( "Hello" );
- StringBuffer b = a;
- b.append( ", World" );
- System.out.println( "a is " + a);
- }
- }
运行结果：
a is Hello, World
这个例子中a 和b 都是引用，当改变了b 指示的对象的值的时候，从输出结果来看，a 所指示的对象的值也改变了。所以，a 和b 都指向同一个对象即包含"Hello" 的一个StringBuffer 对象。
这里描述了两个要点：
1. 引用是一种数据类型，保存了对象在内存中的地址，这种类型即不是我们平时所说的简单数据类型也不是对象（类实例）；
2. 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。
3. 按引用传递是什么？
指的是在方法调用时，传递的参数是按引用进行传递，按前面的表述，传递引用其实就是传递引用的地址，也就是变量所对应的内存空间的地址。
事例：
- public class ObjPass {
- /**
- * @param args
- */
- public static void main(String[] args) {
- ObjPass pass = new ObjPass();
- Person person = pass. new Person();
- person.age = 10 ;
- System.out.println( "Before pass : main方法中的age = " + person.age);
- pass.passTest(person);
- System.out.println( "After pass : main方法中的age = " + person.age);
- }
- public void passTest (Person person) {
- person.age = 20 ;
- System.out.println( "passTest中的age = " + person.age);
- }
- class Person {
- public int age = 0 ;
- }
- }
Before pass : main 方法中的age = 10
passTest中的age = 20
After pass : main 方法中的age = 20
从这个例子可以看出，对象类型确实是按引用进行传递的，而不是按值的拷贝进行传递的。
4、一定要注意String对象的传递
从3的例子的输出结果可以看出，对象的传递是引用传递，当引用指向的值发生改变后，传递的那个引用所指向的值当然就发生了改变。但是赋值方式的String的传递相当于值传递，而不是引用传递，即
String str = "Hello world"的传递不是引用传递，对String有一定了解的童鞋相信都知道为啥，因为String类很特殊，对于：
- String str = "123" ;
- str = "hello world" ;
- public class StringValuePass {
- public static void passTest(String str) {
- System.out.println( " === before append: hash code: " + str.hashCode());
- str = " hello : " + str;
- System.out.println( " === After append: hash code: " + str.hashCode());
- System.out.println( "in pass : str = " + str);
- }
- public static void main(String[] args) {
- System.out.println( " ======= Test Pass3 ======= " );
- String str = "wangsheng" ;
- System.out.println( "Before pass : str = " + str + " hash code: " + str.hashCode());
- passTest(str);
- System.out.println( "After pass : str = " + str);
- }
- }
======= Test Pass3 =======
Before pass : str = wangsheng hash code: -1185442234
=== before append: hash code: -1185442234
=== After append: hash code: -414738574
in pass : str = hello : wangsheng
After pass : str = wangsheng
从输出结果的hash code值以及str的值，结果一目了然。
5、 结论：
从上面执行的结果，我们不难得出下面的结论：
（1）：“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。
（2）：在Java里面只有基本类型和按照下面这种定义方式的String是按值传递，其它的都是按引用传递。就是直接使用双引号定义字符串方式：String str = "Hello World";
所以你可以说是按值传递，如结论1， 也可以严格的说大多对象是按引用传递，如结论2。
6、番外篇：
就像光到底是波还是粒子的问题一样，Java 方法的参数是按什么传递的问题，其答案就只能是：即是按值传递也是按引用传递，只是看问题的角度不同，结果也就不同。
正确看待传值还是传引用的问题
要正确的看待这个问题必须要搞清楚为什么会有这样一个问题。
实际上，问题来源于C，而不是Java。
C 语言中有一种数据类型叫做指针，于是将一个数据作为参数传递给某个函数的时候，就有两种方式：传值，或是传指针，它们的区别，可以用一个简单的例子说明：
- void SwapValue( int a, int b) {
- int t = a;
- a = b;
- b = t;
- }
- void SwapPointer( int * a, int * b) {
- int t = * a;
- * a = * b;
- * b = t;
- }
- void main() {
- int a = 0, b = 1;
- printf( "1 : a = %d, b = %d\n" , a, b);
- SwapValue(a, b);
- printf( "2 : a = %d, b = %d\n" , a, b);
- SwapPointer(&a, &b);
- printf( "3 : a = %d, b = %d\n" , a, b);
- }
运行结果：
1 : a = 0, b = 1
2 : a = 0, b = 1
3 : a = 1, b = 0
大家可以明显的看到，按指针传递参数可以方便的修改通过参数传递进来的值，而按值传递就不行。
当Java 成长起来的时候，许多的C 程序员开始转向学习Java，他们发现，使用类似SwapValue 的方法仍然不能改变通过参数传递进来的简单数据类型的值，但是如果是一个对象，则可能将其成员随意更改。于是他们觉得这很像是C 语言中传值/传指针的问题。但是Java 中没有指针，那么这个问题就演变成了传值/传引用的问题。可惜将这个问题放在Java 中进行讨论并不恰当。
讨论这样一个问题的最终目的只是为了搞清楚何种情况才能在方法函数中方便的更改参数的值并使之长期有效。
Java 中，改变参数的值有两种情况：
第一种，使用赋值号“=”直接进行赋值使其改变，如PrimitiveValuePass ；
第二种，对于某些对象的引用，通过一定途径对其成员数据进行改变，如ObjPass。对于第一种情况，其改变不会影响到方法该方法以外的数据，或者直接说源数据。而第二种方法，则相反，会影响到源数据——因为引用指示的对象没有变，对其成员数据进行改变则实质上是改变了该对象。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
