How Does Java Handle Passing Objects: By Value or by Reference?

Java Pass By Value vs. Reference: Analyzing Differences

In Java, arguments are passed by value, not by reference. This concept can be confusing, especially when dealing with objects. Let's examine the subtle differences between two code snippets:

Code A:

Foo myFoo;
myFoo = createfoo();

Code B:

Foo myFoo;
createFoo(myFoo);

public void createFoo(Foo foo)
{
   Foo f = new Foo();
   foo = f;
}

Understanding Code A

In Code A, a reference variable myFoo is created and assigned to the object returned by createfoo(). However, in Java, objects are passed by value, not by reference. This means that a copy of the object is created and assigned to myFoo. Any changes made to this copy will not affect the original object in createfoo().

Understanding Code B

Code B uses the createFoo() function with a parameter foo. Again, foo is a copy of the original reference variable myFoo. So, when f is created and assigned to foo, it actually replaces the copy of myFoo inside createFoo(). Any changes made to foo within createFoo() will be reflected in the original myFoo reference variable.

Example to Illustrate the Differences

To further clarify, consider the following example:

public class Main {
   public static void main(String[] args) {
      Foo f = new Foo("f");
      changeReference(f); // Will not change the reference!
      modifyReference(f); // Will modify the object referred by "f"!
   }
   public static void changeReference(Foo a) {
      Foo b = new Foo("b");
      a = b;  // Re-assigns 'a' reference to the new object, not 'f'.
   }
   public static void modifyReference(Foo c) {
      c.setAttribute("c");  // Modifies the object referred by 'c', same as 'f'.
   }
   private static class Foo {
      private String attribute;
      public Foo(String attribute) { this.attribute = attribute; }
      public void setAttribute(String attribute) { this.attribute = attribute; }
   }
}

When executing this code:

• Foo f = new Foo("f"); creates an object with "f" as its attribute.
• changeReference(f); creates a new copy of the Foo object, assigning "b" as its attribute, but it doesn't affect the original object referred to by f.
• modifyReference(f); modifies the object that f is pointing to, changing its attribute to "c".

Conclusion

In Java, objects are passed by value, which means a copy of the object is passed as an argument. Any changes made to the copy within the method do not affect the original object. However, if the method modifies the object itself (e.g., by changing its attributes), the original object will be affected. It's important to understand this concept when working with objects in Java to avoid potential confusion.

The above is the detailed content of How Does Java Handle Passing Objects: By Value or by Reference?. For more information, please follow other related articles on the PHP Chinese website!