No there is only one object, the method has a copy of the reference only.
The reference is lost the object remains.  In Java references to the object
are passed, and they are passed by value.

--
Mike W

"Ryan" wrote...

There's a difference between pointers in C and references in Java, but I
don't think we need to that deep right here...

No, it won't be erased...

...as the "external" variable still will hold a *reference* to the object.

Objects are not "value" types such as structs in C, but a completely
different kind of animal.

Example, lets say we call a method:

  Object o = myMethod();

And then we have the method:

  Integer myMethod()
  {
     // 1. x now holds a reference to an object.
     //    The variable x is created on the stack,
     //    referencing to the object on the heap

     Object x = new Object();

     // 2. y now holds a reference to an object.
     //    The variable y is created on the stack,
     //    referencing to another object on the heap

     Object y = new Object();

     // 3. the method returns the *reference* to
     //    the first object

     return x;

     // 4. As the method returns, the local
     // *variables* within the method are
     // eliminated from the stack, but...
  }

...both objects still exist on the heap.

As the result of the call, o is referencing the first object of the two, but
there's no variable referencing the second object.

Now the second object is *eligable* for garbage collection, as there are
*no* reference to it, but the first one is still referenced.

I don't know if this made it any clearer, but I hope so...

// Bjorn A

Nope. The callee's local reference disappears, but the object remains
and the pointer to it returned on the stack.  The object won't be
garbage collected because the caller will soon be pointing to it with
one if its local variables as soon as it saves the returned value.

It is safe in the interim because any object pointed to by the stack
won't be gc'd either.

--
Canadian Mind Products, Roedy Green.
Coaching, problem solving, economical contract programming.
See http://mindprod.com/jgloss/jgloss.html for The Java Glossary.

isn't gc works automatically in Java and objects are only gc'ed if
there is no more reference to it? So gc bascially counts the
references to each object and acts when the number reaches 0. So in
your senario, there's still one more reference to it at least, so it
won't be erased.
Yang

Depends what you mean. If you're returning using the keyword, ie.

return myObj;

then as long as you assign that result to a variable, the object will
not get destroyed.

If you have Object myFunc(int p, int p2, ..), then

myFunc(1,2,...);// will result in the return being lost, whereas
Object o = myFunc(1,2,..); // will result in it not being GC'ed

If, on the other hand , you're talking about returning a value through a
parameter, as is typical with C, then no you can't do that. Ie. in C you
can say

void copyVal(int *p) {
  *p = 5;
}

int a;
a = 1;
copyVal(&a);
// a now has 5 stored in it

There's no way to do this in Java.

mehaase(at)sas(dot)upenn(dot)edu

Or, in other words, Objects in Java were all created in the heap, with
new(), so that they don't get automatically erased when existing a stack
frame?