Java: Pass by Reference or Pass by Value? – Explained

Java is always pass-by-value, NOT by reference. (Remember – Java pass by value)

Unfortunately, we never handle an object at all, instead of juggling object handles called references (which are passed by value of course).

The chosen terminology and semantics easily confuse many beginners.

This will give you some insights into how Java really works to the point that in your next discussion about Java passing by reference or passing by value you’ll just smile

Step one please erase from your mind that word that starts with ‘p’ “_ _ _ _ _ _ _”, especially if you come from other programming languages. Java and ‘p’ cannot be written in the same book, forum, or even text.

Step two remember that when you pass Object into a method, you’re passing the Object reference and not the Object itself.

• Student: Master, does this mean that Java is pass-by-reference?
• Master: Grasshopper, No.

Now think of what an Object’s reference/variable does/is:

1. A variable holds the bits that tell the JVM how to get to the referenced Object in memory (Heap).
2. When passing arguments to a method you ARE NOT passing the reference variable, but a copy of the bits in the reference variable. Something like this: 3bPd086a. — 3bPd086a represents a way to get to the passed object.
3. So you’re just passing 3bPd086a, which is the value of the reference.
4. You’re passing the value of the reference and not the reference itself (and not the object).
5. This value is actually COPIED and given to the method.

Now, Compile/execute the below program in your mind or on your console.

Person person;
person = new Person("Tom");
changeName(person);
//I didn't use Person person below as an argument to be nice
static void changeName(Person anotherReferenceToTheSamePersonObject) {
  anotherReferenceToTheSamePersonObject.setName("Jerry");
}

What just happened here?

• The variable person is created in line #1 and it’s null at the beginning.
• A new Person Object is created in line #2, stored in memory, and the variable person is given the reference to the Person object. That is its address. Let’s say 3bPd086a.
• The variable person holding the address of the Object is passed to the function in line #3.
• On line #4 you can listen to the sound of silence
• Check the comment on line #5
• A method local variable –anotherReferenceToTheSamePersonObject– is created and then comes the magic in line #6:
• The variable/reference person is copied bit-by-bit and passed to anotherReferenceToTheSamePersonObject inside the function.
• No new instances of Person are created.
• Both “person” and “anotherReferenceToTheSamePersonObject” hold the same value of 3bPd086a.
• Don’t try this but person==anotherReferenceToTheSamePersonObject would be true.
• Both variables have IDENTICAL COPIES of the reference and they both refer to the same Person Object, the SAME Object on the Heap, and NOT A COPY.

One picture is worth a thousand words.

Note that the anotherReferenceToTheSamePersonObject arrows is directed towards the Object and not towards the variable person!

If you didn’t get it then just trust me and remember that it’s better to say that Java is pass by value. Well, pass by reference value. Oh well, even better is pass-by-copy-of-the-variable-value! 😉

Now feel free to hate me but note that given this there is no difference between passing primitive data types and Objects when talking about method arguments.

You always pass a copy of the bits of the value of the reference!

• If it’s a primitive data type these bits will contain the value of the primitive data type itself.
• If it’s an Object the bits will contain the value of the address that tells the JVM how to get to the Object.

Java is pass-by-value because inside a method you can modify the referenced Object as much as you want but no matter how hard you try you’ll never be able to modify the passed variable that will keep referencing (not p _ _ _ _ _ _ _) the same Object no matter what!

And

The changeName function above will never be able to modify the actual content (the bit values) of the passed reference. In other word changeName cannot make Person person refer to another Object.

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    // we pass the object to foo
    foo(aDog);
    // aDog variable is still pointing to the "Max" dog when foo(...) returns
    aDog.getName().equals("Max"); // true
    aDog.getName().equals("Fifi"); // false
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // change d inside of foo() to point to a new Dog instance "Fifi"
    d = new Dog("Fifi");
    d.getName().equals("Fifi"); // true
}

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    foo(aDog);
    // when foo(...) returns, the name of the dog has been changed to "Fifi"
    aDog.getName().equals("Fifi"); // true
    // but it is still the same dog:
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // this changes the name of d to be "Fifi"
    d.setName("Fifi");
}

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 modify 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");
     }

}

Foo f = new Foo("f");

public static void changeReference(Foo a)

changeReference(f);

Foo b = new Foo("b");