Understanding Pass-by-Value in Java

Course: Core Java Training

Topic: Understanding Pass-by-Value in Java

Course Link: Core Java Training Course

Demo Link: Register for a Course Demo

JustAcademy Homepage: Visit JustAcademy

1. Introduction to Pass-by-Value in Java

Pass-by-value is a fundamental concept in Java that explains how arguments are transferred to method parameters. Whenever a method is called, Java passes a copy of the value of each argument to the corresponding parameter.

This behavior is important when working with primitive data types, objects, arrays, and methods. It helps programmers understand why changing a parameter sometimes does not affect the original variable, while modifying an object's fields can be visible outside the method.

Key principle: Java always uses pass-by-value. For primitive variables, the value itself is copied. For objects and arrays, the reference value is copied, not the entire object or array.

2. Learning Objectives

• Understand the meaning of pass-by-value.
• Differentiate between arguments and parameters.
• Learn how primitive values are passed to methods.
• Understand how object references are passed.
• Differentiate between modifying an object and reassigning a reference.
• Understand pass-by-value behavior with arrays and strings.
• Identify common misconceptions about Java parameter passing.
• Apply pass-by-value concepts to practical Java programs.

3. Understanding Arguments and Parameters

Before learning pass-by-value, it is important to understand arguments and parameters.

• Parameter: A variable declared in a method definition that receives a value.
• Argument: The actual value or expression supplied when a method is called.

Example

public class ParameterExample {
    static void displayNumber(int number) {
        System.out.println(number);
    }

    public static void main(String[] args) {
        displayNumber(25);
    }
}

Output

25

In this example, number is the parameter and 25 is the argument. When the method is called, Java copies the argument's value into the parameter.

4. What Is Pass-by-Value?

Pass-by-value means that a method receives a copy of the value supplied by the caller. The parameter is a separate local variable, so assigning a different value to that parameter does not directly change the caller's variable.

Java applies this rule to all argument types:

• Primitive arguments: The primitive value is copied.
• Object arguments: The reference value is copied.
• Array arguments: The array reference value is copied.

When an object reference is passed, the copied reference can still access the same object. Consequently, changing the object's mutable state can be visible to the caller even though the reference itself was passed by value.

5. Pass-by-Value with Primitive Data Types

Primitive data types in Java include byte, short, int, long, float, double, char, and boolean.

When a primitive variable is passed to a method, Java copies its current value into the parameter. The parameter can be changed independently of the original variable.

Example: Modifying an Integer Parameter

public class PrimitivePassByValue {
    static void changeValue(int number) {
        number = 100;
        System.out.println("Inside method: " + number);
    }

    public static void main(String[] args) {
        int value = 25;

        System.out.println("Before method call: " + value);
        changeValue(value);
        System.out.println("After method call: " + value);
    }
}

Output

Before method call: 25
Inside method: 100
After method call: 25

Step-by-Step Explanation

1. The variable value is initialized with 25.
2. The method call changeValue(value) passes a copy of the value 25.
3. The parameter number receives the copied value.
4. Inside the method, number is changed to 100.
5. The original variable value remains 25.

This example demonstrates that modifying a primitive parameter does not change the original variable in the calling method.

6. Pass-by-Value with Object References

Objects are accessed through reference variables. When an object is passed to a method, Java copies the reference value into the parameter. Initially, the caller's reference and the parameter can refer to the same object.

Because both references can access the same object, the method can modify its mutable fields. Such modifications may be visible to the caller.

Example: Modifying an Object's Field

class Student {
    String name;
}

public class ObjectPassByValue {
    static void changeName(Student student) {
        student.name = "Rahul";
    }

    public static void main(String[] args) {
        Student s = new Student();
        s.name = "Amit";

        System.out.println("Before method call: " + s.name);
        changeName(s);
        System.out.println("After method call: " + s.name);
    }
}

Output

Before method call: Amit
After method call: Rahul

Explanation

1. The variable s refers to a Student object whose name is Amit.
2. The method receives a copy of the reference stored in s.
3. The parameter student and the variable s initially refer to the same object.
4. The statement student.name = "Rahul"; modifies the object's field.
5. When the method returns, s.name is Rahul because the shared object was modified.

Important: Java did not pass the caller's reference variable itself. It passed a copy of its reference value.

7. Reassigning an Object Reference Inside a Method

Modifying an object and reassigning a reference parameter are two different operations. Reassignment makes the local parameter refer to another object, but it does not replace the reference held by the caller's variable.

Example

class Student {
    String name;

    Student(String name) {
        this.name = name;
    }
}

