String passed into method

[soni29]

hi,
i had a question about the following program:

class StringTest {
String strTest = new String("Hello!");
public static void main(String args[]) {
StringTest obj = new StringTest();
obj.Display();
}

void Display() {
System.out.println("Before call " + strTest);
Update(strTest);
System.out.println("After call " + strTest);
}

void Update(String strString) {
System.out.println("In update method before " + strString);
strString = new String("Bye!");
System.out.println("In update method after " + strString);
}
}

why is it that at the end it prints: After call Hello! i changed the
reference in the method correct? i know String's are immutable but
doesn't the reference change in the method Update? as if i wrote
something like:

class Temp {
public static void main(String args[]) {
Temp obj = new Temp();
obj.CallMe();
}
void CallMe() {
String strName = new String("Name");
System.out.println(strName);
strName = new String("No Name");
System.out.println(strName);
}
}

in which case at the end it will print out No Name, since the
reference of the variable strName has now changed?

Thank you.

 

[Darryl L. Pierce]

soni29 wrote:

<snip>

First off, String is an immutable class. You cannot change the value of a
String object.

Secondly, Java does not pass-by-reference. It, instead, does a
pass-reference-by-value. IOW, the value of the reference that you're
passing to the method as an argument is itself *copied* and the method is
using that copy to reference you object.

As such, you can pass a reference to a String object in a method call, but
the invoked method, if it attempts to change the value, will instead be
working on a whole new String object. When the method exits, the original
reference value is unchanged. And, since it's unchanged, it's pointing to
the same String object as before the call.

 

[Esoteric]

what he says is true, but you could fix it by doing it like this:

class StringTest {
String strTest = new String("Hello!");
public static void main(String args[]) {
StringTest obj = new StringTest();
obj.Display();
}

void Display() {
System.out.println("Before call " + strTest);
strTest = Update(strTest); // <== changed
System.out.println("After call " + strTest);
}

String Update(String strString) { // <== changed return type from void to
String
System.out.println("In update method before " + strString);
strString = new String("Bye!");
System.out.println("In update method after " + strString);
return strString; // <== added return
}
}

hope this helps
owen.

 

[Darryl L. Pierce]

what he says is true, but you could fix it by doing it like this:

class StringTest {
String strTest = new String("Hello!");
public static void main(String args[]) {
StringTest obj = new StringTest();
obj.Display();
}

void Display() {
System.out.println("Before call " + strTest);
strTest = Update(strTest); // <== changed
System.out.println("After call " + strTest);
}

String Update(String strString) { // <== changed return type from void
to String
System.out.println("In update method before " + strString);
strString = new String("Bye!");
System.out.println("In update method after " + strString);
return strString; // <== added return
}
}

hope this helps

This assumes that the argument passed by Display() to Update() is a property
of the enclosing class. If, instead, it's just an argument and not a class
property, then making it a field is a bad design choice.

Also, my example highlights why he won't be able to do the same *between
classes* as well. Giving him a work-around in one class won't highlight the
underlying reason.

 

[Thomas Schodt]

This might not be the best way of doing it
but it demonstrates that an array of one element
allows you to pass back a new Object.


class StringTest {
String strTest = new String("Hello!");
public static void main(String args[]) {
StringTest obj = new StringTest();
obj.Display();
}

void Display() {
System.out.println("Before call " + strTest);
Update(strTest);
System.out.println("After call " + strTest);
}

void Update(String strString) {
System.out.println("In update method before " + strString);
strString = new String("Bye!");
System.out.println("In update method after " + strString);
}
}

 

[Thomas Schodt]

This might not be the best way of doing it
but it demonstrates that an array of one element
allows you to pass back a new Object.

class StringTest {
String[] strTest = { "Hello!" };
public static void main(String args[]) {
StringTest obj = new StringTest();
obj.Display();
}

void Display() {
System.out.println("Before call " + strTest[0]);
Update(strTest);
System.out.println("After call " + strTest[0]);
}

void Update(String[] strString) {
System.out.println("In update method before " + strString[0]);
strString[0] = new String("Bye!");
System.out.println("In update method after " + strString[0]);
}
}

 

[nos]

don't you mean "pass back a reference to a new object"?

 

[Darryl L. Pierce]

This might not be the best way of doing it
but it demonstrates that an array of one element
allows you to pass back a new Object.

Ack! Unless the method receiving the argument can and will use an array,
it's poor design to pass an array just to get around the reference-by-value
constraint. If you're seriously in need of passing a mutable object, pass
StringBuffer, not an array.

 

[Thomas Schodt]

don't you mean "pass back a reference to a new object"?

^_^

Yes, that was what I meant.