SDSU CS535 Object-Oriented Programming & Design
Fall Semester, 1996
Doc 24, AWT Observer Example

[To Lecture Notes Index]
San Diego State University -- This page last updated Nov 17, 1996
----------

Contents of Doc 24, AWT Observer Example

  1. An Observer/Observable Example
    1. Class Descriptions
      1. class IncreaseDetector
      2. abstract class CounterButton
      3. class IncreaseButton
      4. class DecreaseButton
      5. class CounterView
      6. class CounterTextView
      7. class ButtonController
      8. class RectangleView
    2. Sample Program


Doc 24, AWT Observer Example Slide # 1Listen Here!

An Observer/Observable Example

The Classes






indicates interface



Doc 24, AWT Observer Example Slide # 2Listen Here!

Class Descriptions


Counter
A Counter can increase or decrease by one. Each time a counter changes value, it notifies its observers of the type of change. 
IncreaseDectector
IncreaseDetector is an observer that observes counters. 
IncreaseDetector counts the number of times one of its observables increases.


CounterButton
Abstract class for changing a counter each time the button is  pressed

IncreaseButton
A button that increases a counter each time the button is pressed
DecreaseButton
A button that decreases a counter each time the button is pressed


Doc 24, AWT Observer Example Slide # 3Listen Here!
Class Descriptions
CounterView
A parent window view that observes a counter. Does nothing with counter. Used as parent for other views.

CounterTextView
A window for displaying the value of a counter in ASCII.


ButtonController
A window for changing the value of a counter using IncreaseButton and DecreaseButton. 


RectangleView
Draws a colored rectangle that depends on two counters. One counter is the width of the rectangle, the other counter is the height of the rectangle. The color of rectangle varies with its shape. 


Doc 24, AWT Observer Example Slide # 4Listen Here!
class Counter
/**
 * A counter can increase or decrease by one. Each time a counter 
 * changes value, it notifies its observers of the type of change. 
 */

class Counter extends Observable 
   {
   public static final String INCREASE = "increase";
   public static final String DECREASE = "decrease";

   private int count = 0;
   private String label;
   
   public Counter( String label )   {   this.label = label; }
      
   public String label()         {  return label; }
   public int value()             {  return count; }
   public String toString()       {  return String.valueOf( count );}
      
   public void increase() 
      { 
      count++; 
      setChanged();
      notifyObservers( INCREASE ); 
      }
         
   public void decrease() 
      { 
      count--;
      setChanged();
      notifyObservers( DECREASE ); 
      }   
   }



Doc 24, AWT Observer Example Slide # 5Listen Here!

class IncreaseDetector

/**
 * IncreaseDetector is an observer that observes counters. 
 * IncreaseDetector counts the number of times one of its obervables 
 * increases.
 */

class IncreaseDetector extends Counter implements Observer
   {
   public IncreaseDetector( String label )
      {
      super( label );
      }
      
   public void update( Observable whatChanged, Object message)
      {
      if ( message.equals( Counter.INCREASE) )
         increase();
      }
   }



Doc 24, AWT Observer Example Slide # 6Listen Here!

abstract class CounterButton

/**
 * An abstract class for changing a counter each time the button is 
 * pressed
 */

abstract class CounterButton extends Button
   {
   protected Counter count;
   
   public CounterButton( String buttonName, Counter count )
      {
      super( buttonName );
      this.count = count;
      }
      
   public boolean action( Event processNow, Object argument )
      {
      changeCounter();
      return true;
      }
   
   abstract protected void changeCounter();
   }


Doc 24, AWT Observer Example Slide # 7Listen Here!

class IncreaseButton

/**
 * A button that increases a counter each time the button is pressed
 */

class IncreaseButton extends CounterButton
   {
   public IncreaseButton( Counter count )
      { 
      super( "Increase", count ); 
      }

   protected void changeCounter()
      { 
      count.increase(); 
      }   
   }

class DecreaseButton

/**
 * A button that decreases a counter each time the button is pressed
 */

class DecreaseButton extends CounterButton
   {
   public DecreaseButton( Counter count )
      {
      super( "Decrease", count );
      }
      
   protected void changeCounter()
      { 
      count.decrease();
      }
   }


