5.8. Passing Parameters (Call by Value)

In Java, all arguments are passed by value. That means: a copy of the variable is passed, not the actual variable.

When we talk about 'passing parameters by value', it means that when you call a method and pass an argument to it, Java sends a copy of that argument's value to the method. Therefore, what happens inside the method does not affect the original variable that was passed in. This is crucial to understand to avoid any confusion about whether the original variable changes or not when a method is called.

Think of it like sending a copy of a handwritten note to a friend. If your friend makes changes to their copy of the note, your original note remains unchanged. Similarly, when you call a method and pass a variable, the method works with a 'copy' of that variable, leaving the original variable intact.

✅ Example:

class Demo {
    void changeValue(int x) {
        x = x + 10;
    }
    public static void main(String[] args) {
        int num = 5;
        Demo d = new Demo();
        d.changeValue(num);
        System.out.println("num = " + num);
    }
}

In the provided Java example, we define a class Demo with a method changeValue. When we call changeValue(num), Java passes a copy of num (which is 5). Inside changeValue, the method modifies x to be x + 10, but since x is just a copy, the original num remains 5. Thus, when we print num, the output will still show num = 5.

Consider a school situation where a student (the variable num) gives a homework assignment (the method changeValue) to a tutor (the method). The tutor receives a copy of the assignment. If the tutor makes any changes to that copy (adding 10), the original homework given by the student remains unchanged. The student can always go back to their original work without worry of it being altered.

● x is a copy → num remains unchanged.

This point reinforces the essence of call by value in Java: since the method receives only a copy of the variable, any modifications made to that copy do not affect the original variable used in the call. This guarantees that the original data remains safe and unchanged through the execution of the method.

Imagine you have a favorite toy (the original variable num). You let your friend play with a clone of that toy (the copy) while you keep your original tucked away safely. Even if your friend changes the clone in various ways, your original toy remains the same as it was.

--