public class RussianDoll {   // version 4

  public static final RussianDoll ZERO = new RussianDoll();

  private RussianDoll inner;
  private RussianDoll(RussianDoll rd) {  
    inner = rd;
  }
  private RussianDoll() {    // returns ZERO
    inner = this;
  }

  public RussianDoll smaller() {
    return inner;   // now what is ZERO.smaller()?
  }

  public RussianDoll bigger() {
    return new RussianDoll(this);
  }

  public String toString() {  // recursive: will it necessarily terminate?
    if (this == ZERO)
      return "0";
    else 
      return "S" + inner.toString();  // "S" for "surround"
  }

  public static RussianDoll add(RussianDoll rdOuter, RussianDoll rdInner) {
    // Okay to modify rdOuter to stick rdInner inside it?
    // No, we'd better copy it.  Could define a clone method, but
    // here's a cute recursive method instead:
    if (rdOuter==ZERO)
      return rdInner;
    else 
      return add(rdOuter.smaller(), rdInner.bigger());
  }

  public RussianDoll add(RussianDoll rdInner) { 
    // Alternative method.
    if (this==ZERO)
      return rdInner;
    else
      return smaller().add(rdInner.bigger());
  }

  public static void main(String args[]) {
    System.out.println("Zero : " + ZERO);
    System.out.println("Zero ++ ++ ++ -- ++ : "
                       + ZERO.bigger().bigger().bigger().smaller().bigger());
    System.out.println("Zero ++ -- -- ++ : "
                       + ZERO.bigger().smaller().smaller().bigger());

    RussianDoll rdThree = ZERO.bigger().bigger().bigger();

    RussianDoll rdFour =  ZERO.bigger().bigger().bigger().bigger();
    System.out.println("Three : " + rdThree);
    System.out.println("Four : " + rdFour);

    System.out.println("Three + Four (static method) : "
                       + add(rdThree,rdFour));
    System.out.println("Three + Four (instance method) : "
		       + rdThree.add(rdFour));
  }
}