Passing by reference in Java

[Amy Adams]

Hello,
For basic types as int, char. Passing by value. For objects, passing by value of the reference (by abuse of language, passed by reference).
Here is the code

str = mstr "Hello";
exchange(mstr);
System.out.println(mstr);
 
void exchange(str unstr)
{
   unstr = Goodbye;
}

So, if any one can explain me then it would be great. Thanks in advance.

[InterNetWorKed]

Hello,
See, this code

void exchange(String unstr)

Has the appeal of the method changes (mstr), the reference of the object is referenced by mstr fill in the local variable to the method that is the parameter unstr
See here

unstr = Goodbye;

You replaced the reference in unstr by reference to the string constant "goodbye". The variable mstr is in no way affects the reference and storage on the same subject before.

[Windowed]

Hello,
In your method changes when you do

unstr = "goodbye"

you change just the value of the parameter "unstr", which is a copy of mstr. So obviously, you do not change mstr

void exchange(unclassmutbl subject) {
    object.setQuelqueChose(newValeur());
}

Here for cons, you change the contents of the object passed as parameter (but there is no setter on the String class (because String is immutable), you can not change its value).

[GlassFish]

Hello,
Passing by value means "passing by copying the value." So when you pass an object you pass a copy of the reference, and if that reference is changed that does not impact the reference of the calling code (the new reference exists in the method body).
By cons, if the object is changed, so there it works:

void exchange(StringBuffer strbuf)
	{
		strbuf.delete(0Sb.length()); / / We erase all
		strbuf.append(Goodbye);
	}

And see this code

		StringBuffer mstr = New StringBuffer("Hello");
exchange(mstr);
System.out.println(mstr);

[NetWorkInG]

Hello,
Otherwise if you have not been changed, you can always do something like that

str = mstr "Hello";
Object[] t = New Object[] {mstr};
exchange(t);
mstr = t[0];
System.out.println(mstr);
 
void exchange(Object[] t)
{
   t[0] = Goodbye;
}

This is somewhat hidden misery but sometimes there is no alternative

[SoftWore]

Hello,
Or they choose a gender approach to CORBA:

class GenericHolder <T>
{
  public T val;

  public GenericHolder(T aval)
  {
    val = aval;
  }
}

But in general it is preferable to avoid this kind of transition parameters. It's not for nothing that AC was not included in the Java language.