Re: Noob question - StringBuffer
On Jan 8, 9:08 am, Lew <l...@lewscanon.com> wrote:
Gordon Beaton wrote:
On Tue, 8 Jan 2008 03:08:35 -0800 (PST), fxt...@gmail.com wrote:
I suspected this was the case - like you said, and if I understood
correctly, the arguments being passed were copies - but they were
"shallow" copies and the embedded references weren't replicated, and
hence the behavior that confused me. I had expected a major utility
class like StringBuffer to override the default clone() with a
meaningful "deep" implementation, but that's obviously not the case.
The object itself is not involved when the reference is copied or
assigned; in this respect references behave just like primitives.
In other words, there's no question of clone()ing or copying. The clone()
method has absolutely nothing to do with parameter passing. Nothing.
Java is "pass by value", but it's the value of the *reference* that's passed,
not the value of the object itself.
--
Lew
You're right Lew. I realize now that clone() has nothing to do with
the previous discussion.
For some reason I was under the impression that the JVM calls clone()
automatically when an assignment (=) is made or an object is passed as
argument. I tried overriding the default clone() and realized it
wasn't automatically called in either case.
Another misconception corrected :)
So it seems to me that the only way we can pass a true deep-copy of an
object as an argument, is to override the clone() method and
EXPLICITLY invoke it like so: operate((Simple)a.clone(),
(Simple)b.clone());
The following works fine as a deep-copy is used in argument, and the
resulting:
[A],[B]
import java.util.*;
class Simple implements Cloneable
{
private Vector<Object> inner;
public Simple(String str)
{
inner = new Vector();
inner.add(str);
}
public void addInner(Simple s) {inner.add(s.toString());}
public String toString() {return inner.toString();}
public Object clone()
{ try{ //performing the "deep" copying here:
Simple simple = new Simple(inner.toString());
return simple;
}catch (Exception e){
e.printStackTrace();
return this;
}
}
}
public class Test
{
static void operate(Simple x, Simple y)
{
x.addInner(y);
y = x;
}
public static void main(String[] args)
{
Simple a = new Simple("A");
Simple b = new Simple("B");
operate((Simple)a.clone(),(Simple)b.clone());
System.out.println(a+","+b);
}
}