Java always passes arguments by value, NOT by reference. In your example, you are still passingobj by its value, not the reference itself. Inside your methodchangeName, you are assigning another (local) reference,obj, to the same object you passed it as an argument. Once you modify that reference, you are modifying the original reference,obj, which is passed as an argument.

EDIT:

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 change the object that the reference 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:

1- Declaring a reference namedf of typeFoo and assign it to a new object of typeFoo with an attribute"f".

Foo f = new Foo("f");

2- From the method side, a reference of typeFoo with a namea is declared and it's initially assigned tonull.

public static void changeReference(Foo a)

3- As you call the methodchangeReference, the referencea will be assigned to the object which is passed as an argument.

changeReference(f);

4- Declaring a reference namedb of typeFoo and assign it to a new object of typeFoo with an attribute"b".

Foo b = new Foo("b");

5-a = b is re-assigning the referencea NOTf to the object whose its attribute is"b".

6- As you callmodifyReference(Foo c) method, a referencec is created and assigned to the object with attribute"f".

7-c.setAttribute("c"); will change the attribute of the object that referencec points to it, and it's same object that referencef points to it.

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

In Java, an object handle, or the identity of an object is considered a value. Passing by value means passing this handle, not a full copy of the object.

A "reference" in the term "pass by reference" also doesn't mean "reference to an object". It means "reference to a variable" – a named "bucket" in a function definition (or, rather, a call frame) that can store a value.

Passing by reference would mean the called method could changevariable values in the calling method. (For example, in the C standard library, the functionscanf works this way.) This isn't possible in Java. You can always change theproperties of an object – they aren't considered a part of its "value". They're completely different independent objects.

It did not change obj (your code doesn't change it anyway).Had it been passed by reference, you could have written:

public static void changeName(myObject obj){    obj = new myObject("anotherName");}

And have "anotherName" printed by the main method.

You're changing aproperty ofobj, not changingobj (the parameter) itself.

The point is that if you pointedobj at something else inchangeName thatthat change would not be reflected inmain.

Seethis post for further clarification.

It is passing the reference to obj as a value (a bit confusing I know :)).

So let's say it makes a copy of the pointer to obj's value and pass that.

That means that you can do things like:

  public static void changeName(myObject obj){            obj.setName("anotherName");        obj = new myObject();    }

and the statement

System.out.print(obj.getName());

is still going to refer to the old object (the one that you did setName).

Java is passing a copy of what you're passing to your function. When it is a primitive type - it will be the copy of a value. When it is an object - you're passing the reference copy. In you're code example you're modifying one of objects properties, but not the reference itself so the name will be changed. However when you'd like to assign new object to obj variable in changeName function, then you're changing reference, so outside obj will have an old value.

• java
• parameter-passing
• terminology
• pass-by-reference
• pass-by-value