aspose file tools*
The moose likes Java in General and the fly likes Object Inside Object Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login
JavaRanch » Java Forums » Java » Java in General
Bookmark "Object Inside Object" Watch "Object Inside Object" New topic
Author

Object Inside Object

Sachin Dravid
Greenhorn

Joined: Jan 21, 2013
Posts: 12
Hi,

Consider the following code:


In the above example, we are creating an object of type ABC inside main() method and calling a method on that object. Now, within the method, we are again creating an object of type ABC, using the same reference variable name 'abc'. I know that the values of 'x' and 'y' would be 10 and 20 after printing. Now, my question is:

01) We are using same reference variable to refer to 2 different objects. As soon as the second object is created, reference to the first object will be dropped and will be created for the second object, since we are using the same reference variable. Is it so?

02) If it is so, then how we are getting the values in first object (x=10, y=20) and not the new pair of values (x=30, y=40)
Campbell Ritchie
Sheriff

Joined: Oct 13, 2005
Posts: 38793
    
  23
Welcome to the Ranch

Please use the code button. Fortunately I can apply it to your code, and you can see how much better it looks

I think you have a misunderstanding about pass‑by‑reference and pass‑by‑value. There is a long discussion about it here; have a look at that when you have a week to spare.
The rules about pass‑by‑reference are very simple in Java: it doesn’t exist. If it used pass‑by‑reference, you could write something like thisBut it doesn’t, so you can’t. All that code can be compiled and executed in Java, but it doesn’t print 234. The original f reference, outside the method, remains unchanged. So it prints Foo 123. The only Foo references changed are those in the method.
Remember, when people tell you that reference types are pass‑by‑reference and primitives are pass‑by‑value, those people are telling you rubbish.
fred rosenberger
lowercase baba
Bartender

Joined: Oct 02, 2003
Posts: 11311
    
  16

Variables have a 'scope'. This is basically where the object can be seen and where it can't.

The 'abc' variable in the main method can only be seen in the main method, and the 'abc' variable in your method_01 can only be seen in the method_01.

When your main method calls method_01, you get a new, distinct variable. Java knows which is which.

So, your statement "As soon as the second object is created, reference to the first object will be dropped" is simply not true.


There are only two hard things in computer science: cache invalidation, naming things, and off-by-one errors
Sachin Dravid
Greenhorn

Joined: Jan 21, 2013
Posts: 12
Thanks Ritchie and Fred.

Continuing the discussion with Fred:

As you mentioned Fred - So, your statement "As soon as the second object is created, reference to the first object will be dropped" is simply not true.

I am confused a bit now. Since we are using the same reference variable name to refer to 2 objects, how can single variable can point to 2 different objects?

After reading a little about the memory concepts, I know now that each method has its own stack. So, main() method will have its own stack and we are creating 1st object inside main() method. Next, method_01() will have its separate stack and 2nd object is created from this method. So, has it got to do something with memory? The 2 reference variables will simply exist in different stacks (even though they are of same name) and will keep on pointing on different objects on the heap?
Joanne Neal
Rancher

Joined: Aug 05, 2005
Posts: 3534
    
  15
Sachin Dravid wrote:Since we are using the same reference variable name to refer to 2 objects, how can single variable can point to 2 different objects?

You might be using the same variable name, but they are not the same variable. You have two separate variables pointing to two separate objects.


Joanne
Sachin Dravid
Greenhorn

Joined: Jan 21, 2013
Posts: 12
Thanks Joanne for the reply.

But that is what is puzzling me. Can you please elaborate a bit about memory/stack? Like where will the 2 reference variables land?
Joanne Neal
Rancher

Joined: Aug 05, 2005
Posts: 3534
    
  15
As both variables are local variables (declared inside a method rather than as part of the class declaration), they will both be on the stack.
Joanne Neal
Rancher

Joined: Aug 05, 2005
Posts: 3534
    
  15
Actually I've just taken another look at your code.

Sachin Dravid wrote:02) If it is so, then how we are getting the values in first object (x=10, y=20) and not the new pair of values (x=30, y=40)

That is because you don't set x to 30 or y to 40. You assign those values to variables called a and b, but those variables don't appear to be declared anywhere, so that code won't actually compile. Maybe you should post the actual code you are using (or at least show us the declarations of a and b.
Ivan Jozsef Balazs
Rancher

Joined: May 22, 2012
Posts: 867
    
    5


Then at the time of the execution of the method "bar", both "foo" and "bar" will have their frames on actually the same stack (that of the executing thread).
The two variables called "abc" are different, they have different scopes (namely of their declaring methods respectively), so they will occupy different places in the stack:
each inside the frame of its declaring method.

But these are the details of the implementation, it might be better to simply think of them as of two different variables, albeit having accidentally the same name,
but being of different scopes, and hence being different.



 
I agree. Here's the link: http://aspose.com/file-tools
 
subject: Object Inside Object