传递的是对象，但居然没有遵守引用传递的规则

Question

就是以下程序：public class aa
   {
      String haha = "aaaaa";      public static void main ( String args [ ] )
         {
            aa h = new aa ( );
            h.change ( h.haha );
            
            System.out.println ( h.haha );
         }      private void change ( String arg )
         {
            arg = "bbbbb";
         }
   }打印出来的值居然是:bbbbb

Answer 1

String haha = new String("aaaaa");
String haha = "aaaaa";
是有区别的.要用第一种

Answer 2

"aaaa"=="aaaa" 返回true
但是如果你 String a=new ("aaaa");
           String b=new ("aaaa");
a==b 返回的是false
a.equals(b)返回的是true;

Answer 3

说错了，打印结果是：aaaaa前面两位，答非所问呀请问到底是什么原因呀

Answer 4

说错了，打印结果是：aaaaa前面两位，答非所问呀请问到底是什么原因呀

Answer 5

正确答案是aaaaa
原因：在java里，一切传递皆是按值传递。
对于基本数据类型，传递的是它的另外一个拷贝。包括String.
而对于object,虽说是按引用传递，实际上也是按值传递。因为传递的是它的
引用的一个拷贝，而不是它所指向的对象的拷贝。因此，把引用改变也就把它所指向的
对象改变了（实际上不用传对象）。因此也叫做按引用传递。各位兄弟，明白了吗？

Answer 6

//但居然没有遵守引用传递的规则 
什么规则啊？Strings are constant

Answer 7

对于基本数据类型，传递的是它的另外一个拷贝。包括String.前半句对,后半句错!String不是基本类型,只不过是只读类型而已!
既然只读,就是不可变,既然不可变,当然可以共享,拷贝的时候无须创建新对象

Answer 8

aa h = new aa ( );
h.change ( h.haha );
还是不明白，h.haha 是字符串对象的引用，它传递给了change （ String arg ）函数，在函数中又有arg = "bbbbb";那么，打印的值就是 bbbbb 呀况且String继承至Object呀请各位达人，详解

Answer 9

虽然说String is constant但是它还是要被引用的呀，我把引用所引用的值修改了，那就应该打印 bbbbb我把程序修改如下：public class aa
   {
      String haha = new String ( "aaaaa" );      public static void main ( String args [ ] )
         {
            aa h = new aa ( );
            h.change ( h.haha );            System.out.println ( h.haha );
         }      private void change ( String arg )
         {  System.out.println ( arg );
            arg = new String ( "bbbbb" );
            System.out.println ( arg );
         }
   }打印结果：
aaaaa
bbbbb
aaaaa如果按你们的说法那应该是
aaaaa
aaaaa
aaaaa我的关键问题是， arg 和 haha 是指向同一个地方的，那对arg进行了操作相应的haha指向的数据也会变

Answer 10

当然是
打印结果：
aaaaa
bbbbb
aaaaa我都晕死了.你还没搞清  "aaaaa" 和 new String("aaaaa")的区别!!!!
"aaaaa" 值传递
new String("aaaaa") 引用传递天,我以为昨天你就搞明白了呢.

Answer 11

arg 和 haha 是指向同一个地方的，那对arg进行了操作相应的haha指向的数据也会变问题是指向的对象不可变呀,
对arg进行操作只是让arg指向新的对象而已!

Answer 12

1.String haha = "aaaaa";
分析： 执行这一句，系统在栈中分配了一个名为haha存储空间，并且初始化为"aaaaa"
2.h.change ( h.haha );
private void change ( String arg )
         {
            arg = "bbbbb";
         }分析：系统把change方法的参数看作一个局部变量，在栈中为arg 分配了一个空间，然后把haha的值拷贝一份赋给arg,这个时候在方法体内对 arg = "bbbbb";只是改变了arg变量的值，并没有影响haha的值。所以最后的打印就是：aaaaa

Answer 13

arg = new String ( "bbbbb" );
这样做是新建了一个对象，然后把这个对象赋值给arg（放弃了原来的对象）
然后你操作的就不是传过来的对象了，而原来的对象的值当然不会改变

Answer 14

public class aa
   {
      StringBuffer haha = new StringBuffer ( "aaaaa" );      public static void main ( String args [ ] )
         {
            aa h = new aa ( );
            h.change ( h.haha );            System.out.println ( h.haha );
         }      private void change ( StringBuffer arg )
         {  System.out.println ( arg );
            arg.append("asdf");
            System.out.println ( arg );
         }
   }
结果是
aaaaa
aaaaaasdf
aaaaaasdf理解一下

Answer 15

呵呵，不能简单的理解成是引用传递。应该说是传递的是地址的副本。先不考虑String，
class A1 {    int t = 0;
}
public class Exam {    A1 a1= new A1();
    
    private void change(A1 param){
        param.t = 10;  
    }
    
    private void change2(A1 param){
        param = new A1();  //地址改变
        
        param.t = 100;
    }
    
    public static void main(String[] args){
        Exam eg = new Exam();
        
        eg.a1.t = 5;
       
        System.out.println(eg.a1.t);
        
        eg.change(eg.a1);
        
        System.out.println(eg.a1.t);
        
        eg.change2(eg.a1);
        
        System.out.println(eg.a1.t);
    }}, 最后说String，由于它是一个只读类，所以举例如下：String str = "abc";//生成一个对象
       str = "abc"+"def";　　//str的地址改变了，重新生成一个对象内容为"abc"+"def"
                             //然后把该地址赋给str，结合上边例子，应该讲清楚了吧

Answer 16

补充：change（）中虽然传递的说是地址副本，但该地址副本所指向的地址仍然是原来地址，所以一赋值，原来的就改变了。