Pass by Reference and By Value Overview

In Java, the method of passing data to functions (also known as methods in Java) can be understood as either "pass-by-value" or "pass-by-reference."

Pass-by-Value

Call by value is a method used in programming when you pass information to functions. Let's break it down into simpler terms:

Photocopying Documents: Imagine you have an important document, and you need to share it with someone, but you don't want them to change the original. So, you make a photocopy and give them the copy. Call by value works like this. When you pass a value to a function, what you're actually passing is a copy of that value, not the original.
Protecting the Original: Because the function only gets a copy of the value, it can't change the original variable's value in the calling environment. Whatever changes the function makes, it makes to the copy. The original value remains safe and unchanged.
Simple Example: Think of a simple function like one that adds two numbers. When you pass these numbers to the function, you're actually passing copies of them. The function adds these copies, not the original numbers.
Memory Aspect: Each time a function is called by value, a new space in memory is created for the variable in the function. This space is separate from the space where the original variable is stored.
Use Cases: This method is used when you want to ensure that the original data shouldn't be altered by the function, providing a level of protection to your data.

In essence, call by value is like saying, "Here, use this copy for your work, but don't touch the original!" This ensures that your original data remains unchanged and safe.

In Java, primitive data types like int, float, double, char, etc., are passed by value. This means that a copy of the actual value is passed to the method, and any change made to that value within the method does not affect the original value outside of the method.

static void modifyValue(int x) {
    x = x * 2;
    System.out.println("Value inside method: " + x);
}

public static void main(String[] args) {
    int a = 5;
    modifyValue(a);
    System.out.println("Value outside method: " + a);
}

In this example, the output will be:

Value inside method: 10
Value outside method: 5

The value of a remains unchanged outside the method, indicating that the variable was passed by value.

Pass-by-Reference

Call by reference is another method used in programming for passing information to functions. Here's a simple explanation:

Giving Someone Your Notebook: Imagine you have a notebook with important information. Instead of giving someone a photocopy (like in call by value), you hand them the actual notebook. Call by reference works similarly. When you pass a variable to a function by reference, you essentially give the function access to the original variable, not a copy.
Making Direct Changes: Because the function has access to the original variable, any changes made directly to that variable. This means that the function can modify the original data.
Simple Example: Think of a function meant to edit a list by adding an item. If you pass this list to the function by reference, the function can directly add the item to the actual list, not just a copy of it.
Memory Aspect: In call by reference, no new memory space is created for the variable in the function. The function uses the same memory location as the original variable. This can be more memory efficient.
Use Cases: This method is often used when you need the function to modify the original data, or when you're working with large data where making copies would be inefficient in terms of memory and performance.

In essence, call by reference is like saying, "Here, make your changes in my notebook." It's a direct and efficient way to allow functions to modify and work with the original data.

In contrast, objects of classes (like arrays, instances of user-defined classes, etc.) are also passed by value, but the value that gets passed is the reference to the object, not the actual object itself. This is sometimes confusingly referred to as "pass-by-reference," but it's more accurate to say the object references are passed by value.

Here's an example:

import java.util.Arrays;
static void modifyArray(int[] arr) {
    arr[0] = 99;
    System.out.println("Array inside method: " + Arrays.toString(arr));
}

public static void main(String[] args) {
    int[] myArray = {1, 2, 3};
    modifyArray(myArray);
    System.out.println("Array outside method: " + Arrays.toString(myArray));
}

The output will be:

The array is modified inside the method and the change reflects outside the method as well. This happens because the reference to the array is passed by value.

In summary, Java is "pass-by-value" in the sense that it passes a copy of the variable to methods. For primitive types, it's the actual value; for objects, it's the reference to the object. Changes to the object that the reference points to will be visible outside the method, but if you change the reference itself to point to a new object, that change won't be visible outside the method.