Call By Value in Java

Why Mutating Fields "Looks Like" Pass-by-Reference

Because the copied reference points to the same heap object, calling a method that changes the object's fields through that reference (e.g. obj.setName("New")) really does change the object the caller sees — there is only one object, and both the caller's reference and the parameter's reference point to it. This is the source of the confusion: people see the caller's object change and assume Java passed the object itself. In reality, Java passed a copy of the pointer to that one shared object.

Why Reassigning the Parameter Does Not Affect the Caller

Reassigning the parameter inside the method (e.g. param = new Employee("Someone Else")) only changes what the local copy of the reference points to. It does not — and cannot — reach back and change the caller's original variable, because the caller's variable is a completely separate copy of the reference. Once the method returns, the caller's variable still points to the original object, unaffected by the reassignment.

Primitives vs Objects — the Same Rule, Two Effects

The underlying rule never changes: a copy of the value is passed. It only looks different because a primitive's "value" is the data, while an object variable's "value" is an address. Keeping this single mental model — "always a copy of the value, and for objects that value is an address" — resolves nearly every confusing case you will encounter with method parameters in Java.

• Passing a primitive: the method gets a copy of the number; changes to the parameter never affect the caller's variable.
• Passing an object and mutating its fields: both references point to the same object, so the change is visible to the caller.
• Passing an object and reassigning the parameter: only the local copy of the reference changes; the caller's reference is untouched.

What Happens in Memory During a Call

Each method call gets its own stack frame, and every parameter is a brand-new local variable in that frame. When the call starts, Java copies the argument's value into the parameter. When the call ends, the frame and all its parameters are thrown away. Objects live separately on the heap, so they survive the call. That is why a change made through a reference outlives the method, while a change made to the parameter variable itself disappears with the frame.

The Classic Test: Why a swap Method Fails

A swap(int a, int b) method that exchanges its two parameters looks correct but changes nothing for the caller, because it only swaps the two local copies. The same is true for swap(Employee a, Employee b): it swaps the copied references, not the caller's variables. To swap for real, swap the contents of something both sides share, such as two elements of the same array, or return the result.

Strings and Wrapper Types Look Like Primitives

String, Integer and the other wrapper classes are objects, so a copy of the reference is passed. They are also immutable: no method can change them in place. Something like text = text + "!" builds a new String and points only the local copy at it, so the caller still sees the original. A mutable type such as StringBuilder behaves differently, because append changes the one object both references share.

How to Get a Changed Value Back to the Caller

Since a method can never rebind the caller's variable, pick one of these instead:

• Return the new value and let the caller store it (score = addBonus(score);). This is the clearest option and the usual choice.
• Change a shared mutable object, such as a field of an object, an array element or a collection, when updating that object is the method's job.
• Return a small result object or record when a method needs to hand back several values at once.

Examples

class Employee {
    String name;
    Employee(String name) { this.name = name; }
}

public class CallByValueDemo {

    static void mutateField(Employee e) {
        e.name = "Changed Inside Method"; // same object, so caller sees this
    }

    static void reassignReference(Employee e) {
        e = new Employee("Brand New Object"); // only the local copy of the reference changes
    }

    static void changePrimitive(int value) {
        value = value + 100; // only the local copy changes
    }

    public static void main(String[] args) {
        Employee emp = new Employee("Original");
        mutateField(emp);
        System.out.println(emp.name); // field mutation IS visible

        reassignReference(emp);
        System.out.println(emp.name); // reassignment is NOT visible

        int score = 10;
        changePrimitive(score);
        System.out.println(score); // primitive change is NOT visible
    }
}

Changed Inside Method
Changed Inside Method
10

public class SwapDemo {
    static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp; // swaps the local copies only
    }

    static void swapInArray(int[] values) {
        int temp = values[0];
        values[0] = values[1];
        values[1] = temp; // changes the one array both references point to
    }

    public static void main(String[] args) {
        int x = 1, y = 2;
        swap(x, y);
        System.out.println("After swap: x = " + x + ", y = " + y);

        int[] pair = {1, 2};
        swapInArray(pair);
        System.out.println("After swapInArray: " + pair[0] + ", " + pair[1]);
    }
}

After swap: x = 1, y = 2
After swapInArray: 2, 1

public class StringParamDemo {
    static void addMark(String text) {
        text = text + "!"; // builds a new String; only the local reference moves to it
    }

    static void addMark(StringBuilder text) {
        text.append("!"); // changes the one StringBuilder the caller also points to
    }

    public static void main(String[] args) {
        String greeting = "Hello";
        addMark(greeting);
        System.out.println(greeting);

        StringBuilder builder = new StringBuilder("Hello");
        addMark(builder);
        System.out.println(builder);
    }
}

Hello
Hello!

public class ReturnValueDemo {
    static int addBonus(int score) {
        return score + 100; // hand the new value back instead of changing the parameter
    }

    public static void main(String[] args) {
        int score = 10;
        addBonus(score);              // result ignored, score unchanged
        System.out.println(score);
        score = addBonus(score);      // caller chooses to store the result
        System.out.println(score);
    }
}

10
110

Exercise

This swap method does nothing useful: the program prints 1 2 because the method only swaps its own copies. Change the program so the two values really are swapped, by passing an array and swapping its elements.

Expected output: 2 1

public class SwapDemo {

    static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        swap(x, y);
        System.out.println(x + " " + y);
    }
}

public class SwapDemo {

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

    public static void main(String[] args) {
        int[] values = {1, 2};
        swap(values);
        System.out.println(values[0] + " " + values[1]); // 2 1
    }
}

Quick quiz

Interview questions