What is the difference between passing parameters by value and by reference in Java?

Understanding Parameter Passing in Java

In Java, the way parameters are passed to methods is a fundamental concept that every Java programmer should understand. Java uses two distinct mechanisms for passing parameters: pass-by-value and pass-by-reference.

Pass-by-Value

In Java, when you pass a parameter to a method, the value of the parameter is copied and passed to the method. This means that any changes made to the parameter inside the method will not affect the original value outside the method. This is known as pass-by-value.

Here's an example to illustrate pass-by-value:

public class PassByValue {
    public static void main(String[] args) {
        int x = 5;
        System.out.println("Before calling the method: x = " + x);
        changeValue(x);
        System.out.println("After calling the method: x = " + x);
    }

    public static void changeValue(int y) {
        y = 10;
        System.out.println("Inside the method: y = " + y);
    }
}

Output:

Before calling the method: x = 5
Inside the method: y = 10
After calling the method: x = 5

In this example, when the changeValue() method is called, the value of x (which is 5) is copied and passed to the y parameter. Any changes made to y inside the method do not affect the original x value.

Pass-by-Reference

In contrast to pass-by-value, some programming languages, like C++ and Python, use pass-by-reference, where the reference (or address) of the parameter is passed to the method. This means that any changes made to the parameter inside the method will affect the original value outside the method.

However, Java does not support true pass-by-reference. Instead, Java uses a mechanism called pass-by-value of the reference. This means that the reference (or address) of the object is passed to the method, but the reference itself is passed by value.

Here's an example to illustrate pass-by-value of the reference:

public class PassByReference {
    public static void main(String[] args) {
        Person p = new Person("John");
        System.out.println("Before calling the method: " + p.getName());
        changeName(p);
        System.out.println("After calling the method: " + p.getName());
    }

    public static void changeName(Person person) {
        person.setName("Jane");
        System.out.println("Inside the method: " + person.getName());
    }

    static class Person {
        private String name;

        public Person(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

Output:

Before calling the method: John
Inside the method: Jane
After calling the method: Jane

In this example, when the changeName() method is called, the reference (or address) of the Person object is passed to the person parameter. Any changes made to the Person object inside the method, such as calling the setName() method, will affect the original Person object outside the method.

Visualizing Parameter Passing

The difference between pass-by-value and pass-by-reference can be visualized using a Mermaid diagram:

In the pass-by-value scenario, the value of the parameter is copied and passed to the method, while in the pass-by-reference scenario, the reference (or address) of the object is copied and passed to the method.

Conclusion

In summary, Java uses pass-by-value for primitive data types and pass-by-value of the reference for object types. Understanding the difference between these two parameter passing mechanisms is crucial for writing efficient and correct Java code.