Difference between object and reference in java with code?

Question

public class TestVO {

    public static void main(String[] args) {
        VO vo1 = new VO();
        VO vo2 = new VO();
        VO vo3;
        VO vo4 = new VO();

        vo1.setName("Sourav");
        vo2.setName("Anil");

        vo3 = vo1;
        vo4 = vo1;

        System.out.println(" " + vo4.getName());

        vo1.setName("Abhishek.");

        System.out.println(vo1.getName() + "  " + vo2.getName() + " " + vo3.getName() + " " + vo4.getName());
    }
}

--OUTPUT is:---

Sourav

Abhishek.  Anil Abhishek. Abhishek.

VO is a simple class contain String name and contain getter and setter.

In the first System.out.println *vo4.getName()* print : Sourav ok.It's fine.

But in the 2nd System.out.println *vo4.getName()* print : Abhishek.

My Question is why 2nd print is Abhishek.. I have kept a copy of vo1 object in vo4 object not a reference. That means it create a new memory. vo1 and vo4 are different.Then why vo4.getName is changed in the 2nd time. I am setting the vo1 object but vo4 is automatically changed. Why it is happening ??

You create objects with the new keyword, = transfers the reference of that object into the variable, equally var1=var2 copies the reference not the object — Richard Tingle
– Richard Tingle, Commented Jul 12, 2013 at 7:56

T.J. Crowder · Accepted Answer · 2013-07-12 08:05:26Z

I have kept a copy of vo1 object in vo4 object not a reference.

No, you've pointed the variables vo1 and vo4 at the same object, like this:

+-----+
| vo1 |--------\
+-----+         \    +----------------+
                 --->| (object)       |
+-----+         /    | name = Abishek |
| vo4 |--------/     +----------------+
+-----+

Let's follow the code through:

VO vo1 = new VO();

Gives us:

+-----+              +----------------+
| vo1 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+

Then:

VO vo2 = new VO();

Now we have:

+-----+              +----------------+
| vo1 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+

+-----+              +----------------+
| vo2 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+

Then:

VO vo3;

...which just creates vo3 with null (not pointing at any object).

Then:

VO vo4 = new VO();

So we have:

+-----+              +----------------+
| vo1 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+

+-----+              +----------------+
| vo2 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+
+-----+
| vo3 | (is null)
+-----+

+-----+              +----------------+
| vo4 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+

Now:

vo1.setName("Sourav");
vo2.setName("Anil");

Gives us:

+-----+              +----------------+
| vo1 |------------->| (object)       |
+-----+              | name = Sourav  |     *** change is here ***
                     +----------------+

+-----+              +----------------+
| vo2 |------------->| (object)       |
+-----+              | name = Anil    |     *** and here ***
                     +----------------+
+-----+
| vo3 | (is null)
+-----+

+-----+              +----------------+
| vo4 |------------->| (object)       |
+-----+              | name = null    |
                     +----------------+

Here's where things get interesting:

vo3 = vo1;
vo4 = vo1;

That points vo3 at the same object vo1 points to, and points vo4 at that object as well, releasing the object vo4 used to point to (which becomes eligible for garbage collection). Giving us:

+-----+
| vo1 |----\
+-----+     \
             \
+-----+       \      +----------------+
| vo3 |------------->| (object)       |
+-----+       /      | name = Sourav  |
             /       +----------------+
+-----+     /
| vo4 |----/
+-----+

+-----+              +----------------+
| vo2 |------------->| (object)       |
+-----+              | name = Anil    |
                     +----------------+

Now

System.out.println(" " + vo4.getName());

...gives us "Sourav" as you'd expect.

Then

 vo1.setName("Abhishek.");

...changes the object that vo1, vo3, and vo4 are all pointing to:

+-----+
| vo1 |----\
+-----+     \
             \
+-----+       \      +----------------+
| vo3 |------------->| (object)       |
+-----+       /      | name = Abishek |
             /       +----------------+
+-----+     /
| vo4 |----/
+-----+

