Pass-by-Value Parameter Passing

Pass-by-value is a mechanism where a copy of the actual parameter's value is passed to the function's formal parameter. This ensures that the function operates on a local copy, isolating the original data from modifications performed within the function.

Key Characteristics of Pass-by-Value

• Copy Creation: The function receives a duplicate of the argument's value in a distinct memory location (typically the stack frame).
• Independent Variables: The formal parameter inside the function and the actual argument outside are separate entities. Altering the formal parameter has no impact on the original argument.
• Primitive Data Types: In languages like Java, primitive types (int, boolean, double, char) are invariably passed by value.
• Memory Overhead: For large data structures, copying the entire value can introduce memory and performance overhead.
• Reference Copies: When applied to object references, it's the reference value (the memory address) that is copied, not the object itself. Both references point to the same object, but the reference variables themselves are independent.
• Effect on Objects: While you cannot change which object the original reference points to from within the function, you can modify the internal state of the shared object via its reference copy, leading to side effects.

Example: Modifying a Primitive Value

class ValuePassingDemo {
    public static void main(String[] args) {
        int originalValue = 15;
        updateNumber(originalValue); // Passes a copy of the value 15
        System.out.println("Original Value: " + originalValue); // Prints: Original Value: 15
    }

    // The parameter 'input' receives a local copy of the passed value
    static void updateNumber(int input) {
        input = 100; // Modifies only the local copy
    }
}

Explanation: The method updateNumber receives a duplicate of originalValue. Changing the local variable input to 100 does not affect the variable originalValue in the main method.

---

Pass-by-Reference Parameter Passing

Pass-by-reference involves passing the memory address (reference) of an argument to the function. The formal parameter becomes an alias for the original argument, allowing direct modification.

Key Characteristics of Pass-by-Reference

• Alias Creation: The formal parameter inside the function is another name for the original argument, accessing the same memory.
• Direct Modification: Changes made to the formal parameter directly affect the original argument.
• No Copying: Since only an address is passed, large object are not duplicated, which is memory efficient.
• Language Support: Languages like C++ support true pass-by-reference (e.g., using &). Note that Java does not support pass-by-reference for variables; it only has pass-by-value.
• Object References: In Java, what is often perceived as pass-by-reference is actually pass-by-value where the value being passed is an object reference. The reference is copied, but both the original and the copy point to the same object, enabling state modification.

Example: Modifying an Object's State (Simulating Reference-like Behavior)

class ObjectStateModification {
    public static void main(String[] args) {
        Employee emp = new Employee("Charlie", 50000);
        adjustSalary(emp); // Passes a copy of the reference to the 'emp' object
        System.out.println("Employee: " + emp.name + ", Salary: " + emp.salary); // Prints: Employee: Charlie, Salary: 75000
    }

    // The parameter 'employeeRef' holds a copy of the reference, pointing to the same object
    static void adjustSalary(Employee employeeRef) {
        employeeRef.salary = 75000; // Modifies the state of the shared object
        // employeeRef = new Employee("Diana", 90000); // This assignment would NOT affect the original 'emp' reference
    }

    static class Employee {
        String name;
        double salary;

        Employee(String name, double salary) {
            this.name = name;
            this.salary = salary;
        }
    }
}

Explanation: The adjustSalary method receives a copy of the reference emp. Both references point to the same Employee object. Changing the object's salary field through the employeeRef parameter is visible via the original emp reference. How ever, reassigning the parameter employeeRef to a new Employee object would only affect the local copy of the reference, not the original emp variable.

Critical Distinction

In Java, all arguments are passed by value. For objects, the value that is passed is the reference (the pointer). This leads to a common point of confusion:

• You cannot change what object the original reference variable points to from within a method (true pass-by-value behavior).
• You can change the state (fields) of the object that the reference points to, because you are operating on the same object through a copied reference.