Understanding Java's Pass by Value Mechanism

Java works as a “pass by value” or “pass by reference” phenomenon?

Java is often described as "pass by value," but this can be a bit misleading without further explanation. Here's a breakdown of how it works:

1. Primitive Types: When you pass a primitive type (like int, char, float, etc.) to a method, Java passes a copy of the value. This means that changes made to the parameter inside the method do not affect the original variable.

   public void modifyPrimitive(int number) {
       number = 10; // This change does not affect the original variable
   }
   
   public void example() {
       int original = 5;
       modifyPrimitive(original);
       System.out.println(original); // Outputs: 5
   }
   

2. Reference Types: When you pass an object (which is a reference type) to a method, Java passes a copy of the reference to that object, not the actual object itself. This means that while you cannot change the reference to point to a new object (the reference itself is passed by value), you can modify the object that the reference points to.

   class MyObject {
       int value;
   }
   
   public void modifyObject(MyObject obj) {
       obj.value = 10; // This change affects the original object
   }
   
   public void example() {
       MyObject original = new MyObject();
       original.value = 5;
       modifyObject(original);
       System.out.println(original.value); // Outputs: 10
   }
   

In summary, Java is strictly "pass by value." However, when dealing with objects, it may seem like "pass by reference" because you can modify the object's state through the reference that was passed. But remember, the reference itself is still passed by value, meaning you cannot change which object the reference points to in the calling method.