Java pass by reference

What is the difference between this 2 codes:

Code A:

Foo myFoo;
myFoo = createfoo();

where

public Foo createFoo()
{
   Foo foo = new Foo();
   return foo;
}

Vs. Code B:

Foo myFoo;
createFoo(myFoo);

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

Are there any differences between these 2 pieces of codes?

Java always passes arguments by value NOT by reference.

Let me explain this through an example:

public class Main
{
     public static void main(String[] args)
     {
          Foo f = new Foo("f");
          changeReference(f); // It won't change the reference!
          modifyReference(f); // It will modify the object that the reference variable "f" refers to!
     }
     public static void changeReference(Foo a)
     {
          Foo b = new Foo("b");
          a = b;
     }
     public static void modifyReference(Foo c)
     {
          c.setAttribute("c");
     }
}

I will explain this in steps:

Declaring a reference named f of type Foo and assign it to a new object of type Foo with an attribute "f".
```
Foo f = new Foo("f");
```
From the method side, a reference of type Foo with a name a is declared and it's initially assigned to null.
```
public static void changeReference(Foo a)
```
As you call the method changeReference, the reference a will be assigned to the object which is passed as an argument.
```
changeReference(f);
```
Declaring a reference named b of type Foo and assign it to a new object of type Foo with an attribute "b".
```
Foo b = new Foo("b");
```
a = b is re-assigning the reference a NOT f to the object whose its attribute is "b".
As you call modifyReference(Foo c) method, a reference c is created and assigned to the object with attribute "f".
c.setAttribute("c"); will change the attribute of the object that reference c points to it, and it's same object that reference f points to it.

I hope you understand now how passing objects as arguments works in Java :)

Since Java is strictly "pass by value" and even references to objects are passed by value the second code will not work as expected. See the "Related" section to the right for numerous discussions on this.

Think of method parameters as their own variable declarations. If you were to substitute the method call with a single block of code, it looks like this:

Foo myFoo;
{                      //Method call starts here
    Foo foo;
    foo = myFoo;
    Foo f = new Foo();
    foo = f;
}                      //Method call ends here

Even if the method parameter has the same name as another variable, the method parameter is still it's own, unique reference that only the method knows about. That's the same thing that Eng.Fouad says above.

Another important point which you should know is the object type which you pass into the method. whether it is a mutable object or a immutable object. If you pass a immutable object such as String it will create a another copy and do the modification. Changes are not reflected to your original copy.

Java pass by reference

Related

Recent Posts