Altering passed parameters in Java (call by ref,value)

Question

Hi,

I actually thought that I had a good idea of how passing values in Java actually work, since that was part of the SCJP cert which I have passed. That was until today, when I at work discovered a method like this:

public void toCommand(Stringbuffer buf) {

  buf.append("blablabla");
}

Then the caller of that method used the function like this:

StringBuffer buf = new StringBuffer();
toCommand(buf);
String str = buf.toString();

Now I thought that that code would give str the value "", but it actually give it the value from the mehod. How is this possible? I thought things didnt work like that in Java?

Either way... it should be considered a bad practice to write code like this in Java, right? Because I can imagine it can bring some confusion with it.

I actually spent some time searching on this, but my interpretation of what these sources are saying, is that it shouldnt work. What am I missing?

http://www.yoda.arachsys.com/java/passing.html
http://javadude.com/articles/passbyvalue.htm

Sebastian

Answer 1

str has the value "blablabla" because a reference to the StringBuilder instance is passed to toCommand().

There is only one StringBuffer instance created here - and you pass a reference to it to the toCommand() method. Therefore any methods invoked on the StringBuffer in the toCommand() method are invoked on the same instance of the StringBuffer in the calling method.

Answer 2

StringBuffer is mutable. The toCommand() method gets a reference to that objects which is passed by value (the reference), the reference allows the method to change the mutable StringBuffer.

If you are thinking about why we cannot do this with String it is because String is immutable in which case it will result in the creation of another String object and not having the changes reflected in the object of which the reference is passed.

And I don't see why it should be bad practice.

Answer 3

It is not always bad practise. Consider the task to assemble an email, then you could do something like:

 StringBuilder emailBuilder = new StringBuilder();
 createHeader(emailBuilder);
 createBody(emailBuilder);
 createFooter(emailBuilder);
 sendEmail(emailBuilder.toString());

It surely could be used to create confusion and for public API one should add a note or two to the javadoc, if the value at the passed reference is changed.

Another prominent example from the Java API:

Collections.sort(list);

And as other already explained and just to complete the answer: The value of the reference of the StringBuffer (<-- start using StringBuilder instead!) is passed to toCommand so outside and inside the toCommand method you access the same StringBuffer instance.

Answer 4

Since you get a reference to the instance you can call all the methods on it, but you can't assign it to anything else.

public void toCommand(Stringbuffer buf) {
    buf.append("blablabla"); // okay
    buf = new Stringbuffer(); // no "effect" outside this method
}

Answer 5

When you pass an object to a method, unlike in C++, only the reference to the object gets copied. So when a mutable object is passed to the method, you can change it and the change gets reflected in the calling method. In case you're too much into C/C++ programming, you should know that in java, pass by reference(in C++ lingo) is the default(and the only) way of passing arguments to methods.

Answer 6

This is because the in the method, when you pass an object, a copy of a reference to the object is passed by value. Consider the example below:

    public class Test {

     public static void modifyBuff(StringBuffer b)   {
        b.append("foo");
     }

     public static void tryToNullifyBuff(StringBuffer b)   {
        b = null; // this will not affect the original reference since 
                  // the once passed (by value) is a copy
     }


     public static void main(String[] args) {
        StringBuffer buff = new StringBuffer();  // buff is a reference 
                                                 // to StringBuffer object

        modifyBuff(buff);

        System.out.println(buff); // will print "foo"

        tryToNullifyBuff(buff); // this has no effect on the original reference 'buff'

        System.out.println(buff); // will still print "foo" because a copy of 
                                  // reference buff is passed to tryToNullifyBuff() 
                                  // which is made to reference null 
                                 // inside the method leaving the 'buff' reference intact
     }
}

This can be done with other mutable objects like Collection classes for example. And this is not at all a bad practice, in fact certain designs actively use this pattern.

Answer 7

Just in response to some of the comments about the SCJP (sorry don't have permissions to leave comments - apologies if leaving an answer is not the right way to do this).

In defence of the SCJP exam, passing object references as method parameters AND the differences between immutable String objects and StringBuffer / StringBuilder objects are part of the exam - see sections 3.1 and 7.3 here:

http://www.javadeveloper.co.in/scjp/scjp-exam-objectives.html

Both topics are covered quite extensively in the Kathy Sierra / Bert Bates study guide to the exam (which is the de facto official study guide to the exam).