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)
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.
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.
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?
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 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.
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.