Passing Objects to Methods in Java

Objects are passed to methods exactly the same way primitive values are, yet the outcome looks different: changes made to an object's fields inside a method are visible to the caller, while changes to a primitive parameter are not. Let's see why that happens, where this rule stops working the way beginners expect, and how a method returns an object.

Pass by Value or Pass by Reference?

Java always passes arguments by value. For a primitive parameter the value itself is copied (10, 3.14, true). For an object parameter the reference is copied — the address of the object on the heap, not the object itself.

That is exactly why the copied reference still points to the very same object: through it the method can change the object's state, and everyone holding a reference to that object sees the change. In everyday conversation this model is often described as "objects are passed by reference". It is a convenient shortcut, but it is not accurate, and in an interview it is worth spelling out.

Example 1. Changing a Primitive and an Object in a Method

When the program starts, a frame is allocated on the stack for the main() method, and the local variables x and y live there. Calling changePrimitives() creates one more stack frame with its own local variables a and b — copies of the passed values. Modifying a and b has no effect on x and y: they are different memory cells.

The local variable box is created on the stack of main() too, but the Box object itself lives on the heap. What changeObject() receives is a copy of the reference pointing at that same object. So assigning to box.width, box.height and box.depth inside the method changes the object on the heap, and the result is visible back in main():

public class Box {
    double width;
    double height;
    double depth;

    Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }
}

public class TestDemo {

    // Changes the state of the object: the caller sees the new values
    static void changeObject(Box box) {
        box.width *= 2;
        box.height /= 2;
        box.depth += 2;
    }

    // Changes copies of the values: the caller sees nothing
    static void changePrimitives(int a, int b) {
        a *= 2;
        b /= 2;
    }

    public static void main(String[] args) {
        Box box = new Box(5, 6, 7);

        int x = 10;
        int y = 10;
        System.out.println("x and y before method invocation: " + x + " " + y);
        changePrimitives(x, y);
        System.out.println("x and y after method invocation: " + x + " " + y);

        System.out.println("box before method invocation: " + box.width + " " + box.height + " " + box.depth);
        changeObject(box);
        System.out.println("box after method invocation: " + box.width + " " + box.height + " " + box.depth);
    }
}

Program output:

x and y before method invocation: 10 10
x and y after method invocation: 10 10
box before method invocation: 5.0 6.0 7.0
box after method invocation: 10.0 3.0 9.0

Where Intuition Breaks Down: Reassigning a Parameter

If objects really were passed by reference, assigning a brand new object to the parameter inside the method would also change the caller's variable. In Java it does not: only the local copy of the reference is reassigned, while the original variable keeps pointing at the old object.

public class ReassignDemo {

    // A new object is assigned to the parameter - nothing changes outside
    static void reassign(Box box) {
        box = new Box(1, 1, 1);
        box.width = 100;
    }

    // The state of the received object is modified - the change is visible outside
    static void mutate(Box box) {
        box.width = 100;
    }

    public static void main(String[] args) {
        Box first = new Box(5, 6, 7);
        reassign(first);
        System.out.println("after reassign: " + first.width);

        Box second = new Box(5, 6, 7);
        mutate(second);
        System.out.println("after mutate: " + second.width);
    }
}

Program output:

after reassign: 5.0
after mutate: 100.0

The table below answers the only question that really matters here: will the calling method see the change?

Arrays, String and StringBuilder

An array in Java is an object as well, so a method that receives an array can change its elements and the caller will see the new values. String, on the other hand, is immutable: the statement text += " Java" inside a method builds a new string and assigns it to the local parameter, leaving the original untouched. If a string has to grow inside a method, use StringBuilder or return the result:

public class ArrayStringDemo {

    static void fill(int[] numbers) {
        numbers[0] = 42;            // an array is an object, so the change is visible outside
    }

    static void addSuffix(String text) {
        text += " Java";            // a new string is created, the original stays the same
    }

    static void addSuffix(StringBuilder text) {
        text.append(" Java");       // the same object is modified
    }

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        fill(numbers);
        System.out.println("numbers[0]: " + numbers[0]);

        String text = "Hello";
        addSuffix(text);
        System.out.println("text: " + text);

        StringBuilder builder = new StringBuilder("Hello");
        addSuffix(builder);
        System.out.println("builder: " + builder);
    }
}

Program output:

numbers[0]: 42
text: Hello
builder: Hello Java

By the way, the two addSuffix() methods with different parameter types are an example of method overloading: the compiler picks the right version from the type of the argument.

Example 2. Returning an Object from a Method

Methods can not only accept objects but also create them and hand them back. What is returned is a reference to the object on the heap — the object itself is never copied. The method incrementByTen() leaves the current object alone and produces a new one with a larger field value:

public class ReturnObjectExample {
    int a;

    ReturnObjectExample(int i) {
        a = i;
    }

    ReturnObjectExample incrementByTen() {
        ReturnObjectExample temp = new ReturnObjectExample(a + 10);
        return temp;
    }

    public static void main(String[] args) {
        ReturnObjectExample ob1 = new ReturnObjectExample(2);
        ReturnObjectExample ob2 = ob1.incrementByTen();
        System.out.println("ob1.a: " + ob1.a);
        System.out.println("ob2.a: " + ob2.a);
    }
}

Program output:

ob1.a: 2
ob2.a: 12

The intermediate variable temp is optional here — the body can be written as a single line: return new ReturnObjectExample(a + 10);. An object created inside a method does not disappear when the method ends: it stays on the heap as long as at least one reference to it exists, and only then becomes eligible for garbage collection.

Key Takeaways

• Java passes arguments by value only: a primitive's value is copied, an object's reference is copied.
• Changing the state of an object inside a method is visible to the calling code.
• Assigning a new object to the parameter is not visible to the calling code.
• Arrays and collections behave like the mutable objects they are; String, Integer and other immutable types cannot be "changed" through a parameter.
• A method can create an object and return a reference to it — the object is not copied on return.