• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Jeanne Boyarsky
  • Ron McLeod
  • Paul Clapham
  • Liutauras Vilda
Sheriffs:
  • paul wheaton
  • Rob Spoor
  • Devaka Cooray
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Frits Walraven
  • Tim Moores
Bartenders:
  • Mikalai Zaikin

Object Inside Object

 
Greenhorn
Posts: 12
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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)
 
Marshal
Posts: 79178
377
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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.
 
lowercase baba
Posts: 13089
67
Chrome Java Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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.
 
Sachin Dravid
Greenhorn
Posts: 12
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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?
 
Rancher
Posts: 3742
16
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

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.
 
Sachin Dravid
Greenhorn
Posts: 12
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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
Posts: 3742
16
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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
Posts: 3742
16
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
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.
 
Rancher
Posts: 1044
6
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator


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.



 
Consider Paul's rocket mass heater.
reply
    Bookmark Topic Watch Topic
  • New Topic