don't understand

[fengqiao cao]

hi, there
could you explain to me in detail the outcome of following code(i am pretty new to java)?

public class TestBuffer {
     public void myBuf( StringBuffer s, StringBuffer s1) {
            s.append(" how are you") ;
            s = s1;
     }
     public static void main ( String args[] ) {
             TestBuffer tb = new TestBuffer();
              StringBuffer s = new StringBuffer("Hello");
              StringBuffer s1 = new StringBuffer("doing");
              tb.myBuf(s, s1);
              System.out.print(s);
      }
}

[Dave Vick]

fengqiao
This question was asked just last week here at this thread. If you have any let us know and we'll help you out.

------------------
Dave
Sun Certified Programmer for the Java� 2 Platform

[fengqiao cao]

Dave
thanks a lot. Finally, i got it. ( method append()change the object itself, but reference assignment just provide a handler to an object, the object itself not being affected at all.)

[Anonymous]

Hi,
Food for thought...What if your objects were of type String instead of its peer StringBuffer?...This piece of code might help.

<font>
public class TestBuffer {
    public void myBuf(String s, String s1) {
      s+= ", How are you";
      System.out.println("Temp Object created as a result of string concatenation : " + s);
      s = s1;
      System.out.println(s);
      }
    public static void main(String args[]) {
      TestBuffer tb = new TestBuffer();
      String s = new String("Hello");
      String s1 = new String("doing");
      tb.myBuf(s, s1);
      System.out.print(s);
    }
}
</font>

Hope this helps
Shyam

[fengqiao cao]

hi Shyamsundar
i have difficulty on understanding of the first output. could you explain to me? The secod is "doing" and third one is "hello"( string is immutable).

thank you very much.

[Anonymous]

Hi, I've invoked my artistic abilities... ...Do tell me if you need further explanation.

<font size = 2>                  
                  
In the case of String (In my program)
                           (intitally)    (intitally)
               [s] (original) ---> {Hello} <--- [s] (Function Parameter)
                                              /  |  [STEP 1]
                                             /   | (After s+= operation. Since String
                                            /    |  objects are immutable, a NEW temporary
                                           /     |  object is formed as shown below. But 
                                  [STEP 2]/      |  the original object pointed by [s] is                                     
                                         /       |  untouched and it is printed at the end.
                                        /        |  In the second step, however, the reference
                                       /         |  is assigned a different value.This value 
                                      /          |  eventually gets printed within the method.)
                                     /   {Hello} + {, How are you}--->(This is the temp object created)
                                    /
               [s1](original) ---> {doing} <--- [s1](Function Parameter)

In the case of StringBuffer (In your program)
              
                [s] (original) ---> {Hello} <--- [s] (Function Parameter)
                 \            (Just passed)     / |                                                                
                  \                            /  |
                   \___________________|______/   |        
                                |      |A         | (STEP 2: s = s1 within method. Link marked A gets broken.
   (After appending, Step 1)    |                 |  This change is not visible outside the method. The original
                                |                 |   [s] still points to {Hello, How are you}.)
                       {Hello, How are you}       |
   [In Step 1, when we make changes to the        |
    object pointed by the Function Parameter,     |   
    (which is the same as the object being        | 
    pointed by the original parameter)            |
    NO NEW OBJECT IS CREATED because StringBuffer |  
    objects are mutable, meaning they can be      | 
    changed contrary to String objects. This is   |
    reflected in the final print statement.]      |     
                                                  |
                [s1](original) ---> {doing} <--- [s1](Function Parameter)
</font>

Hope this helps
Shyam

[This message has been edited by Shyamsundar Gururaj (edited October 29, 2001).]