In programming, there are two ways to pass arguments to a method, pass-by-value
and pass-by-reference:
- When you have a pass-by-value parameter, a copy of the
argument is stored into the memory location allocated for the formal
parameter. In this case, any changes made to the formal parameter inside
the method will not affect the value of the argument back in the
calling method.
- When a parameter is pass-by-reference, the memory
address of the argument is passed to the method, making the formal
parameter an alias for the argument. This means that changes made to the
formal parameter inside the method will be reflected in the value of
the argument when control is returned to the calling function.
Technically, all parameters in Java are pass-by-value.
All primitives are pass-by-value, period. When a primitive value is
passed into a method, a copy of the primitive is made. The copy is what
is actually manipulated in the method. So, the value of the copy can be
changed within the method, but the original value remains unchanged.
For example:
public class TestPassPrimitive {
static void doSomething(int m) {
m = m + 2;
System.out.println("The new value is " + m + ".");
}
public static void main(String[] args) {
int m = 5;
System.out.println("Before doSomething, m is " + m + ".");
doSomething(m);
System.out.println("After doSomething, m is " + m + ".");
}
}
The output result is
Before doSomething, m is 5.
The new value is 7.
After doSomething, m is 5.
Objects, however, work a bit differently. When you pass a Java object
or array as a parameter, an object reference or array reference is
passed into a method. The method can manipulate the attributes of the
object that is referenced by the reference (formal parameter).
This reference is passed-by-value. What does this mean exactly?
- Any direct changes made to the reference (formal
parameter) inside the method will be reflected in the value of the
object back in the calling method;
- If you were to reassigns a new instantiation of an
object or array to the reference (formal parameter) within the method,
the reassignment only affects the copy reference (formal parameter), not
the original reference passed by the caller. After that, any direct
changes made to the reference (formal parameter) inside the method will
be reflected the new reassigned object or array.
The subtleties of passing parameters will become clearer as you write
more and more methods. Experimentation is the best form of learning.
For example:
class TestReferenceParameter{
public static void main (String args[]) {
String s1 = "one";
String s2 = doSomething(s1);
System.out.println(s1 + " " + s2);
}
static String doSomething(String s1) {
s1 = s1 + " two";
System.out.println(s1 + " ");
return "three";
}
}
The output result is
one two
one three