What is Pass by Reference in Java

In Java, many developers often wonder whether the language uses pass-by-reference or pass-by-value when dealing with method arguments. To clear up this confusion, let’s explore parameter passing in Java so we can answer the question of what is pass by reference in Java.

Contrary to popular belief, Java’s method arguments are always passed by value. This means the variable’s actual value is passed to the method when calling a function or method rather than a reference to the heap memory location where the value is stored. When dealing with objects, Java passes reference value (or pointer) to the referenced object, allowing the called method to modify the object’s state. However, the object reference remains unchanged in the calling scope.

For example, consider the following code snippet:

class Example {
    void modifyObject(MyClass obj) {
        obj.setValue(10);
        obj = new MyClass(20);
    }

    public static void main(String[] args) {
        MyClass myObj = new MyClass(5);
        Example ex = new Example();
        ex.modifyObject(myObj);
        System.out.println(myObj.getValue()); // Output: 10
    }
}

In this example, the modifyObject method receives a copy of the reference myObj, allowing it to change the object’s value (from 5 to 10) using the setValue method. However, when a new instance of MyClass is created and assigned to the local variable obj, it does not affect the original myObj reference in the calling scope. Thus, the output of the example is 10 rather than 20.

---

2. Understanding Java Pass by Reference

In Java, as developers, we often deal with the concept of passing arguments to methods. It is important to grasp the concept of pass-by-reference since we need to understand how Java handles object references when passing them to methods.

First, let’s clarify what pass by reference means. When passing an argument by reference, we essentially pass the memory location where the data is stored instead of copying it. This means any changes made to the actual parameter within the method will directly affect the original data since both the parameter and the original reference point to the same heap memory location.

However, it is crucial to note that Java does not support “pass by reference” in the truest sense. Instead, when Java pass an object to a method, we pass the referenced object “by value”. This means we are passing a copy of the reference to the method, not the actual object reference itself.

public void modifyObject(MyClass obj) {
    obj.setField("New Value");
}

The code above demonstrates a method that accepts an object reference of type MyClass. When we call this method, it updates the field within the object. Since Java pass the object reference by value, the called method will still modify the original object because the copied reference points to the same object in heap memory. But the reference itself is a copy, meaning that reassigning the parameter within the method doesn’t affect the original reference.

public void reassignObject(MyClass obj) {
  obj = new MyClass();
}

In this case, the method reassigns the parameter to a new object, but the reference outside the method remains unchanged. We can conclude that, even though Java allows modifying the objects passed to methods, it does not allow changing the actual reference leading to it being called “pass by value” instead of “pass by reference”.

---

3. How Java Handles Objects and Primitive Data Types

Let’s discuss how Java handles objects and primitives, which will help us understand the concept of pass-by-reference in Java.

3.1. Primitive Data Types

Primitive types are the basic data types, such as integers, floats, and booleans. When Java pass a value type to a method, it’s passed by a value. This means that a copy of the actual value is passed, and any changes made to the variable within the method don’t affect the original value. Let’s take a look at an example:

public class ValueTypeExample {
     public static void main(String[] args) {
         int number = 42;
         System.out.println("Before: " + number);
         changeValue(number);
         System.out.println("After: " + number);
     }

     public static void changeValue(int value) {
         value = 24;
     }
}

Output:

Before: 42
After: 42

The output shows that the variable number remains unchanged after calling changeValue(), indicating that it has been passed by value.

3.2. Java Object Variables

When working with Java objects, such as class or array instances, its reference (a heap memory address) is passed when passed to a method. This means changes to the object within the method will affect the original object reference. Here is an example:

class Dog {
    String name;

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

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

    String getName() {
        return name;
    }
}

public class ReferenceTypeExample {
    public static void main(String[] args) {
        Dog dog = new Dog("Sparky");
        System.out.println("Before: " + dog.getName());
        changeName(dog);
        System.out.println("After: " + dog.getName());
    }

    public static void changeName(Dog d) {
        d.setName("Rex");
    }
}

Output:

Before: Sparky
After: Rex

After calling changeName(), the dog’s name has changed, meaning the dog object has been passed by reference. This is because we’re passing the object’s heap memory address, allowing the method to modify the original object.

---

4. Passing Primitives by Reference

So far, there was demonstrated that Java always passed by the value. It’s still possible to pass by reference; understanding how is essential.

4.1 Static Variables

private static int count;

public static void main(String[] args) {
    incrementByOne();
    count++;
    System.out.println(count);
}

public static void incrementByOne() {
    count++;
    System.out.println(count);
}

