In Java parameter passing, what do pass by value and pass by reference mean, and how does Java actually pass arguments to methods?

Introduction / Context:
The terms pass by value and pass by reference come from classic programming language theory and describe how arguments are delivered to methods or functions. Many Java beginners are confused about whether Java is pass by value or pass by reference, especially when working with objects. Interviewers like this question because it reveals whether you truly understand how Java parameters and references behave in memory during method calls.

Given Data / Assumptions:

• Java has primitive types such as int and double, and reference types such as objects and arrays.
• Methods can take these types as parameters.
• Changes to parameters inside a method may or may not affect the caller, depending on what is changed.
• We need to relate these behaviors to the definitions of pass by value and pass by reference.

Concept / Approach:
Pass by value means that the method receives a copy of the actual argument value held by the caller. Modifying the parameter variable inside the method does not change the caller variable, because they are separate copies. Pass by reference means the method receives a direct alias or reference to the caller variable itself, so assignments could affect the caller. Java always uses pass by value. For primitive parameters, the primitive value is copied. For object parameters, the reference value is copied, meaning both the caller and the method parameter refer to the same underlying object, but the reference variable itself inside the method is a separate copy that can be reassigned without affecting the caller variable.

Step-by-Step Solution:
Step 1: Consider a primitive parameter int x. When a method is called, the value stored in the caller variable is copied into the parameter x. Step 2: Changing x inside the method does not change the original variable in the caller, proving pass by value for primitives. Step 3: For an object parameter, such as MyClass obj, the reference stored in the caller variable is copied into the parameter obj. Step 4: Inside the method, you can modify the state of the object through obj, and those changes are visible to the caller because both references point to the same object. Step 5: However, if you reassign obj to a new object inside the method, that reassignment does not change the caller variable reference, demonstrating that the reference itself was still passed by value.

Verification / Alternative check:
Simple experiments confirm this model. If you pass a primitive and reassign the parameter, the caller variable remains unchanged. If you pass an ArrayList and add elements inside the method, the caller sees the new elements because the same list object is shared. But if you assign the parameter to a new ArrayList inside the method, the caller still points to the original list. This combination of behaviors is perfectly explained by Java using pass by value for both primitives and reference values.

Why Other Options Are Wrong:
Option B is incorrect because Java never passes direct aliases to local variables that would allow reassignment to change the caller variable itself. Option C is wrong because it suggests that Java uses two different passing models depending on the type, which is not true; the unified rule is pass by value. Option D is clearly incorrect since Java language specification precisely defines argument passing and does not randomize behavior at runtime.

Common Pitfalls:
A common pitfall is saying that Java is pass by reference because changes to object state appear in the caller. This is actually due to passing a copy of the reference value, not pass by reference semantics. Another mistake is believing that reassigning a parameter reference will change the caller variable, which often leads to confusing bugs. Remembering that Java always passes a copy of the value, whether that value is a primitive or an object reference, helps avoid these misunderstandings.

Final Answer:
Pass by value means the method receives its own copy of the argument value, and Java always uses pass by value, even when the value being copied is an object reference that points to a shared object.