java是按值传递的,不是按址传递的。
所以,你那种做法bb是不会变的。

解决方案 »

  1.   

    public class test{
        int x = 0;
        public void change(int a){
            a=1;
        }
        public test(){
            change(x);
            system.out.println(x);
        }
    }
    试试上面的代码吧。他能证明我的说法!
      

  2.   

    参数传递是copy的。原参数不变
      

  3.   

    还是给你说详细点:java 字符串的构造有 两种:1.  直接用文字构造:
      
        String  s = "用文字构造”;
        
        java编译器自动会为每个文字生成一个 String 对象的实例,以上语句实际上相当于嫁了一个新的字符串对象,并初始化为:"用文字构造”,然后将该对象地址的地址付给字符串对象s。2.使用String 类构造   String();
       String(String object);
       等等。
      

  4.   

    我知道 值传递.
    starr0110:整型肯定没问题.
    我的意思是.书上说字符串和数组都是对象,是传引用,
    String aa;
            String bb;
            aa="hahaha";
            bb=aa;
            aa="xxxxx";
    把aa的引用传给了bb
     所以最后bb的结果也应该是 " xxxxxx"
    但实际运行结果却没变
      

  5.   

    我这么跟你说吧:Java中的变量有两种,一种是值类型,一种是引用类型。传递值类型的参数时,这个值被copy一份传递到方法内部。传递引用类型的参数时,这个引用也会copy一份传递到方法内部。注意,如果方法内部修改的是这个引用,那么原来的变量(包括其引用的对象)都不变,如果方法内部是通过这个引用修改了它引用的对象,那么原来的那个对象就会真的被改变了。Java中引用的概念和C++的引用不太一样,这里的引用是"指针语意的引用",或者说弱引用。
      

  6.   

    String 是不会改变的,要改变用StringBuffer
    http://expert.csdn.net/Expert/topic/3063/3063668.xml?temp=.5077936
      

  7.   

    具体到楼主的例子:String aa;
    String bb;
    aa="hahaha"; // 这个aa现在指向的是"hahaha"这个对象
    bb=aa;       // 现在bb也指向那个"hahaha"对象
    aa="xxxxx";  // aa指向了新的"xxxxx"对象,这个过程中并没有修改bb
      

  8.   

    楼主一定要注意:Java中的引用不同于C++中的引用(类似int& a这样的东东)!!
      

  9.   

    关键回答
    aa="xxxxx"不代表hahaha被xxxxx覆盖,即hahaha还是存在的,不然bb指向什么地方呢?而是一个new String.也就是传值
            aa="hahaha"; aa指向hahaha,bb没有指向
            bb=aa;       aa,bb指向hahaha
            aa="xxxxx";  aa指向xxxxx,bb指向hahaha
      

  10.   

    aa="xxxxx"; 
    这一句修改的是引用(你可以想象成地址),而不是(在那个地址的)对象。
      

  11.   

    看来要仔细讲一讲了:
    首先你要知道String类型本身是不可变的,一旦初始化赋值以后就不可改变:
    看你的代码:
    String aa;
            String bb;
            aa="hahaha";
            bb=aa;//注意这里,其实bb并不是指向aa,而是aa,bb同时指向字符串"hahaha"
            aa="xxxxx";//执行这句后,aa指向了"xxxxxx",因为字符串本身不可变,于是系统新创建了一个对象,让aa指向它,而原来的对象依然存在,bb依然指向"hahaha"现在明白了吗?不要以为
    bb = aa ;就是说明bb指向aa,真实情况是bb指向aa当时指向的东西如果换成StringBuffer你的程序就是对的,因为StringBuffer是可改变的
    你用aa.replace(i,j,"xxx")代替aa="xxxxxx"肯定可以得出aa和bb是同样的结果
      

  12.   

    moke33(勤奋的菜鸟) 对象如果重新赋值,以前那个值会不会保留呢?
    我用一个对象来做这个例子
    结果是跟着改变了tt gg,hh;
            gg=new tt();
            hh=new tt();
            gg.you=50;
            gg.me=60;
            hh=gg;
            gg.you=80;
            gg.me=90;tt是我定义的一个类.
      

  13.   

    看来楼主没有弄清楚reference:String aa;  //这是一个reference
            String bb;//这也是一个reference
    //这两个reference没有与任何对象建立关联
            aa="hahaha";//赋值号右边是个String对象,reference指向它
            bb=aa;//bb现在也指向aa指向的对象
            System.out.println(aa + " " + bb);//aa,bb指向同一个String对象
            aa="xxxxx";//右边又是一个新的对象,reference指向新对象,bb指向的对象没有变!
           System.out.println(aa + " " + bb);//aa,bb各指向一个对象  所以,输出是:
        hahaha hahaha
        xxxxx hahaha
      

  14.   

    我这样理解对不对?:
    声明一个对象时: xxxx aa; 存储器里划了一块存了个地址,就是将来要用来引用的地址
    创建时:aa=new xxxx(); 存储器里在另外一个地方根据xxxx的定义划了一大块地址用来存储对象的域和方法;
    再具体赋值时,就把刚才那块存储区填好数据.
    在调用对象变量名时,实际上是调用声明时分配的那个存储块,传给某个方法并改变其值时,只是改变了这个地址的指向?
      

  15.   

    对象如果重新赋值,以前那个值会不会保留呢?
    我用一个对象来做这个例子
    结果是跟着改变了tt gg,hh;
            gg=new tt();
            hh=new tt();
            gg.you=50;
            gg.me=60;
            hh=gg;
            gg.you=80;
            gg.me=90;tt是我定义的一个类./////////////////////////////////////////////////////////////////////楼主可以再好好看看我前面的帖子。这里你是通过引用改变了具体的对象,而不是修改引用本身。
      

  16.   

    FileNewExit((呵呵)) 
    用你刚才的解释来解释这段:tt gg,hh;
            gg=new tt();
            hh=new tt();
            gg.you=50;
            gg.me=60;
            hh=gg;
            gg.you=80;
            gg.me=90;tt是我定义的一个类.
    最后结果  tt.you 和tt.me应该是 50\60,但结果是80\90
      

  17.   

    sean_gao(大胃) hh=gg;这也是直接修改引用吧,我觉得
    我发现我问题的关键就是
    什么是直接修改引用什么是通过引用修改引用的对象值
      

  18.   

    hh本来是没有指向任何对象
    hh=gg后指向了gg指向的那个对象
    (这一步确实是修改了引用本身,但不是我说的关键)
    后来你怎么用的hh来着?
    你通过hh.me和hh.you这样修改了对象的me和you字段,对吧?
    由于hh和gg指向同一个对象
    自然gg指向的对象就是刚刚被修改的那个对象。
      

  19.   

    你直接写hh=什么什么,就是修改引用。
    你写hh.什么什么,就是对对象的操作。
      

  20.   

    tt gg,hh;//两个reference
            gg=new tt();//与对象(叫做对象1吧)关联
            hh=new tt();//与对象(叫做对象2吧)关联
            gg.you=50;  //修改对象1的you
            gg.me=60;   //修改对象1的me
            hh=gg;      //现在,hh指向gg指向的对象,hh原来指向的对象2现在没有谁指向了
            gg.you=80;  //修改对象1的you
            gg.me=90;   //修改对象1的me//你说结果该是多少?
      

  21.   

    sean_gao(大胃) 进一步缩小范围:
    你说
            gg.you=80;
            gg.me=90;
    你通过hh.me和hh.you这样修改了对象的me和you字段,对吧?
    由于hh和gg指向同一个对象
    自然gg指向的对象就是刚刚被修改的那个对象。但之前aa="xxxxx";
    我是不是也可以说修改了 aa, 由于bb和aa都指向同一字符串对象所以......哎,我怎么还是没明白
      

  22.   

    不是的.你可能和C搞混了.//C++ code
    string*  s1 = new string("hello");
    string*  s2 = s1;
    (*s1) += " world";
    cout<<*s1<<endl<<*s2<<endl;
    return  0;
    //s1 = s2 = "hello world" //Java progamming language code
    String s1 = "hello";
    String s2 = s1;
    s1 += " world";
    System.out.println(s1 + "\n" + s2);
    //s1 = "hello world" and  s2 = "hello"再看一下这段代码,可能会对你有点帮助://Java programming language code
    String s1 = "hello";
    String s2 = s1;
    System.out.println("s1 = " + s1
                       + "; s2 = " + s2);
    System.out.println("System.identityHashCode(s1) = "
                       + System.identityHashCode(s1));
    System.out.println("System.identityHashCode(s2) = "
                       + System.identityHashCode(s2));s1 += " world";
    System.out.println("\ns1 = " + s1
                       + "; s2 = " + s2);
    System.out.println("System.identityHashCode(s1) = "
                       + System.identityHashCode(s1));
    System.out.println("System.identityHashCode(s2) = "
                       + System.identityHashCode(s2));Here's the output: 
    s1 = hello; s2 = hello
    System.identityHashCode(s1) = 2452092
    System.identityHashCode(s2) = 2452092s1 = hello world; s2 = hello
    System.identityHashCode(s1) = 7474923
    System.identityHashCode(s2) = 2452092在加如了" world"之后,s1 指向了一个新的地址.
      

  23.   

    String aa;
            String bb;
            aa="hahaha";
            bb=aa;
            aa="xxxxx"; 字符串既然是一个对象,在bb=aa;时就只是把aa的地址给了bb,从而在aa 改变时,bb 也应该改变吧,教材上是这么说的
    但实际情况是bb不变,怎么回事?
    你的理解有误 
    “在bb=aa;时就只是把aa的地址给了bb”这句话是不对地bb=aa 并不是把aa的地址给了bb,而是为bb创建了一个指向aa所引用的对象"hahaha"的一个引用此时aa和bb引用了同一个对象"hahaha" "从而在aa 改变时,bb 也应该改变"也是不对的
    应该是aa指向的对象改变时,bb指向的对象也改变(因为本身就是同一个对象)
    当在执行aa="xxxxx";时 此时aa断开了对"hahaha"的引用而指向了另一个对象"xxxxx"此时bb则仍然引用"hahaha" 
      

  24.   

    你通过aa="xxxxx";这样的语句试图修改的是引用而不是引用指向的对象。这个动作符合我说的>>>你直接写hh=什么什么,就是修改引用。<<<因此对象是没有变的。// bb还是指向原来那个没有改变的对象。//////////////////////////////////////////////////////////////////////////还不明白的话,我实在也想不出更好的办法让你明白了。
      

  25.   

    String对象是一个Java语言比较特殊的类,它的值是不可改变的.
    任何对它的操作(追加,替换,删除等)将重新生成一个新对象,原来的对象(主要是它的值)将会自动保存一段时间(如果较短时间内有要求生成同值的对象,就会让新对象指向这个匿名的对象;如果在一定时间内没有这样的要求,最后会被自动回收).
    ==============================================================================
    而其它对象(如自定义的对象)与String对象不同,它是允许被修改的(如楼主的tt,gg,hh的例子)
      

  26.   

    给你举个例子:
    class Number {
      int i;
    }public class Assignment {
      public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        n1.i = 9;
        n2.i = 47;
        System.out.println("1: n1.i: " + n1.i +
          ", n2.i: " + n2.i);
        n1 = n2;
        System.out.println("2: n1.i: " + n1.i +
          ", n2.i: " + n2.i);
        n1.i = 27;
        System.out.println("3: n1.i: " + n1.i +
          ", n2.i: " + n2.i);
      }
    }
      

  27.   

    yaray(雅睿,生活在别处,工作在别墅) 
    你的话终于让我基本明白了
    String对象是一个Java语言比较特殊的类,它的值是不可改变的.
    而其它对象(如自定义的对象)与String对象不同,它是允许被修改的(如楼主的tt,gg,hh的例子)
    这句话特别清楚.