b gets assigned a reference to a.

Best regards,
Jan

Reference

Here's how I understand it ...

The variable "a" holds a reference to an object. "a" and the object are
separate things. After the return statement is executed, the variable
"a" goes out of scope (and presumably gets garbage collected) however
the object that "a" referred to still exists and is not garbage
collected because there is still a reference to it (in "b").

It's not a silly or stupid question. It's actually a very important question,
and fundamental to the understanding of objects, and references to objects. You
do need to understand this particular point to understand how and why certain
things work the way they do in Java.

The short answer is 'b' gets a reference to the object created within the method
(assuming the unspecified method a() creates an object and returns a reference
to it...). The local variable 'a' disappears when the method returns.

The variable 'a' only holds a reference to an object (whatever is returned by
a()). What gets returned by func() is a copy of that *reference*, not a copy of
the object it refers to. So, when func() returns, a copy of 'a' is returned and
stored in 'b'. 'a', being local to func() and on the stack, disappears.

Not a silly question at all.
Short answer is, Java does "Pass Reference by Value"
Check out
http://www.javaworld.com/javaworld/javaqa/2000-05/03-qa-0526-pass.html

Cheers
Attitude Nine
---------------------------------------------------------------------------------
Built Exclusively using Attitude Version 9.0
http://www.opencontentonline.com

Thanks all,

it was veyr helpful and helped me understand it a lot better.
thanks

The way you declare a new Object in your function makes me think that
you come from a C/C++ background, and, if so, it is important to find a
new way of thinking about objects in Java.  While the program is
running, the JRE maintains a large group of objects, which are all
accessed by reference.  If you want a copy of an object, use the
clone() method, which makes sure that you are dealing with a different
object:

WalmartGreeter sam = new WalmartGreeter();
WalmartGreeter fred = sam;
/* at this point, fred == sam, and fred.equals(sam)
* ( the == operator determines if two variables are
* refering to the same individual object, but the
* equals() method only checks to see if the two
* objects are identical).
*/

fred = sam.clone();

/* at this point, fred != sam, but fred.equals(sam)
* because you have set fred to reference a clone of sam.
*/

fred = new WalmartGreeter();

/* here, you have re-assigned fred to be a totally new object,
* and, depending on how a new WalmartGreeter object is created,
* it may be that fred.equals(sam) (or not), but fred != sam.
* The clone of sam will be destroyed later automatically
* by the garbage collecter, since there is no reference to it anywhere
in the program
*/