java 参数传递是值传递还是引用传递？

Question

下面代码 输出 AB,B  这是为什么？如果引用类型是值传递应该是 A,B
如果引用类型是引用传递应该是 AB,AB但为什么是AB,B
public class Foo{
public static void main(String sgf[]){
StringBuffer a = new StringBuffer("A");
StringBuffer b = new StringBuffer("B");
operate(a,b);
System.out.println(a+","+b);
} static void operate(StringBuffer x,StringBuffer y){
x.append(y);
y=x;
}
}
What is the result?
A. The code compiles and prints "A.B".
B. The code compiles and prints "A.A".
C. The code compiles and prints "B.B".
D. The code compiles and prints "AB.B".
E. The code compiles and prints "AB.AB".

Answer 1

//这样的帖子以前好几次了
public class Foo {    public static void main(String sgf[]) {
        StringBuffer a = new StringBuffer("A");
        StringBuffer b = new StringBuffer("B");
        operate(
            a,
            b);
        System.out.println(a + "," + b);
    }    static void operate(StringBuffer x, StringBuffer y) {//这里会拷贝引用a和b，拷贝成x和y，
        x.append(y);//这时候x和a指向同一个对象，所以改变了x，也影响到了引用a！所以它为AB
        y = x;//但是这里，仅仅把引用Y指向了引用x,也就是a,x,y指向同一个对象，但是原先的引用b还是指向原来的对象！！
    }
}

Answer 2

引用传递y=x;以后，y的指向就变了，就不是以前的那个了。  这句以后你再改y就是对x的改动。  这句以前如果你有y.append(B),最终输出就该项是： AB,BB

Answer 3

2楼的，我不明白
 x.append(y);//这时候x和a指向同一个对象，所以改变了x，也影响到了引用a！所以它为AB
 y = x;//这里难道不是y和b指向同一个对象？？为什么改变了y就不是改变b？？
看了API，上面说：一个类似于 String 的字符串缓冲区，但不能修改。不知道这个“不能修改”是什么意思呢？

Answer 4

Java操作的都是变量引用的对象。
如果操作时，修改了对象，则会引起所有指向它的变量
如果只是更改了指向，则不会改变其他变量指向以前的。
那个 y 是一个局部变量。

Answer 5

你先弄明白什么叫引用什么叫对象，只向同一个对象的2个引用！y=x；只是原先指向b的引用指向了x指向的对象！这时候你觉得原先的引用b会受影响吗？

Answer 6

java 参数传递是值传递还是引用传递?最根本还是值传递, 当我们传递内建数据类型, 如int, float等时, 直接复制他们的值, 这个没有任何疑问.但当我们传递一个对象的引用时到一个函数中时, 可以在那个函数中修改这个对象的成员属性的值. 
有些人在此也许有疑问, 到底这里是值传递还是引用? 实际是这里传递的是那个对象的引用的副本, 即复制了一份那个对象的引用, 然后传递给函数使用.
但是既然传递了副本, 又怎么能够修改那个对象的数据呢? 
例如:
ref1指向对象 obj, 
作为函数的参数传递过去时, 传递的是ref1的副本: ref2
其实ref2这时也是指向对象 obj, 因为引用实际上是对象的内存地址值.
这样, 两个不同的引用ref1, ref2都是指向同一个内存地址, 所以可以修改对象的数据成员的值.
所以, 这里可以看出, 实际上传递的还是值, 而非传递了引用ref1, 而是复制ref2来传递的.结论: Java中没有所谓的引用传递, 只有唯一的值传递.

Answer 7

各位，也就是说
x.append(y);//这段代码的作用是改变对象的操作
y=x;//而这段代码只是改变引用的操作
是这个意思吗？

Answer 8

Java操作的都是变量引用的对象。 
如果操作时，修改了对象，则会引起所有指向它的变量 
如果只是更改了指向，则不会改变其他变量指向以前的。 
那个 y 是一个局部变量。

Answer 9

public class Foo{ 
public static void main(String sgf[]){ 
StringBuffer a = new StringBuffer("A"); 
StringBuffer b = new StringBuffer("B"); 
operate(a,b); 
System.out.println(a+","+b); 
} static void operate(StringBuffer x,StringBuffer y){ 
x.append(y); 
y=x; 
} 
} 
What is the result? 
A. The code compiles and prints "A.B". 
B. The code compiles and prints "A.A". 
C. The code compiles and prints "B.B". 
D. The code compiles and prints "AB.B". 
E. The code compiles and prints "AB.AB". 

Answer 10

operate(a,b); 
这样就可以把a,b的地址传过去怎么还说是传值？？？java 对于非原始类型都是传址的！！！
c 是传值的，如想传址要明确写出取址。  如：
operate(&a,&b); 

Answer 11

ab.b
static void operate(StringBuffer x, StringBuffer y) {
x.append(y);//修改x对象中的内容
y = x;//这一句对于调用者来说没有什么作用
}

Answer 12

这样可以看的更清楚
public class Test3 {
public Test3(){} public  String operate(StringBuffer x, StringBuffer y) 
       x.append(y);        
        y = x; 
       return x+","+y;
 }
public static void main(String args[]){
Test3  t = new Test3();
 StringBuffer a = new StringBuffer("A");
     StringBuffer b = new StringBuffer("B");
     System.out.println(a + "," + b); //
     String ss = t.operate(a,b);
     System.out.println(ss); //
     System.out.println(a + "," + b);// 
   

}  
}

Answer 13

y=x
X引用的对象赋值给Y也就是说这个时候X与Y引用指向同一个对象

Answer 14

这个更能说明问题
class Obj{
    String str = "init value";
    public String toString(){
        return str;
    }
}
public class ObjRef{
    Obj aObj = new Obj();
    int aInt = 11;
    public void changeObj(Obj inObj){
        inObj.str = "changed value";
    }
    public void changePri(int inInt){
        inInt = 22;
    }
    public static void main(String[] args) 
    {
        ObjRef oRef = new ObjRef();
        
        System.out.println("Before call changeObj() method: " + oRef.aObj);
        oRef.changeObj(oRef.aObj);
        System.out.println("After call changeObj() method: " + oRef.aObj);
        System.out.println("==================Print Primtive=================");
        System.out.println("Before call changePri() method: " + oRef.aInt);
        oRef.changePri(oRef.aInt);
        System.out.println("After call changePri() method: " + oRef.aInt);
    }
}
/* RUN RESULT
Before call changeObj() method: init value
After call changeObj() method: changed value
==================Print Primtive=================
Before call changePri() method: 11
After call changePri() method: 11
*
*/