1: /**
   2:  * A better Toilet.  It automatically cleans up after itself if it
   3:  * overflows, so it never throws an exception.  It also tries to raise
   4:  * and lower the seat for you, although this turned out to be a bad idea.
   5:  *
   6:  * @author Jason Eisner
   7:  * @version 1.0, 2003-01-26
   8:  */
   9: 
  10: 
  11: public class AutoToilet extends Toilet {
  12: 
  13:   /** Like {@link Toilet#flush}, but cleans up instead of throwing
  14:       an exception. */
  15: 
  16:   public void flush() {  
  17:     try {
  18:       super.flush();
  19:     }
  20:     catch (FloatingOverflowException e) {
  21:       System.out.println("Caught exception, cleaning up mess.");
  22:       System.out.print("Retrying flush: ");
  23:       this.flush();
  24:     }
  25:   }
  26: 
  27:   /** Although we inherit the general {@link Toilet#deposit(Waste)} method
  28:    * from our parent class, we also override it with this more specific
  29:    * method for <i>liquid</i> waste.  The method automatically raises and lowers
  30:    * the seat for you when you pee.  Alas, tests show dissatisfaction 
  31:    * among female users.
  32:    * @param lw The liquid waste
  33:    */
  34:   public void deposit(LiquidWaste lw) {   
  35:     raiseSeatAuto(true);
  36:     deposit((Waste) lw);   // call the general method; alternatively, super.deposit(lw)
  37:     raiseSeatAuto(false);
  38:   }
  39: 
  40:   /** Since this kind of toilet has an automatic seat raiser, the user
  41:    * can't move the seat.  So we override the inherited <code>raiseSeat</code>
  42:    * method with one that has no effect.  (We do print a warning message;
  43:    * alternatively, we could throw an exception.)<p>
  44:    *
  45:    * Really we shouldn't even be able to call <code>raiseSeat</code>
  46:    * at all on an {@link AutoToilet}.  Unfortunately, by defining a
  47:    * <code>raiseSeat</code> method for {@link Toilet}, we have told
  48:    * the compiler that it's legal to call <code>raiseSeat</code> on
  49:    * any {@link Toilet} object, including subclasses.  So we'd have
  50:    * to change that -- i.e., only some subclasses of {@link Toilet} should
  51:    * support this method. 
  52:    */
  53: 
  54:   public void raiseSeat(boolean b) {  // overrides general method.
  55:     System.out.println("Thanks for trying to adjust the seat, but it's not necessary for this fancy toilet.");
  56:   } 
  57: 
  58:   /** Internally, the class's implementation will call this 
  59:    * protected method to move the seat.  The user can't call
  60:    * this. 
  61:    */
  62:   protected void raiseSeatAuto(boolean b) {
  63:     System.out.print("Whirr ... creak ... ");    // sound of the motor
  64:     super.raiseSeat(b);    // call superclass method, as if user had moved seat
  65:   }
  66: 
  67:   /** Test function similar to {@link Toilet#main}. */
  68: 
  69:   public static void main(String args[]) {   // doesn't throw anything
  70:     AutoToilet throne = new AutoToilet();
  71: 
  72:     throne.raiseSeat(true);                        // unnecessary now
  73: 
  74:     throne.deposit(new LiquidWaste("pee"));        // auto raises/lowers seat
  75:     (new LiquidWaste("more pee")).deposit(throne); // auto raises/lowers seat
  76: 
  77:     throne.deposit(new SolidWaste("poo"));         // no auto-flush in this version
  78:     throne.deposit(new SolidWaste("more poo"));    
  79:     throne.flush();
  80: 
  81:     throne.deposit(new TrashWaste("cigarettes"));  
  82:     throne.flush();                                // auto-cleans if overflow
  83: 
  84:     System.out.println("All done.  No need to destroy toilet; it will be garbage-collected.");
  85:   }
  86: }
  87: