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);
 }
}