🚚 Pass By Value vs Pass By Reference in Java — The Great Confusion Buster 💣

 

💬 “I changed the object inside a method. But when I came back… NOTHING happened.
Java, are you even listening to me?!” 😡

That was me. Screaming at my screen.

So I decided to dig deep: What’s really going on?

Let’s go from basics → to bugs → to JVM internals → to truth 💡

---

🎯 What People Think Java Does:

public void change(int x) {
    x = 10;
}

“Cool, this is pass-by-value. Just a copy. I get it.” ✅

But then...

public void update(User u) {
    u.setName("Anand");
}

“Wait, it changed outside! That must be pass-by-reference!” ❓

And then...

public void update(User u) {
    u = new User("NewGuy");
}

“Now it DIDN’T change outside?!  Java, are you drunk?” 🍺

---

🧠 Truth Bomb: Java is Always Pass-by-Value. No Exceptions.

Even for objects.

But here's the tricky twist:

📌 Java passes a copy of the reference when dealing with objects.

So you're not passing the object directly —
You're passing a copy of the pointer to the object.

---

🔍 Code Time!

🔹 Example 1: Primitives — True Pass-by-Value

public void change(int x) {
    x = 10;
}
int a = 5;
change(a);
System.out.println(a); // prints 5 ❌ no change
📦 Memory (Stack Only — Primitives)
Stack:
-----------
| a = 5     |   // main method variable
-----------
| x = 5     |   // method receives a copy
-----------

Inside method:
x = 10;   // Only updates local copy. No effect on 'a'
🧠 What happened? Java passed the value 5 to x, changed x to 10, but a is untouched.
🔹 Example 2: Object Reference – Mutating Object

public void update(User u) {
    u.setName("Anand");
}
User user = new User("Old");
update(user);
System.out.println(user.name); // prints "Anand" ✅ changed
📦 Memory (Stack + Heap)

Stack:                         Heap:
----------                   -------------------
| user  |  ----ref---->      | User object       |
----------                   | name = "Old"      |
                             -------------------

Inside method:
----------                   -------------------
|  u   |  ----ref---->       | same User object  |
----------                   -------------------

After u.setName("Anand"):

Heap:
-------------------
| name = "Anand"   | ✅ updated!
-------------------
🧠 What happened? Java passed a copy of the reference. You didn’t change the reference — you modified the object it points to. So changes are visible outside.
🔹 Example 3: Object Reference – Reassigning Object

public void update(User u) {
    u = new User("NewGuy");
}
User user = new User("Old");
update(user);
System.out.println(user.name); // prints "Old" ❌ no change
📦 Memory (Stack + Heap)

Before reassignment:
Stack:                         Heap:
----------                   -------------------
| user  |  ----ref---->      | User object       |
----------                   | name = "Old"      |
                             -------------------

Inside method:
----------                   -------------------
|  u   |  ----ref---->       | same User object  |
----------                   -------------------

Now we do: u = new User("NewGuy");

After reassignment:

Stack:
----------                   -------------------        -------------------
|  u   | --ref-->           | User("NewGuy")     | ✅ new object
----------                   -------------------        -------------------
                              
BUT...

user in main() still points to:
-------------------
| name = "Old"      | ❌ unchanged
-------------------
🧠 What happened? You created a new object inside the method and made u point to it — but user in the calling method is still pointing to the old one.
 

---

🤔 Why Java Did This? Internals and Design Reasons

Java designers chose pass-by-value for simplicity and predictability.

• No dangling pointers

• No accidental object sharing

• Easy GC (Garbage Collection)

• No real pointer arithmetic mess like in C++

🔐 Java hides pointers from us — but under the hood, everything is still pointer logic.

---

🤪 Silly Questions We’ve All Asked

❓Can Java ever do pass-by-reference?
Nope. Not even on Sundays. 🙅‍♂️

❓Then how can I simulate it?
Wrap it in another object (e.g., Holder<T> or an array):

void swap(int[] arr) {
    int temp = arr[0];
    arr[0] = arr[1];
    arr[1] = temp;
}

❓So when I change object fields — it works. But when I reassign, it doesn’t?

Yes. Welcome to Pass-by-Reference Confusion Club™

---

🔥 Real Bug from a Production App

public void reset(Config c) {
    c = new Config(); // thought this reset everything
}

The dev thought this resets the config across the app.
But it only changed the local reference.
The global config stayed stale. 🤦‍♂️

Fix:

public void reset(Config c) {
    c.clear(); // actually mutate the object
}

---

🎨 Wrapping Up 

Concept	Java Does?	What Happens
Pass-by-Value (primitive)	✅	A copy of the value is passed
Pass-by-Value (object reference)	✅	A copy of the reference (pointer) is passed
Pass-by-Reference (like in C++)	❌	Not possible

🔍 So next time someone says:

“Java passes objects by reference!”

You say:

“Nah bro. Java passes references by value — big difference!” 😏

---

💡 Final Tip for Interviews:

Interviewer:

“Is Java pass-by-reference or pass-by-value?”

You:

“Always pass-by-value. Even for objects — Java passes a copy of the reference. That’s why mutations work, but reassignments don’t.”

Mic drop. 🎤

Stay curious, stay nerdy,
– Anand 🚀