Doc 24, AWT Observer Example Slide # 8Listen Here!

class CounterView

/**
 * A parent window view that observes a counter
 */

class CounterView extends Frame implements Observer
   {
   public CounterView( String label, int x, int y, int width, int height )
      {
      setTitle( label );
      reshape(x, y,  width, height );
      setLayout( new FlowLayout() );
      }
   
   /**
    * Redraw the window when an observed counter changes
    */   

   public void update(Observable counter, Object argument)
      {
      repaint();
      }
   }
   

Doc 24, AWT Observer Example Slide # 9Listen Here!

class CounterTextView


/**
 * A window for displaying the value of a counter in ascii
 */

class CounterTextView extends CounterView 
   {
   Counter model;
   
   public CounterTextView( Counter model, String label, 
                        int x, int y, int width, int height )
      {
      super( label, x, y, width, height );
      this.model = model;
      model.addObserver( this );
      
      show();
      }
      
   public  void  paint(  Graphics  display  )  
      {
      int y = bounds().height - 20;
      int x = 20;
      display.drawString(  "The value of " + model.label() +
                      " is " + model , x, y  );
      }

   }



Doc 24, AWT Observer Example Slide # 10Listen Here!

class ButtonController

/**
 * A window for changing the value of a counter
 */

class  ButtonController extends CounterView 
   {   
   public ButtonController( Counter model, int x, int y, 
                        int width, int height )
      {
      super(  model.label(), x, y, width, height );
      model.addObserver( this );
      
      // show the value of the counter
      new CounterTextView( model, "Value of " + model.label(),
                         x + width + 5,y, 150, 50);

      // buttons to change counter
      add( new IncreaseButton( model ));
      add( new DecreaseButton( model ));
      show();
      }
   }


Doc 24, AWT Observer Example Slide # 11Listen Here!

class RectangleView

/**
 * Draws a colored rectangle that depends on two counters. One 
 * counter is the width of the rectangle, the other counter is the
 * height of the rectangle. The color of rectangle varies with its shape 
 */

class RectangleView  extends CounterView
   {
   Counter width;
   Counter height;
   
   public RectangleView( Counter rectWidth,  Counter rectHeight, 
                        int x, int y )
      {
      super( "Rectangle", x, y, 150, 150 );
      height =  rectHeight;
      width = rectWidth;
      rectWidth.addObserver( this );
      rectHeight.addObserver( this );
      show();
      }


Doc 24, AWT Observer Example Slide # 12Listen Here!
class RectangleView Continued
   public  void  paint(  Graphics  display  )  
      {
      int x = 10;
      int y = 10;
      
      // Magnify value by 5 to get a bigger visual effect
      int height =  5 * this.height.value();
      int width = 5 * this.width.value();
      
      // Determine color. Colors choosen for fun.
      // The factor of 3 is just to magnify effect of change
      if (( width >= 0 ) && ( height >= 0 ))
         display.setColor( new Color( 3*width, 3*height, 
                              width + height) );
      else if (( width < 0 ) && ( height >= 0 ))
         display.setColor( Color.pink );
      else if (( width >= 0 ) && ( height < 0 ))
         display.setColor( Color.orange );
      else if (( width < 0 ) && ( height < 0 ))
         display.setColor( Color.red );
      
      display.fillRect(x, y, Math.abs(width), Math.abs( height ) );
      }
   }




Doc 24, AWT Observer Example Slide # 13Listen Here!

Sample Program

class TestButton
   {
   public  static  void  main( String  args[] ){
      Counter x = new Counter( "x" );
      Counter y = new Counter( "y" );

      IncreaseDetector plus = new IncreaseDetector( "Pluses" );
      x.addObserver( plus ); 
      y.addObserver( plus ); 

      new ButtonControler( x,  30, 30, 150, 50 );
      new ButtonControler( y,  30, 100, 150, 50 );

      new CounterTextView( plus, "# of increases", 30, 170, 150, 50 );
      new RectangleView( x, y, 340, 30 );
      }
   }




Doc 24, AWT Observer Example Slide # 14Listen Here!
Runtime Object Interaction



----------