传入对象时是传值还是传引用
java只有传值，没有传引用。
详细介绍 ：
http://guhanjie.iteye.com/blog/1683637
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！关于Java对象作为参数传递是传值还是传引用的问题
　　在Java中，当对象作为参数传递时，究竟传递的是对象的值，还是对象的引用，这是一个饱受争议的话题。若传的是值，那么函数接收的只是实参的一个副本，函数对形参的操作并不会对实参产生影响；若传的是引用，那么此时对形参的操作则会影响到实参。
　　首先我们来看一句代码：
Object obj = new Object();
　　这句话的意思是：创建一个Object对象，再创建一个名为obj的引用，让这个引用指向这个对象，如下图所示：
在有了上面的基础之后，我们便来看下面这组在网上很流行的例子：
基本数据类型作为参数传递：
public class test {
public static void main(String[] args) {
int i = 1;
System.out.println("before change, i = "+i);
change(i);
System.out.println("after change, i = "+i);
public static void change(int i){
　　这个例子不难理解，当基本数据类型作为参数传递时，传递的是实参值的副本，即传的是值，无论在函数中怎么操作这个副本，实参的值是不会被改变的。所以以上代码执行的结果是：
　　before change, i = 1
　　after change, i = 1
对象作为参数传递：
　　在下面的例２中，我们把StringBuffer对象作为参数传递到change函数。
public class test {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("Hello ");
System.out.println("before change, sb is "+sb.toString());
change(sb);
System.out.println("after change, sb is "+sb.toString());
public static void change(StringBuffer stringBuffer){
stringBuffer.append("world !");
　　为了方便推理出结论，我们先直接看程序的运行结果：
　　before change, sb is Hello
　　after change, sb is Hello world !
　　从输出结果中我们可以发现，sb所指向的对象的值被改变了，那么是否我们可以推论出，在Java中，当对象作为参数传递时，传递的是该对象的引用呢？我们再来看下面这个例子：
public class test {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("Hello ");
System.out.println("before change, sb is "+sb.toString());
change(sb);
System.out.println("after change, sb is "+sb.toString());
public static void change(StringBuffer stringBuffer){
stringBuffer = new StringBuffer("Hi ");
stringBuffer.append("world !");
　　如果上面的推论是正确的，即Java中对象作为参数传递，实际传递的是该对象的引用，那么在调用change函数之后，原对象的值应该是会改变的，变为“Hi world ！”，但是，当我们运行程序后，结果却是如下所示：
　　before change, sb is Hello
　　after change, sb is Hello
　　原对象的值并没有被改变，这与上面的推论相矛盾！为什么在Java中，当对象作为参数传递时，有的时候实参被改变了，而有的时候实参并未被改变呢？下面让我们来分析一下其中的原因：
　　从文章的开头我们知道，当执行StringBuffer sb = new StringBuffer(“Hello “)时，我们创建了一个指向新建对象“new StringBuffer(“Hello “)”的引用“sb”，如下图所示：
　　在例2中，当我们调用change函数后，实际上，形参stringBuffer也指向了实参sb所指向的对象，即：
　　那么当我们执行stringBuffer.append(“world !”)后，便通过对象的引用“stringBuffer”修改了对象的值，使之变成了“Hello world ！”，即：
　　但是，在例3中的change函数中，我们又新建了一个对象“new StringBuffer(“Hi “)”（这实际上在内存中开辟了一块在原对象地址之外的新区域），这让形参stringBuffer实际指向了这个新建的对象，并将新对象的值设置为“Hi world ！”，即：
　　那么我们就不难理解，为何在执行完change函数之后，实参的值仍为“Hello”了。
　　综上所述，我们可以得出结论：在Java中，当对象作为参数传递时，实际上传递的是一份“引用的拷贝”。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Java 到底是值传递还是引用传递？ - 知乎有问题，上知乎。知乎作为中文互联网最大的知识分享平台，以「知识连接一切」为愿景，致力于构建一个人人都可以便捷接入的知识分享网络，让人们便捷地与世界分享知识、经验和见解，发现更大的世界。629被浏览<strong class="NumberBoard-itemValue" title="5,378分享邀请回答int num = 10;
String str = "hello";
如图所示，num是基本类型，值就直接保存在变量中。而str是引用类型，变量中保存的只是实际对象的地址。一般称这种变量为"引用"，引用指向实际对象，实际对象中保存着内容。二：搞清楚赋值运算符（=）的作用num = 20;
str = "java";
对于基本类型 num ，赋值运算符会直接改变变量的值，原来的值被覆盖掉。对于引用类型 str，赋值运算符会改变引用中所保存的地址，原来的地址被覆盖掉。但是原来的对象不会被改变（重要）。如上图所示，"hello" 字符串对象没有被改变。（没有被任何引用所指向的对象是垃圾，会被垃圾回收器回收）三：调用方法时发生了什么？参数传递基本上就是赋值操作。第一个例子：基本类型
void foo(int value) {
value = 100;
foo(num); // num 没有被改变
第二个例子：没有提供改变自身方法的引用类型
void foo(String text) {
text = "windows";
foo(str); // str 也没有被改变
第三个例子：提供了改变自身方法的引用类型
StringBuilder sb = new StringBuilder("iphone");
void foo(StringBuilder builder) {
builder.append("4");
foo(sb); // sb 被改变了，变成了"iphone4"。
第四个例子：提供了改变自身方法的引用类型，但是不使用，而是使用赋值运算符。
StringBuilder sb = new StringBuilder("iphone");
void foo(StringBuilder builder) {
builder = new StringBuilder("ipad");
foo(sb); // sb 没有被改变，还是 "iphone"。
重点理解为什么，第三个例子和第四个例子结果不同？下面是第三个例子的图解：builder.append("4")之后下面是第四个例子的图解：builder = new StringBuilder("ipad"); 之后日添加部分内容：这个答案点赞的不少，虽然当时回答时并没有讲的特别详细，今天就稍微多讲一些各种类型数据在内存中的存储方式。从局部变量/方法参数开始讲起：局部变量和方法参数在jvm中的储存方法是相同的，都是在栈上开辟空间来储存的，随着进入方法开辟，退出方法回收。以32位JVM为例，boolean/byte/short/char/int/float以及引用都是分配4字节空间，long/double分配8字节空间。对于每个方法来说，最多占用多少空间是一定的，这在编译时就可以计算好。我们都知道JVM内存模型中有，stack和heap的存在，但是更准确的说，是每个线程都分配一个独享的stack，所有线程共享一个heap。对于每个方法的局部变量来说，是绝对无法被其他方法，甚至其他线程的同一方法所访问到的，更遑论修改。当我们在方法中声明一个 int i = 0，或者 Object obj = null 时，仅仅涉及stack，不影响到heap，当我们 new Object() 时，会在heap中开辟一段内存并初始化Object对象。当我们将这个对象赋予obj变量时，仅仅是stack中代表obj的那4个字节变更为这个对象的地址。数组类型引用和对象：当我们声明一个数组时，如int[] arr = new int[10]，因为数组也是对象，arr实际上是引用，stack上仅仅占用4字节空间，new int[10]会在heap中开辟一个数组对象，然后arr指向它。当我们声明一个二维数组时，如 int[][] arr2 = new int[2][4]，arr2同样仅在stack中占用4个字节，会在内存中开辟一个长度为2的，类型为int[]的数组，然后arr2指向这个数组。这个数组内部有两个引用（大小为4字节），分别指向两个长度为4的类型为int的数组。所以当我们传递一个数组引用给一个方法时，数组的元素是可以被改变的，但是无法让数组引用指向新的数组。你还可以这样声明：int[][] arr3 = new int[3][]，这时内存情况如下图你还可以这样 arr3[0] = new int [5]; arr3[1] = arr2[0];关于String：原本回答中关于String的图解是简化过的，实际上String对象内部仅需要维护三个变量，char[] chars, int startIndex, int length。而chars在某些情况下是可以共用的。但是因为String被设计成为了不可变类型，所以你思考时把String对象简化考虑也是可以的。String str = new String("hello")当然某些JVM实现会把"hello"字面量生成的String对象放到常量池中，而常量池中的对象可以实际分配在heap中，有些实现也许会分配在方法区，当然这对我们理解影响不大。916115 条评论分享收藏感谢收起pic4.zhimg.com/9d4d1d25add61af4442cae_b.jpg" data-editable="true" data-title="zhimg.com 的页面"&&/a&" data-rawwidth="524" data-rawheight="101" class="origin_image zh-lightbox-thumb" width="524" data-original="&a href="" data-editable="true" data-title="zhimg.com 的页面"&&/a&"&看到这里的名传递，可能就有人联想到C++里的别名(alias)，其实也是两码事儿。语言层直接支持名传递的语言很不主流，但是在C#中，名传递的行为可以用Func&T&来模拟，说到这儿应该能大概猜出名传递的大致行为了。不过这不是重点，重点是值传递和引用传递。上面给出的传值方式的表述有些单薄，下表列出了一些二者在行为表象上的区别。&img src="&a href="" data-editable="true" data-title="zhimg.com 的页面"&&/a&" data-rawwidth="474" data-rawheight="73" class="origin_image zh-lightbox-thumb" width="474" data-original="&a href="" data-editable="true" data-title="zhimg.com 的页面"&&/a&"&这里的改变不是指mutate, 而是change，指把一个变量指向另一个对象，而不是指仅仅改变属性或是成员什么的（如Java，所以说Java是Pass by value，原因是它调用时Copy，实参不能指向另一个对象，而不是因为被传递的东西本质上是个Value，这么讲计算机上什么不是Value?）。这些行为，与参数类型是值类型还是引用类型无关。对于值传递，无论是值类型还是引用类型，都会在调用栈上创建一个副本，不同是，对于值类型而言，这个副本就是整个原始值的复制。而对于引用类型而言，由于引用类型的实例在堆中，在栈上只有它的一个引用（一般情况下是指针），其副本也只是这个引用的复制，而不是整个原始对象的复制。这便引出了值类型和引用类型（这不是在说值传递）的最大区别：值类型用做参数会被复制，但是很多人误以为这个区别是值类型的特性。其实这是值传递带来的效果，和值类型本身没有关系。只是最终结果是这样。求值策略定义的是函数调用时的行为，并不对具体实现方式做要求，但是指针由于其汇编级支持的特性，成为实现引用传递方式的首选。但是纯理论上，你完全可以不用指针，比如用一个全局的参数名到对象地址的HashTable来实现引用传递，只是这样效率太低，所以根本没有哪个编程语言会这样做。（自己写来玩玩的不算）综上所述，对于Java的函数调用方式最准确的描述是：参数藉由值传递方式，传递的值是个引用。（句中两个“值”不是一个意思，第一个值是evaluation result，第二个值是value content）由于这个描述太绕，而且在字面上与Java总是传引用的事实冲突。于是对于Java，Python、Ruby、JavaScript等语言使用的这种求值策略，起了一个更贴切名字，叫。这个名字诞生于40年前。前面讨论了各种求值策略的内涵。下面以C++为例：void ByValue(int a)
a = a + 1;
void ByRef(int& a)
a = a + 1;
void ByPointer(int* a)
*a = *a + 1;
int main(int argv, char** args)
int v = 1;
ByValue(v);
// Pass by Reference
ByPointer(&v);
// Pass by Value
int* vp = &v;
ByPointer(vp);
Main函数里的前两种方式没有什么好说，第一个是值传递，第二个函数是引用传递，但是后面两种，同一个函数，一次调用是Call by reference, 一次是Call by value。因为：ByPointer(vp);
没有改变vp，其实是无法改变。ByPointer(&v);
改变了v。（你可能会说，这传递的其实是v的地址，而ByPointer无法改变v的地址，所以这是Call by value。这听上去可以自圆其说，但是v的地址，是个纯数据，在调用的方代码中并不存在，对于调用者而言，只有v，而v的确被ByPointer函数改了，这个结果，正是Call by reference的行为。从行为考虑，才是求值策略的本意。如果把所有东西都抽象成值，从数据考虑问题，那根本就没有必要引入求值策略的概念去混淆视听。）请体会一下，应该就明白上面一直在说的调用的行为的意思。C语言不支持引用，只支持指针，但是如上文所见，使用指针的函数，不能通过签名明确其求值策略。C++引入了引用，它的求值策略可以确定是Pass by reference。于是C++的一个奇葩的地方来了，它语言本身（模拟的不算，什么都能模拟）支持Call by value和Call by reference两种求值策略，但是却提供了三种语法去做这俩事儿。C#的设计就相对合理，函数声明里，有ref/out，就是引用传递，没有ref/out，就是值传递，与参数类型无关。不过如果观察一下void ByRef(int& a)和void ByPointer(int* a)所生成的汇编代码，会发现在一定条件下其实是一样的。都是这个样子：; 12
mov ebp, esp
sub esp, 192
lea edi, DWORD PTR [ebp-192]
mov ecx, 48
mov eax, -
; ccccccccH
*a = *a + 1;
mov eax, DWORD PTR _a$[ebp]
mov ecx, DWORD PTR [eax]
add ecx, 1
mov edx, DWORD PTR _a$[ebp]
mov DWORD PTR [edx], ecx
调用方的代码也是一样的。代码就不贴了。这两种传递方式说完了，下面回到正题说好处。问题中“这种”指代不明，且认为是Java。支持多种求值策略可以给语言带来更高的灵活性，但是同时也需要一个“灵活”的人来良好地驾驭。Java通过牺牲这种价值不大还可能带来问题的灵活性，带来了语言自身语法一致性、逻辑鲁棒性及更容易学习等多个好处。不仅仅Java和C#，每个语言，在设计时都需要在这些特性间做出自己独特的取舍来体现自己的设计理念，并适应不同人，不同使用环境的要求。虽然说没有什么功能是一个语言可以做，而另一个语言做不了的。但是每个语言，都有它最适合的范畴与不适合的范畴。418 条评论分享收藏感谢收起职友集：一家做公司点评的网站}