Java Pass By Value | Basics of Java - Software Development PDF Download

Introduction

When programming in Java, it's crucial to understand the concept of "pass by value." While it may sound complex at first, this article aims to explain it in simple terms. We'll explore what pass by value means, how it affects Java methods, and provide several examples to illustrate the concept. By the end, you'll have a clear understanding of how Java handles data passing.

Understanding Pass By Value

In Java, arguments are passed to methods by value. This means that when you pass a variable to a method, a copy of the variable's value is made and passed to the method. The original variable remains unchanged. Let's examine this concept with some examples:
Example 1: Passing a primitive type

public class PassByValueExample {

    public static void main(String[] args) {

        int num = 10;

        System.out.println("Before method call: " + num);

        modifyPrimitive(num);

        System.out.println("After method call: " + num);

    }

    

    public static void modifyPrimitive(int value) {

        value = 20;

        System.out.println("Inside method: " + value);

    }

}

Output

Before method call: 10

Inside method: 20

After method call: 10

Explanation:

• In this example, we have a variable num with a value of 10.
• We pass num to the modifyPrimitive method.
• Inside the method, we assign a new value of 20 to the value parameter.
• However, notice that the change does not affect the original num variable outside the method.

Example 2: Passing an object reference

public class PassByValueExample {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("Hello");

        System.out.println("Before method call: " + sb);

        modifyReference(sb);

        System.out.println("After method call: " + sb);

    }

    

    public static void modifyReference(StringBuilder builder) {

        builder.append(" World!");

        System.out.println("Inside method: " + builder);

    }

}

Output

Before method call: Hello

Inside method: Hello World!

After method call: Hello World!

Explanation

• In this example, we have a StringBuilder object named sb with the value "Hello".
• We pass the sb object reference to the modifyReference method.
• Inside the method, we modify the object by appending " World!" to it.
• Notice that the change to the object is reflected both inside and outside the method.

Key Takeaways

• Java is pass by value, which means when we pass arguments to a method, a copy of the value is made.
• Changes made to the copy of the value inside the method do not affect the original variable outside the method.
• When passing objects as arguments, the reference to the object is passed by value, allowing modifications to the object.

Sample Problems

Write a method that takes two integers as arguments and swaps their values. Verify if the swapping is reflected outside the method.

public class SwapExample {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        

        System.out.println("Before swapping: a = " + a + ", b = " + b);

        swap(a, b);

        System.out.println("After swapping: a = " + a + ", b = " + b);

    }

    

    public static void swap(int x, int y) {

        int temp = x;

        x = y;

        y = temp;

    }

}

Output

Before swapping: a = 10, b = 20

After swapping: a = 10, b = 20

Explanation:

• Even though we attempted to swap the values of a and b inside the swap method, the change is not reflected outside the method. This demonstrates that Java is pass by value.
  

2. Write a method that doubles the values of all elements in an array of integers. Verify if the modifications persist outside the method.

public class ArrayDoubleExample {

    public static void main(String[] args) {

        int[] numbers = {1, 2, 3, 4, 5};

        

        System.out.println("Before doubling: " + Arrays.toString(numbers));

        doubleArray(numbers);

        System.out.println("After doubling: " + Arrays.toString(numbers));

    }

    

    public static void doubleArray(int[] arr) {

        for (int i = 0; i < arr.length; i++) {

            arr[i] *= 2;

        }

    }

}

Output

Before doubling: [1, 2, 3, 4, 5]

After doubling: [2, 4, 6, 8, 10]

Explanation:

• In this example, the doubleArray method takes an array of integers and doubles each element's value.
• The modifications made to the array inside the method are reflected outside the method, demonstrating that object references are passed by value.

By understanding how Java handles pass by value, you can write more robust and reliable programs. Remember that changes made to primitive values do not persist outside a method, while changes to objects (through their references) do persist. Now that you have a solid grasp of pass by value, you can confidently tackle more complex programming challenges in Java!