public class ReferenceReassignment {
    static void replaceStudent(Student student) {
        student = new Student("Neha");
        System.out.println("Inside method: " + student.name);
    }

    public static void main(String[] args) {
        Student s = new Student("Amit");

        System.out.println("Before method call: " + s.name);
        replaceStudent(s);
        System.out.println("After method call: " + s.name);
    }
}

Output

Before method call: Amit
Inside method: Neha
After method call: Amit

Explanation

• The caller's variable s refers to the original Student object.
• The method parameter student receives a copy of that reference.
• The statement student = new Student("Neha"); makes only the local parameter refer to a new object.
• The caller's variable s still refers to the original object.
• Therefore, after the method finishes, s.name remains Amit.

8. Modifying an Object vs. Reassigning a Reference

9. Pass-by-Value with Arrays

Arrays are objects in Java. When an array is passed to a method, a copy of the array reference is passed. The method can modify elements in the shared array, but assigning a new array to the parameter does not replace the caller's array.

Example: Updating an Array Element

public class ArrayPassByValue {
    static void updateElement(int[] numbers) {
        numbers[0] = 500;
    }

    public static void main(String[] args) {
        int[] values = {10, 20, 30};

        updateElement(values);

        System.out.println(values[0]);
    }
}

Output

500

The parameter and the original variable refer to the same array, so changing an element affects the shared array.

Example: Reassigning an Array Parameter

public class ArrayReassignment {
    static void replaceArray(int[] numbers) {
        numbers = new int[] {100, 200, 300};
    }

    public static void main(String[] args) {
        int[] values = {10, 20, 30};

        replaceArray(values);

        System.out.println(values[0]);
    }
}

Output

10

The parameter numbers is reassigned to a new array. The caller's variable values still refers to the original array.

10. Understanding Pass-by-Value with Strings

String is a reference type, and String objects are immutable. Once created, a String object's contents cannot be changed. Operations that produce different text return another String rather than modifying the existing object's contents.

Example

public class StringPassByValue {
    static void changeText(String text) {
        text = "Java Programming";
    }

    public static void main(String[] args) {
        String message = "Hello Java";

        changeText(message);

        System.out.println(message);
    }
}

Output

Hello Java

The method parameter is reassigned to another String reference. The caller's variable message remains unchanged.

11. Pass-by-Value with Wrapper Objects

Java wrapper classes, such as Integer, Double, and Boolean, represent primitive values as objects. These classes are immutable, so their values cannot be modified in place.

Example

public class WrapperPassByValue {
    static void changeNumber(Integer number) {
        number = 200;
    }

    public static void main(String[] args) {
        Integer value = 50;

        changeNumber(value);

        System.out.println(value);
    }
}

Output

50

The parameter receives a copy of the reference value. Assigning 200 to the local parameter does not change the caller's variable.

12. How to Exchange Two Variables Using a Method

A common exercise is swapping two variables. A method that accepts two primitive parameters cannot directly swap the caller's primitive variables by changing only its local parameters.

Example: Attempting to Swap Integers

public class SwapExample {
    static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        swap(x, y);

        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}

Output

x = 10
y = 20

The method swaps its local copies of x and y, not the original variables.

A Practical Alternative: Return the Swapped Values

import java.util.Arrays;

public class SwapWithReturn {
    static int[] swap(int a, int b) {
        return new int[] {b, a};
    }

    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        int[] result = swap(x, y);
        x = result[0];
        y = result[1];

        System.out.println(Arrays.toString(new int[] {x, y}));
    }
}

Output

[20, 10]

This approach returns a new array containing the swapped values. The caller then assigns those values to its variables.

13. Using Objects to Share Mutable State

When several operations need to update related data, a mutable object can hold that data. A method can receive a reference value and update the object's fields. This is different from changing the caller's reference variable.

Example: Updating a Bank Account Balance

class BankAccount {
    double balance;

    BankAccount(double balance) {
        this.balance = balance;
    }
}

public class BankAccountExample {
    static void deposit(BankAccount account, double amount) {
        if (amount > 0) {
            account.balance += amount;
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);

        deposit(account, 500);

        System.out.println("Balance: " + account.balance);
    }
}

Output

Balance: 1500.0

The method updates the shared object's state through its copied reference. In real banking applications, monetary calculations should generally use BigDecimal or an appropriate integer-based representation instead of relying on floating-point values.

14. Memory and Reference Concepts

To understand pass-by-value with objects, it helps to distinguish between a reference variable and the object it refers to.

• Reference variable: A variable that holds a reference to an object.
• Object: The instance containing fields and behavior.
• Copied reference: The reference value received by a method parameter.
• Object state: The data stored in the object's fields at a given time.

