Pass by Value in Java

#Introduction

One of the most confusing and frequently asked Java interview questions is:

Is Java Pass by Value or Pass by Reference?

Many developers answer: "Primitive types are Pass by Value and Objects are Pass by Reference."

❌ This is incorrect. The correct answer is:

Java is 100% Pass by Value.

Whether you pass a primitive variable or an object, Java always passes a copy of the value. The confusion arises because, for objects, the value being copied is the reference (memory address), not the object itself.

#What is Pass by Value?

Pass by Value means a copy of the variable's value is passed to the method.

Any modification inside the method affects only the copied value. The original variable remains unchanged.

#Pass by Value with Primitive Types

public class Demo {

    static void change(int x) {
        x = 100;
    }

    public static void main(String[] args) {
        int number = 10;
        change(number);
        System.out.println(number);
    }
}

10

Memory Representation

#Pass by Value with Objects

class Employee {
    String name;
}

Employee emp = new Employee();
emp.name = "John";

Method:

static void update(Employee e) {
    e.name = "David";
}

Calling:

update(emp);

David

Many people think Java passed the object by reference. It did not. Java passed a copy of the reference.

Memory Diagram

Changing object state with e.name = "David"; updates the shared object.

#Reassigning the Reference

static void change(Employee e) {
    e = new Employee();
    e.name = "Alice";
}

Main:

Employee emp = new Employee();
emp.name = "John";
change(emp);
System.out.println(emp.name);

John

Why? Because only the copied reference changed. The original reference still points to the original object.

Memory Representation

#Primitive vs Object

Java is Pass by Value in both cases.

#String Example

static void change(String s) {
    s = "Spring";
}

String str = "Java";
change(str);
System.out.println(str);

Java

Reason: Strings are immutable. A new String object is created, and the original reference is unaffected.

#Array Example

static void modify(int[] arr) {
    arr[0] = 99;
}

int[] numbers = {10, 20, 30};
modify(numbers);
System.out.println(numbers[0]);

99

Array contents changed because both references point to the same array.

Reassigning Array

static void reset(int[] arr) {
    arr = new int[]{1, 2, 3};
}

The original array remains unchanged. Only the copied reference changed.

#Wrapper Class Example

static void increment(Integer x) {
    x++;
}

Main:

Integer value = 10;
increment(value);
System.out.println(value);

10

Reason: wrapper classes are immutable. x++ creates a new Integer, and the original reference is unchanged.

#Mutable Object Example

static void append(StringBuilder sb) {
    sb.append(" Boot");
}

StringBuilder builder = new StringBuilder("Spring");
append(builder);
System.out.println(builder);

Spring Boot

Reason: StringBuilder is mutable. Both references point to the same object.

#Why the Confusion?

People observe:

employee.name = "David";

and think Java passed the object itself. Actually, Java copied the reference value. Both references point to the same object. The object changes, not the reference.

#Real Project Examples

Service Layer

updateEmployee(employee);

The service modifies the employee object. The caller sees updated values because both references point to the same object.

DTO

request.setUsername("John");

The method changes object state. The original object reflects the changes.

Collections

addEmployee(list);

The method adds elements. The caller sees the updated list.

#Pass by Value vs Pass by Reference

Java supports only Pass by Value.