当前页面: 开发资料首页 → Java 专题 → Java 是传值还是传引用
Java 是传值还是传引用
摘要: Java 是传值还是传引用
1. 简单类型是按值传递的 Java 方法的参数是简单类型的时候，是按值传递的 (pass by value)。这一点我们可以通过一个简单的例子来说明：
/* 例 1 */ /** * @(#) Test.java * @author fancy */ public class Test { public static void test(boolean test) { test = ! test; System.out.println("In test(boolean) : test = " + test); } public static void main(String[] args) { boolean test = true; System.out.println("Before test(boolean) : test = " + test); test(test); System.out.println("After test(boolean) : test = " + test); } } 运行结果：
Before test(boolean) : test = true In test(boolean) : test = false After test(boolean) : test = true 不难看出，虽然在 test(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 来举一个例子：
/* 例 2 */ /** * @(#) Test.java * @author fancy */ 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. 对象是如何传递的呢 关于对象的传递，有两种说法，即“它是按值传递的”和“它是按引用传递的”。这两种说法各有各的道理，但是它们都没有从本质上去分析，即致于产生了争论。
既然现在我们已经知道了引用是什么东西，那么现在不妨来分析一下对象作是参数是如何传递的。还是先以一个程序为例：
/* 例 3 */ /** * @(#) Test.java * @author fancy */ public class Test { public static void test(StringBuffer str) { str.append(", World!"); } public static void main(String[] args) { StringBuffer string = new StringBuffer("Hello"); test(string); System.out.println(string); } } 运行结果：
Hello, World! test(string) 调用了 test(StringBuffer) 方法，并将 string 作为参数传递了进去。这里 string 是一个引用，这一点是勿庸置疑的。前面提到，引用是一种数据类型，而且不是对象，所以它不可能按引用传递，所以它是按值传递的，它么它的值究竟是什么呢？是对象的地址。
由此可见，对象作为参数的时候是按值传递的，对吗？错！为什么错，让我们看另一个例子： /* 例 4 */ /** * @(#) Test.java * @author fancy */ public class Test { public static void test(String str) { str = "World"; } public static void main(String[] args) { String string = "Hello"; test(string); System.out.println(string); } } 运行结果：
Hello 为什么会这样呢？因为参数 str 是一个引用，而且它与 string 是不同的引用，虽然它们都是同一个对象的引用。str = "World" 则改变了 str 的值，使之指向了另一个对象，然而 str 指向的对象改变了，但它并没有对 "Hello" 造成任何影响，而且由于 string 和 str 是不同的引用，str 的改变也没有对 string 造成任何影响，结果就如例中所示。
其结果是推翻了参数按值传递的说法。那么，对象作为参数的时候是按引用传递的了？也错！因为上一个例子的确能够说明它是按值传递的。
结果，就像光到底是波还是粒子的问题一样，Java 方法的参数是按什么传递的问题，其答案就只能是：即是按值传递也是按引用传递，只是参照物不同，结果也就不同。
4. 正确看待传值还是传引用的问题 要正确的看待这个问题必须要搞清楚为什么会有这样一个问题。
实际上，问题来源于 C，而不是 Java。
C 语言中有一种数据类型叫做指针，于是将一个数据作为参数传递给某个函数的时候，就有两种方式：传值，或是传指针，它们的区别，可以用一个简单的例子说明：
/* 例 5 */ /** * @(#) test.c * @author fancy */ 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 中，改变参数的值有两种情况，第一种，使用赋值号“=”直接进行赋值使其改变，如例 1 和例 4；第二种，对于某些对象的引用，通过一定途径对其成员数据进行改变，如例 3。对于第一种情况，其改变不会影响到方法该方法以外的数据，或者直接说源数据。而第二种方法，则相反，会影响到源数据——因为引用指示的对象没有变，对其成员数据进行改变则实质上是改变的该对象。
5. 如何实现类似 swap 的方法 传值还是传引用的问题，到此已经算是解决了，但是我们仍然不能解决这样一个问题：如果我有两个 int 型的变量 a 和 b，我想写一个方法来交换它们的值，应该怎么办？
结论很让人失望——没有办法！因此，我们只能具体情况具体讨论，以经常使用交换方法的排序为例：
/** 例 6 */ /** * @(#) Test.java * @author fancy */ public class Test { public static void swap(int[] data, int a, int b) { int t = data[a]; data[a] = data[b]; data[b] = t; } public static void main(String[] args) { int[] data = new int[10]; for (int i = 0; i < 10; i++) { data[i] = (int) (Math.random() * 100); System.out.print(" " + data[i]); } System.out.println(); for (int i = 0; i < 9; i++) { for (int j = i; j < 10; j++) { if (data[i] > data[j]) { swap(data, i, j); } } } for (int i = 0; i < 10; i++) { System.out.print(" " + data[i]); } System.out.println(); } } 运行结果(情况之一)：
78 69 94 38 95 31 50 97 84 1 1 31 38 50 69 78 84 94 95 97 swap(int[] data, int a, int b) 方法在内部实际上是改变了 data 所指示的对象的成员数据，即上述讨论的第二种改变参数值的方法。希望大家能够举一反三，使用类似的方法来解决相关问题。
作者相关文章： Java 高层网络编程(翻译) 在 .NET 程序的窗体中使用 XP 风格的控件(翻译) 具有 Applet & Application 双重身份的类(原作)
对该文的评论 LuckyMan2001(2002-12-18 14:49:33)
唉，这不就是传值和传址的问题嘛！ 其实这就是在Java中对那几种基本数据类型和对对象的不同的创建、存储以及使用所造成的！ Java中的基本数据类型的使用是创建一个并非句柄的“自动”变量，而变量容纳了具体的值，并置于堆栈中； ～ 值 Java中的对象的使用是创建一个句柄，并用new关键字使它同一个新对象连接，而对象实际是存储在堆中的。 ～ 址
spring_y(2002-12-13 17:35:05)
原来如此
qiuyilai(2002-12-13 15:10:26)
我觉得freelybird说得经典.
flyingbugs(2002-12-12 18:05:59)
Java确实不如C/C++(个人感受！)
bigtimber(2002-12-12 15:13:57)
《The Java™ Language Specification》Second Edition 15.18.1 String Concatenation Operator + If only one operand expression is of type String, then string conversion is performed on the other operand to produce a string at run time. The result is a reference to a newly created String object that is the concatenation of the two operand strings. The characters of the left-hand operand precede the characters of the right-hand operand in the newly created string.
多谢SnHnBn指点迷津。 至此已明白运算符+生成了新的实例，致使str不再与string指向同一地址（引用本身的值），而是指向了新的实例。罗嗦一下，上句话就是说+改变了引用（Reference）str本身的值（引用str本身的值就是str实例的地址）
SnHnBn(2002-12-12 13:48:17)
再修正：a不是释放了原来的String, 而是不再引用原来的String。 补充：String的内容确定之后不能动态增加，只能另外创建新的String实例来保存。
SnHnBn(2002-12-12 13:42:13)
不好意思，我认真做了一下实验，纠正我的部分错误： 首先，String对象传的总是引用（指针）是没错。 问题出在 +=, 这个东西其实并不是String的成员方法。String里面没有这个东西。 这里的+=就是简单的 a = a + b，因为a + b是重新生成的一个string实例，所以a释放了原来的String引用而改用了a+b生成的新实例。请看下面的例子，我们去掉test，只留下main： public class Test { public static void main(String[] args) { String string = "Hello"; String str=string; str+= ", World"; System.out.println(str); System.out.println(string); } } 结果一样是： Hello, World Hello
SnHnBn(2002-12-12 13:16:46)
我来给你解释一下，传递的是String 的引用（指针），在函数内部，通过传进来的引用（指针）操作那个String的实例，+=是String的一个方法（已重载），因此操作了调用者的String，使其值改变（对象本身并没有改变，还是那个对象），因为String表现出来的字符内容实质上是他的一个隐含属性（方法返回）。
bigtimber(2002-12-12 11:50:15)
楼下几位否能解释一下这个例子呢？ 例子中的变量string和str都是Class String的一个实例(instance)，在传递过程中到底是如何进行的??希望有高手指教。 //Test.java public class Test { public static void test(String str) { str += " World"; System.out.println(str); } public static void main(String[] args) { String string = "Hello"; test(string); System.out.println(string); } }
output: Hello World Hello
tonytan(2002-12-12 11:24:36)
java就是传值和传指针。java没有引用。
连sun公司自己都不说java没有指针， 而是没有指针的语法。
只有C＋＋有传值，传引用，传指针 这么复杂的东东
SnHnBn(2002-12-12 9:41:11)
“3. 对象是如何传递的呢” 这一小节里面，作者犯了个错误，他的第一个例子仍然很好地证明了对象是按引用传递的。并且所谓的引用，实质上就是按值传递对象的地址（其实也许叫做对象指针更准确些），所以里面的这句话“引用是一种数据类型，而且不是对象，所以它不可能按引用传递，所以它是按值传递的，它么它的值究竟是什么呢？是对象的地址”含有严重的矛盾。如果不好理解的话，把“引用”这种类型当作简单值类型就好了（指针是简单值）。所有的对象都是通过这个“引用”简单值进行操作的。
iamfancy(2002-12-11 22:57:34)
大家慢慢争吧，这个问题争得太多了，我都不想争了，其实上呢，一句话，都是传的值，问题是传的什么值： 基本类型数据，传的就是它本身，而对象，传的是它引用的值，也就是说，对象不会被拷贝一份的。如果大家喜欢分别说成是传值和传引用，也是一回事，反正说的就是这么一回事了——
简单类型传值，数据是被拷贝的。对象传引用值，拷贝的是引用，不是对象本身。
superssp(2002-12-11 21:54:58)
要了解问题的实质 1、Java中所有的参数都按值传递。（对于基本类型，谁都明白） 2、参数传递对象的引用时，实质上也是按值传递。在内存中又开辟了一个指针变量，指向对象实例。这时，型参和实参的值相同，都是对象实例的地址。但是，型参和实参自身的地址值是不同的。
bigtimber(2002-12-11 16:56:25)
freelybird(2002-12-11 12:03:32)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
itpunk(2002-12-11 11:45:55)
给楼下各位补充一下,除了基本类型和String是传值以外,其它对象都是传引用的;赋值亦如此,如了基本类型和String是赋值拷贝以外,其它对象都是赋句柄.
============================================================================= 两个加起来就全对了。 String的实例感觉很特殊：调试后发现，它的参数传递方式跟原子类型是一样的!传值!
例子4稍加修改： //Test.java public class Test { public static void test(String str) { str += " World"; System.out.println(str); } public static void main(String[] args) { String string = "Hello"; test(string); System.out.println(string); } }
这也说明了函数内部对形式参数的处理并不影响参数传递方式!真是白话,呵呵
bigtimber(2002-12-11 16:39:35)
freelybird(2002-12-11 12:03:32)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
itpunk(2002-12-11 11:45:55)
给楼下各位补充一下,除了基本类型和String是传值以外,其它对象都是传引用的;赋值亦如此,如了基本类型和String是赋值拷贝以外,其它对象都是赋句柄.
两个加起来就全对了。 String感觉很特殊：调试后发现，它的参数传递方式跟原子类型是一样的，传值！ 例子4稍加修改：
public class Test { public static void test(String str) { str += " World"; System.out.println(str); } public static void main(String[] args) { String string = "Hello"; test(string); System.out.println(string); } }
这也说明了函数内部对形式参数的处理并不影响参数传递方式!真是白话,呵呵
bigtimber(2002-12-11 16:39:10)
freelybird(2002-12-11 12:03:32)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
itpunk(2002-12-11 11:45:55)
给楼下各位补充一下,除了基本类型和String是传值以外,其它对象都是传引用的;赋值亦如此,如了基本类型和String是赋值拷贝以外,其它对象都是赋句柄.
两个加起来就全对了。 String感觉很特殊：调试后发现，它的参数传递方式跟原子类型是一样的，传值！ 例子4稍加修改：
public class Test { public static void test(String str) { str += " World"; System.out.println(str); } public static void main(String[] args) { String string = "Hello"; test(string); System.out.println(string); } }
这也说明了函数内部对形式参数的处理并不影响参数传递方式!真是白话,呵呵
freelybird(2002-12-11 12:03:32)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
itpunk(2002-12-11 11:45:55)
给楼下各位补充一下,除了基本类型和String是传值以外,其它对象都是传引用的;赋值亦如此,如了基本类型和String是赋值拷贝以外,其它对象都是赋句柄.
baishu3166(2002-12-11 11:34:11)
在java中，基本对象是按直传递的，而非基本对象是按引用传递的。
freelybird(2002-12-11 10:34:50)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
freelybird(2002-12-11 10:33:28)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
freelybird(2002-12-11 10:31:58)
说了一大堆废话,还是没把问题阐述清楚.
其实挺简单,就几条. 1 引用就是指针. java中所有对象实例都在堆中,只能通过引用(即指针)来访问这些实例. 2 java中的参数都是按引用传递.(但是基本数据类型却按值传递,因为primitive type的数据根本没有引用)
sonicsir(2002-12-10 21:10:30)
关注中。
slump(2002-12-10 17:23:21)
楼上说的对 Java中所有的参数都按值传递 所谓的传引用只不过是传递指针的值 这和C语言是一样的， C中所有的参数都按值传递，按指针传递实际上是传递指针的值 这样就非常清楚了
slump(2002-12-10 17:23:04)
楼上说的对 Java中所有的参数都按值传递 所谓的传引用只不过是传递指针的值 这和C语言是一样的， C中所有的参数都按值传递，按指针传递实际上是传递指针的值 这样就非常清楚了
sandywei(2002-12-10 17:13:50)
其实我们不应该机械的理解按引用传递就一定会更改实参， 上面第三点中的两个test方法已经说明得很清楚了。关键是看 函数内部对型参做如何的处理，如果该引用没有被修改（重新做其他的引用），那么将会修改实参； 另外，如果型参发生诸如: str = "World"; 型参引用另外对象，于是不会影响实参。
elabs(2002-12-10 12:50:26)
写的不错，可以给一些初学的以启示，但还是没有说清楚，到底什么时候引用发生，什么时候是直接传值。
zhangyan_qd(2002-12-10 10:29:40)
我觉得swap用一个类来实现更好一些。 class Swapper{ private int var1; private int var2; public Swapper(int a, int b){ var1 = b; var2 = a; } public int GetNewA(){ return var1; ｝ public int GetNewB(){ return var2; ｝ ｝
noho(2002-12-10 10:28:12)
1、Java中所有的参数都按值传递。 2、Java中拿不到对象，只能拿到对象的引用。
这两点不要混在一起就清楚了。Think in Java中说得很清楚了。
↑返回目录
前一篇: Java 相关的编译技术
后一篇: Java 实现关键路径分析