When a reference is passed to a method, Java does not automatically create a duplicate object. The parameter receives a copied reference value. If both references point to the same mutable object, changes to that object's fields can be observed through either reference.

15. Common Misconceptions

Misconception 1: Java Passes Objects by Reference

Correction: Java passes the reference value by value. The method receives its own copy of the reference.

Misconception 2: Pass-by-Value Means Objects Are Copied

Correction: Passing an object does not automatically create a copy of the object. The reference value is copied.

Misconception 3: A Method Cannot Change an Object

Correction: A method can modify a mutable object's state through a copied reference if it has access to that state.

Misconception 4: Reassigning an Object Parameter Replaces the Caller’s Object

Correction: Reassigning the parameter changes only the local reference variable. The caller's variable continues to hold its original reference.

Misconception 5: Java Uses Pass-by-Reference for Arrays

Correction: Arrays follow the same pass-by-value rule as other objects. Their reference values are copied when passed to methods.

16. Best Practices

• Remember that Java always uses pass-by-value.
• Distinguish between changing a parameter and changing the object it refers to.
• Return a value when a method needs to communicate a new primitive value to the caller.
• Return a replacement object when the caller needs to receive a newly created object.
• Document methods that modify the state of mutable objects.
• Use immutable classes where appropriate to reduce unexpected changes.
• Avoid unnecessary parameter reassignment because it can make code harder to understand.
• Write small examples to trace how primitive variables and references behave.
• Use unit tests to verify the expected behavior of methods that modify objects or arrays.

17. Common Errors and Troubleshooting

18. Practice Exercises

Exercise 1: Primitive Value

Create a method that accepts an integer and changes its parameter to 500. Print the variable before and after the method call and explain the output.

Exercise 2: Object Modification

Create a Car class with a color field. Pass a Car object to a method and change its color. Observe the value after the method call.

Exercise 3: Object Reassignment

Pass a Car object to a method and reassign the parameter to a new Car object. Check whether the caller's variable refers to the new object.

Exercise 4: Array Update

Pass an integer array to a method and update its first element. Explain why the caller sees the change.

Exercise 5: Array Reassignment

Write a method that assigns a new array to its parameter. Check whether the caller's array reference changes.

Exercise 6: Return a New Value

Write a method that accepts a number, increases it by ten, and returns the result. Store the returned value in the caller's variable.

19. Interview Questions and Answers

Q1. What is pass-by-value in Java?

Answer: Pass-by-value means Java passes a copy of an argument's value to the method parameter.

Q2. Is Java pass-by-value or pass-by-reference?

Answer: Java is always pass-by-value. When an object is passed, the copied value is its reference.

Q3. Why does changing a primitive parameter not change the original variable?

Answer: The parameter is a separate local variable containing a copy of the primitive value.

Q4. Can a method modify an object passed to it?

Answer: Yes. If the object is mutable, the method can modify its state through the copied reference, and the caller may observe that modification.

Q5. What happens when an object parameter is reassigned?

Answer: Only the local parameter refers to the new object. The caller's reference variable remains unchanged.

Q6. Does Java create a copy of an object when passing it to a method?

Answer: No. Java copies the reference value, not the object itself.

Q7. Why can a method modify an array's elements?

Answer: The copied reference can access the same array as the caller's reference. Changing an element modifies that shared array.

Q8. How can a method communicate a changed primitive value?

Answer: It can return the calculated value, which the caller can assign to its variable.

Q9. Are String objects passed by reference?

Answer: No. Java passes a copy of the String reference. Because String objects are immutable, their contents cannot be changed after creation.

Q10. Can Java swap two primitive variables through a normal method call?

Answer: Not by changing only the method's primitive parameters. The method can return the swapped values for the caller to assign.

20. Quick Revision Checklist

• Java always uses pass-by-value.
• Primitive arguments are passed as copied primitive values.
• Object and array arguments are passed as copied reference values.
• Reassigning a parameter does not reassign the caller's variable.
• Modifying a shared mutable object can affect what the caller observes.
• Strings are immutable.
• Return values allow methods to communicate calculated or replacement values.
• Understanding the distinction between references and objects helps prevent programming errors.

21. Conclusion

Pass-by-value explains how Java methods receive arguments. For primitive types, the primitive value is copied. For objects and arrays, the reference value is copied, allowing a method to access the same object without receiving the caller's reference variable itself.

The most important distinction is between modifying an object's state and reassigning a parameter. Once this difference is clear, it becomes easier to understand method behavior, avoid common mistakes, and write reliable Java applications.

Continue strengthening your programming skills through the Core Java Training Course, register for a course demo, or visit the JustAcademy homepage.