Java Pass-by-Value

The Fundamental Rule

Java is ALWAYS pass-by-value. There is no pass-by-reference in Java.

• Primitives: The actual value is copied
• References: The reference (address) is copied, not the object

This is the #1 Java misconception. Many developers believe Java passes objects by reference, but it doesn't.

public class PassByValueRule {
    public static void main(String[] args) {
        int x = 10;
        changePrimitive(x);
        System.out.println(x);  // 10 (unchanged)
        
        int[] arr = {1, 2, 3};
        changeArray(arr);
        System.out.println(arr[0]);  // 999 (changed!)
    }
    
    static void changePrimitive(int val) {
        val = 999;  // Changes local copy only
    }
    
    static void changeArray(int[] array) {
        array[0] = 999;  // Changes the object via copied reference
    }
}

Key insight: When you pass a reference, Java copies the reference. The method gets a copy of the reference, pointing to the same object.

Passing Primitives

When you pass a primitive, the value is copied. The method works with a local copy.

public class PrimitiveDemo {
    public static void main(String[] args) {
        int a = 5;
        double b = 3.14;
        boolean c = true;
        
        increment(a);
        System.out.println(a);  // Still 5!
        
        modify(b, c);
        System.out.println(b);  // Still 3.14!
        System.out.println(c);  // Still true!
    }
    
    static void increment(int x) {
        x++;  // Only changes local copy
    }
    
    static void modify(double d, boolean flag) {
        d = 100.0;
        flag = false;
        // Changes are lost when method returns
    }
}

Why primitives can't be modified:

• The method receives a copy on the stack
• Changes affect only the local stack frame
• Original value remains untouched
• No way to modify the caller's variable

Passing References

When you pass an object, the reference is copied. The method gets a copy of the reference, pointing to the same object.

public class ReferenceDemo {
    public static void main(String[] args) {
        Person p = new Person("Alice");
        
        // Reference 'p' is copied to changeName()
        changeName(p);
        System.out.println(p.name);  // "Bob" (changed!)
        
        // But we can't change what 'p' points to
        resetPerson(p);
        System.out.println(p.name);  // Still "Bob"
    }
    
    static void changeName(Person person) {
        // person is a COPY of 'p', but same object
        person.name = "Bob";  // Modifies the object
    }
    
    static void resetPerson(Person person) {
        person = new Person("Charlie");  // Only changes local copy
        // 'p' in main still points to original object
    }
}

Two things you can do with a reference:

1. Modify the object (via the copied reference) ✓
2. Change what the reference points to ✗ (only affects local copy)

The 'Pass by Reference' Misconception

Many developers think Java passes objects by reference because modifications to objects persist. This is wrong.

public class MisconceptionDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        
        // This WORKS - looks like pass by reference
        modifyArray(arr);
        System.out.println(arr[0]);  // 999
        
        // But THIS doesn't - proves it's pass by value
        int[] newArr = {4, 5, 6};
        replaceArray(newArr);
        System.out.println(newArr[0]);  // Still 4, not 7
    }
    
    static void modifyArray(int[] array) {
        array[0] = 999;  // Modifies via copied reference
    }
    
    static void replaceArray(int[] array) {
        array = new int[]{7, 8, 9};  // Only changes local copy!
        // Caller's reference is unchanged
    }
}

Proof it's pass by value:

1. If Java had pass by reference, replaceArray() would change newArr
2. But newArr still points to {4, 5, 6}
3. This proves the reference was copied (pass by value)

The confusion:

• Pass by value: copy of value/reference
• Pass by reference: alias (same variable)
• Java copies the reference → pass by value

The Swap Method Proof

The classic proof that Java is pass-by-value:

public class SwapProof {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        swap(a, b);  // Pass by value - swap won't work!
        
        System.out.println("a = " + a);  // Still 10
        System.out.println("b = " + b);  // Still 20
    }
    
    static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
        // x and y are local copies
        // a and b are unchanged
    }
}

If Java were pass by reference:

• x would be an alias for a
• y would be an alias for b
• Swapping x and y would swap a and b
• But it doesn't!

What actually happens:

Before swap:  a=10, b=20
After call:   x=10, y=20 (copies)
After swap:   x=20, y=10 (local copies swapped)
Back in main: a=10, b=20 (unchanged)

To swap objects, return them:

static int[] swap(int a, int b) {
    return new int[]{b, a};
}

int[] result = swap(x, y);
x = result[0];
y = result[1];

Key takeaway: Java copies the reference, not the object. This is pass-by-value.