+-----+              +----------------+
| vo2 |------------->| (object)       |
+-----+              | name = Anil    |
                     +----------------+

...and so getName() on vo1, vo3, or vo4 will give you "Abishek."

@GrahamSmith: Love me some ASCII-art. I probably should have used yuml.me, though. :-)

ajay.patel · Accepted Answer · 2013-07-12 07:54:23Z

6

Because both vo1 and vo4 are referring to the same object.

Below assignment makes vo4 to refer to an object that is referenced by vo1.

vo4 = vo1;

And hence, any changes made to referring object by any of the reference(be it vo1 or vo4) will be reflect to the same object.

So if you change say vo4.setName("xyz"), its going to change the object which is referred by vo4 but actually vo1 is also referring to the same object. So changes are made at one memory location allocated for ONE object which is being REFERENCED by many references( in this case vo1 and vo4).

answered Jul 12, 2013 at 7:54

ajay.patel

1,96712 silver badges15 bronze badges

Comments

AllTooSir · Accepted Answer · 2013-07-12 07:55:30Z

2

You are assigning the same object reference to vo1 and vo4 .

vo4 = vo1;

Now both the reference variables are pointing to the same object.

enter image description here

answered Jul 12, 2013 at 7:55

AllTooSir

49.5k17 gold badges132 silver badges164 bronze badges

Comments

Rohan · Accepted Answer · 2013-07-12 08:09:34Z

1

Object is an entity which will store actual value for the fields defined within it.Object will get created on memory using new keyword and reference will be returned to reference variable.Reference variable is not an object. So in your example new VO() will create object on heap memory and VO1 will have reference to it.

answered Jul 12, 2013 at 8:09

Rohan

3,0881 gold badge23 silver badges27 bronze badges

Comments

Onur A. · Accepted Answer · 2013-07-12 07:55:55Z

0

when you do vo4 = vo1; you simply copy vo1 by refernce to vo4, in other terms you do a pointer assignment so they both assign to the same location in memory which results if vo1 changes it will also affect vo4 too, as in the result you see

answered Jul 12, 2013 at 7:55

Onur A.

3,0273 gold badges24 silver badges37 bronze badges

Comments

Bryan Abrams · Accepted Answer · 2013-07-12 07:55:57Z

0

Everything in java except for the basic data types is a pointer. After creating vo4 you set it equal to vo1. Now vo4 points to v01.

answered Jul 12, 2013 at 7:55

Bryan Abrams

3271 silver badge8 bronze badges

Comments

Prasad Kharkar · Accepted Answer · 2013-07-12 07:56:31Z

0

When you do vo4 = vo1, it means the reference variable vo4 is referring to the object referred by vo1. So both vo1 and vo4 will refer to same object

Read the first part of this tutorial. You don't need to go till the end as it is about garbage collection but it explains in good detail how refrences are assigned to objects and how are they chagned.

http://www.thejavageek.com/2013/06/22/how-do-objects-become-eligible-for-garbage-collection/

answered Jul 12, 2013 at 7:56

Prasad Kharkar

13.6k5 gold badges42 silver badges57 bronze badges

Comments

score 0 · Accepted Answer · 2013-07-12 10:03:19Z

0

I have to prepare the following picture: as you see vo1, Vo3, Vo4 point to the same object

enter image description here

edited Jul 12, 2013 at 10:03

answered Jul 12, 2013 at 8:19

user2354035

3 Comments

A Basak Over a year ago

Simplest diagram to understand.Thankx.

T.J. Crowder Over a year ago

@ABasak: Except the labels are backward. The variables are on the stack, not the heap; the objects are in the heap, not the stack.

user2354035 Over a year ago

@ T.J. Crowder: Thank you very much for your comment, I corrected this error

Collectives™ on Stack Overflow

Difference between object and reference in java with code?

8 Answers 8

1 Comment

Comments

Comments

Comments

Comments

Comments

Comments

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

8 Answers 8

1 Comment

Comments

Comments

Comments

Comments

Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related