Pass by Value vs. Pass by Reference in Java

Java developers often debate whether the language uses pass by value or pass by reference. The answer is clear: Java is strictly pass by value. However, confusion arises when working with objects. Let’s break down how Java handles parameter passing for primitives and objects, debunk myths, and clarify common misunderstandings.

Key Definitions

1. Pass by Value

• A copy of the variable’s value is passed to the method.
• Changes to the copy do not affect the original variable.

2. Pass by Reference

• The memory address of the variable is passed to the method.
• Changes to the parameter directly modify the original variable.

Java Does NOT Support Pass by Reference.

Java’s Strict Pass by Value Rule

Example 1: Primitives (Pass by Value)

Primitives pass a copy of their value. Modifying the parameter inside the method has no effect on the original.

public class Main {  
    public static void main(String[] args) {  
        int num = 10;  
        modifyPrimitive(num);  
        System.out.println(num); // Output: 10 (unchanged)  
    }  

    static void modifyPrimitive(int value) {  
        value = 20; // Only the local copy changes  
    }  
}  

Output:

The output of the above code will be: 10

Example 2: Objects (Pass by Value of the Reference)

When passing objects, a copy of the reference (memory address) is passed:

• Modifying the object’s state (e.g., changing a field) affects the original.
• Reassigning the reference (e.g., obj = new Object()) does not affect the original.

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

public class Main {  
    public static void main(String[] args) {  
        Dog myDog = new Dog("Radha");  
        modifyObject(myDog);  

        System.out.println(myDog.name); // Output: Krishna (state changed)  
    }  

    static void modifyObject(Dog dogRef) {  
        dogRef.name = "Krishna"; // Modifies the original object  
        dogRef = new Dog("Shyam"); // Reassigns the local copy (original unchanged)  
    }  
}  

Output:

The output of the above code will be: Krishna

Why People Think Java Uses Pass by Reference

1. Object State Changes Are Visible:
   • If you modify an object’s fields (e.g., dogRef.name = "Krishna"), the original object reflects the change.
2. Misunderstanding References:
   • The method receives a copy of the reference, not the original reference itself.

Immutable Objects (e.g., String)

Immutable objects behave like primitives because their state cannot change. Reassigning them inside a method has no effect outside:

public static void main(String[] args) {  
    String name = "Radha";  
    modifyString(name);  
    System.out.println(name); // Output: Radha (unchanged)  
}  

static void modifyString(String str) {  
    str = "Krishna"; // Creates a new String; original reference unchanged  
}  

Common Pitfalls and Solutions

1. Trying to Swap Primitive Values

Mistake:

void swap(int a, int b) { ... } // Useless; primitives are pass by value  

Fix: Return a result or use wrapper classes (e.g., int[]).

2. Reassigning Object References

Mistake:

void resetList(List<String> list) {  
    list = new ArrayList<>(); // Original reference outside remains unchanged  
}  

Fix: Modify the existing object (e.g., list.clear()).

Key Takeaways

1. Java is Pass by Value: Always.
2. Primitives: Copies of values are passed.
3. Objects: Copies of references (memory addresses) are passed.
   • Object state changes are visible outside the method.
   • Reference reassignments are not visible.
4. No Pass by Reference: Java does not allow direct memory manipulation.

Conclusion

Understanding pass by value in Java is critical for debugging and writing predictable code. While objects may appear to behave like pass by reference, Java’s strict pass by value rule ensures developers maintain control over data flow.