There has been a lot of debate on whether “java is pass by value or pass by reference?“. Well, let us conclude last time, Java is passed by value and not pass-by-reference. If it had been pass-by-reference, we should have been able to C like swapping of objects, but we can’t do that in java. We know it already, right?
1. Java is Pass-by-value
When you pass an object to a method, its memory address is copied bit by bit to a new reference variable, thus both pointing to the same instance. But if you change the reference inside the method, the original reference will not change.
If Java was pass-by-reference, then it would have got changed also.
To prove it, let’s see how memory allocations happen in run time. It should solve the slightest doubts if any. I am using the following program for demonstration of the concept.
public class Foo
{
private String attribute;
public Foo (String a){
this.attribute = a;
}
public String getAttribute() {
return attribute;
}
public void setAttribute(String attribute) {
this.attribute = attribute;
}
}
public class Main
{
public static void main(String[] args){
Foo f = new Foo("f");
changeReference(f); // It won't change the reference!
modifyReference(f); // It will change the object that the reference variable "f" refers to!
}
public static void changeReference(Foo a) {
Foo b = new Foo("b");
a = b;
}
public static void modifyReference(Foo c) {
c.setAttribute("c");
}
}
2. Analysis
Let us see what happens on runtime step by step when the above program runs:
Foo f = new Foo("f");
This statement will create an instance of class Foo, with ‘attribute’ initialized to ‘f’. The reference to this created instance is assigned to variable f;

public static void changeReference(Foo a)
When this executes then a reference of type Foo with a name a is declared and it’s initially assigned to null.

changeReference(f);
As you call the method changeReference(), the reference a will be assigned to the object which is passed as an argument.

Foo b = new Foo("b"); //inside first method
This will do exactly the same as in the first step, and will create a new instance of Foo, and assign it to b;

a = b;
This is an important point. Here, we have three reference variables, and when the statement executes, a and b will point to the same instance created inside the method. Note: f is unchanged, and it is continually pointing to instance, it was pointing originally. NO CHANGE !!

modifyReference(Foo c);
Now when this statement executed a reference, c is created and assigned to the object with attribute “f”.

c.setAttribute("c");
This will change the attribute of the object that reference c points to it, and the same object that reference f points to it.

I hope that this explanation was clear enough to make your understanding better if it was not already.
Happy Learning !!
Leave a Reply