Java: It is most certainly pass by value

I am surprised after all these years that this debate still happens between even seasoned Java developers. It isn’t really their fault though. Java made it a little confusing. If you want something more detailed, then you should read the following link.

I’m going to give you a quick overview that is not as detailed. Let’s start with a rule.

Java is pass by value regardless whether you are dealing with an object or a primitive

Everyone who writes java understands that when a method is called and a primitive is passed in, you get a copy of that variable and not the original. It is when passing an object that people get confused. The short of it is that the variable passed in is a cheap referenced copy of the original, but not really a pointer like in other languages like C++.

When you pass in an object, you can manipulate the values of elements of the object, but you cannot reassign the object to a new instance of that object because once you do, the link back to the object is completely broken. So if you call modifyIt(myClass) and in the method, you say myClass.someValue = ‘test’ and directly after the method call, the value of the original will be reflected by your change, but if you attempt to do this and reassign myClass to another object, your reference is lost.

Here is a class that illustrates the examples with some comments to help you along.

public class TestString {

 private static void modifyIt(String modified) {

  modified = "New String";  //This doesn't have any effect on the original

 }

 private static void modifyIt(int modified) {

  modified = 2; //This doesn't have any effect on the original

 }

 private static void modifyIt(MyClass clazz) {

  clazz.myValue = "new Value"; //This will work
  clazz.intValue = 2; //this will work
  
  clazz = new MyClass(); //Things will go south here. 
  
  clazz.myValue = "This value"; //you are throwing a toothpick in a volcano
  clazz.intValue = 56; //Urinating in the wind

 }

 public static void main(String[] args) {

  String value = "Original Value";
  modifyIt(value);
  // Prints only original value
  System.out.println(value);

  MyClass clazz = new MyClass();
        modifyIt(clazz); //This method call has problems
  
  
  System.out.println(clazz.myValue);
  System.out.println(clazz.intValue);

  int intValue = 1;

  modifyIt(intValue);

  // Only prints original value
  System.out.println(intValue);

 }
}

class MyClass {

 public String myValue = "Original Value";
 public int intValue = 1;

}

My personal preference is to always avoid even the remote possibility that these circumstances can even happen. You can do this by always returning the element in question from the method you are calling.

private static MyClass modifyIt2(MyClass clazz) {
 
  clazz = new MyClass(); //Things will go south here. If Java was
                                       //pass by reference, this would work
                                       //but it is pass by value 
  
  clazz.myValue = "This value"; //you are throwing a toothpick in a volcano
  clazz.intValue = 56; //Urinating in the wind
  
  return clazz;

 }

...

 myClazz = modifyIt2(myClazz);

If you make an assignment back to your variables from the return of a method in all cases, this eliminates any question as to what object you have. This is also more object oriented and leans away from the function paradigm to a method paradigm.

The biggest thing I want everyone to take away from reading this is that Java is pass by value and not pass by reference, it is not even a mix.