As you probably already know, static variables are initialised when the class is loaded, so they belong to the class rather than an instance. As a result, they can be accessed globally by any method inside the class file. In the above example, both methods are aware of each modification hence why the value is incremented twice (pointer points to same object reference).

4.2. Public Class Variables

public static void main(String[] args) {
    Person somePerson = new Person("Dave", 20);
    addToAge(somePerson, 5);
    System.out.println(somePerson); // Person(name=Dave, age=25)
}

public static void addToAge(Person person, int add) {
    person.age += add;
}

The person object has a public variable age to update it directly inside the method. Changes are visible in the main method since it has affected the original object location in the application heap memory.

4.3. Return Method Value

public static void main(String[] args) {
    int age = 25;
    age = addToAge(age, 5);
    System.out.println(age); // 30
}

public static int addToAge(int age, int add) {
    age += add;
    return age;
}

This example is similar, but we assign the method’s return value to the age variable and update the matter accordingly. The change is visible inside the main method because the change has been applied to the original variable.

---

5. Common Misconceptions

One of the most common misconceptions in Java is the belief that Java uses pass-by-reference for objects. However, Java employs pass-by-value for all method parameters, including object references. Let’s clarify this concept further.

In Java, primitive types (such as int, float, or char) are passed by value, which means that a copy of the actual value is sent to the method. On the other hand, object references are also passed by value, meaning that a copy of the reference (not the object itself) is sent to the method. This might seem similar to pass-by-reference, but it’s a crucial distinction.

To illustrate the difference, let’s consider a Java example:

class Dog {
    String name;
}

void changeDogName(Dog dog, String newName) {
    dog.name = newName;
    dog = new Dog();
}

public static void main(String[] args) {
    Dog myDog = new Dog();
    myDog.name = "Fido";
    changeDogName(myDog, "Buddy");
    System.out.println(myDog.name);
}

In this code snippet, we have a Dog class with a name property and a method called changeDogName that takes a Dog object and a new name. Inside the changeDogName method, we change the dog’s name and create a new object. When we call changeDogName in the main method, the output will still be “Fido” instead of “Buddy”. Why?

It’s because when we pass myDog to the changeDogName method, we pass a copy of the reference to the Dog object. The dog.name assignment successfully changes the name of the original Dog object. Still, when we create a new Dog object with the line dog = new Dog(), that new object is only visible within the scope of the changeDogName method and not reflected in the calling scope.

Hopefully, this clears up the confusion surrounding pass-by-value and pass-by-reference in Java.

---

6. Benefits and Drawbacks

When working with Java, we may encounter situations where we must pass information between methods. One benefit of passing by reference in Java is that it can allow for improved memory efficiency. Since we’re passing a reference to an object rather than creating a new, separate copy, less memory is consumed.

Additionally, passing by reference can be useful when we want to modify an object’s state or attributes within a method and have these modifications persist outside the method. This can be done by passing the object rather than creating a copy.

6.1. Drawbacks

However, there are several disadvantages to employing pass-by-reference in Java. One of the major disadvantages is the danger of accidentally changing an item’s state because we’re working with the original object rather than a distinct duplicate. This may result in unforeseen repercussions and side effects in the programming.

It’s also worth noting that Java passes by value rather than via reference by default. This isn’t an issue for primitive data types like int or double. When interacting with objects, however, the reference to the object is supplied by value. This might not be very clear for newcomers to the language and adds complexity when attempting to implement pass-by-reference behaviours.

Furthermore, while attempting to implement pass-by-reference behaviour in Java, we may need to modify our code by using mutable objects or arrays. This may require the caller to undertake more work, which is not always desirable.

To summarise, while there are advantages to using pass-by-reference in Java, such as improved memory efficiency and the ability to modify objects outside of the method, there are also disadvantages to consider, such as the risk of unintended modifications and the additional complexity involved in achieving true pass-by-reference behaviour.

---

7. Summary

In this post, we looked at the Java notion of pass-by-reference. As we’ve seen, Java is a pass-by-value language when it comes to passing arguments. When we send a variable to a method, we pass a copy of the value rather than a direct reference to the original data.

It may appear that we are passing by reference while working with Java object variables; however, this is not the case. We’re accomplishing this by sending the reference value by value. In other words, rather than a direct reference to the item, we send a copy of the reference to the object.

When building and implementing Java applications, it is critical to understand the distinction between pass-by-value and pass-by-reference. It enables us to know how data is modified and shared across functions, allowing us to write more efficient, secure, and maintainable code.