What Is Call By Reference And Call By Value In Java?

In Java, all arguments are passed by value, without exception.

There is no "call by reference" in the language, though the behavior with objects can often be mistaken for it. The key distinction lies in the type of value being copied: for primitives, it's the data itself, and for objects, it's a copy of the object's memory address (a reference).

What is call by value?

In call by value, a method receives a copy of the argument's value. Any changes made to this copied value within the method do not affect the original variable in the calling method.

Case 1: Primitives (e.g., int, double, boolean)

When you pass a primitive type to a method, a new copy of the primitive's value is created on the stack for the method's parameter.

Example:

public class PassByValueExample {
    public static void main(String[] args) {
        int num = 10;
        System.out.println("Before method call: " + num); // Prints 10
        changePrimitive(num);
        System.out.println("After method call: " + num);  // Prints 10
    }
    public static void changePrimitive(int value) {
        value = 20; // This changes only the local copy
        System.out.println("Inside method: " + value); // Prints 20
    }
}

Use code with caution.

Explanation:

1. In the main method, num is initialized to 10.
2. When changePrimitive(num) is called, the value 10 is copied into the value parameter.
3. Inside changePrimitive, the local parameter value is changed to 20. This has no effect on the original num variable in the main method.

The object reference illusion: Why it seems like call by reference

The confusion around Java's parameter passing arises when dealing with objects. In this case, Java is still passing by value, but the value being copied is the object's reference, which is the memory address of the actual object.

Case 2: Objects

When an object is passed to a method, a copy of the object reference is passed. Both the original variable and the method's parameter will hold a reference to the exact same object in the heap memory. This means:

• Modifying the object's state: If the method changes the state (e.g., a field) of the object using the copied reference, those changes will be visible to the caller. This is because both references point to the same object.
• Reassigning the reference: If the method reassigns its parameter to a new object, this will not affect the original reference in the calling method. The parameter's reference will simply point to a different object, while the caller's reference remains unchanged.

Example:

class Dog {
    String name;
    Dog(String name) { this.name = name; }
}
public class PassByReferenceIllusion {
    public static void main(String[] args) {
        Dog myDog = new Dog("Max");
        System.out.println("Before method call (name): " + myDog.name); // Prints "Max"
        changeDogName(myDog);
        System.out.println("After changeDogName (name): " + myDog.name); // Prints "Fifi"
        reassignDog(myDog);
        System.out.println("After reassignDog (name): " + myDog.name); // Still prints "Fifi"
    }
    // Modifies the object's state, visible to the caller
    public static void changeDogName(Dog dog) {
        dog.name = "Fifi";
    }
    // Reassigns the local reference, not visible to the caller
    public static void reassignDog(Dog dog) {
        dog = new Dog("Buddy");
        System.out.println("Inside reassignDog (name): " + dog.name); // Prints "Buddy"
    }
}

Use code with caution.

Explanation:

1. Initially, myDog is a reference pointing to a Dog object with the name "Max".
2. changeDogName(myDog) is called. The reference is copied, so both myDog and the dog parameter point to the same object. The dog.name = "Fifi" line modifies the actual object on the heap, so myDog.name also reflects this change.
3. reassignDog(myDog) is called. The reference is again copied. The line dog = new Dog("Buddy") creates a new Dog object. The local dog parameter is now updated to point to this new object, but the original myDog variable still points to the first Dog object.

Pass by reference vs. Pass by value: Summary

Conclusion

The definitive answer is that Java is strictly pass-by-value. The confusion stems from a crucial distinction in what "value" means for different data types. For primitives, the value is the data itself. For objects, the value is the reference (memory address), so when this reference is passed by value, multiple variables end up pointing to the same underlying object. Understanding this mechanism is vital for predicting how methods will interact with different types of data in Java.