CS 696: Advanced OO
Spring Semester, 1997
Doc 18 Observer

Doc 18 Observer Slide # 1

Observer

Use the Observer pattern:

• When an abstraction has two aspects, one dependent on the other.

• When a change to one object requires changing others, and you don't how many objects need to be changed

• When an object should be able to notify other objects without making assumptions about who these objects are.
  

Java Example

Java's observer interface is the Observer abstract class in the pattern

Java's Observable class is the Subject abstract class in the pattern

Doc 18 Observer Slide # 2

Doc 18 Observer Slide # 3

Class Descriptions

Counter

CounterButton

Doc 18 Observer Slide # 4

Doc 18 Observer Slide # 5

/**
 * 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 18 Observer Slide # 6

class IncreaseDetector

/**
 * IncreaseDetector is an observer that observes counters. 
 * IncreaseDetector counts the number of times one of its observables 
 * 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 18 Observer Slide # 7

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 18 Observer Slide # 8

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 18 Observer Slide # 9

/**
 * 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 18 Observer Slide # 10

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 18 Observer Slide # 11

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 18 Observer Slide # 12

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 18 Observer Slide # 13

     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 chosen 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 18 Observer Slide # 14

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 18 Observer Slide # 15

Runtime Object Interaction

Doc 18 Observer Slide # 16

Implementation Issues

Mapping subjects(Observables) to observers

Observing more than one subject

Pass information in the update method

Doc 18 Observer Slide # 17

• Have methods that change the state trigger update
  
  

class Counter extends Observable 

{// some code removed
public void increase() 

{ 
count++; 
setChanged();
notifyObservers( INCREASE ); 
}
}

It might be inefficient or cause too many screen updates

• Have clients call Notify at the right time
  

class Counter extends Observable 


{// some code removed
public void increase()  { count++; }
}

{
Counter pageHits = new Counter();
pageHits.increase();
pageHits.increase();
pageHits.increase();

pageHits.notifyObservers();
}

Doc 18 Observer Slide # 18

Make sure Subject is self-consistent before Notification

class ComplexObservable extends Observable
     {
     Widget frontPart = new Widget();
     Gadget internalPart = new Gadget();
     
     public void trickyChange()
          {
          frontPart.widgetChange();
          internalpart.anotherChange();
          setChanged();
          notifyObservers( ); 
          }
     }
     
class MyBetterClass extends ComplexObservable
     {
     Gear backEnd = new Gear();
          
     public void trickyChange()
          {
          super.trickyChange();
          backEnd.yetAnotherChange();
          setChanged();
          notifyObservers( ); 
          }
     }

Doc 18 Observer Slide # 19

class ComplexObservable extends Observable
     {
     Widget frontPart = new Widget();
     Gadget internalPart = new Gadget();
     
     /**
      * Trigger update to observers
      */
     public void trickyChange()
          {
          doThisChangeWithFactoryMethod();
          setChanged();
          notifyObservers( ); 
          }

     private void doThisChangeWithFactoryMethod()
          {
          frontPart.widgetChange();
          internalpart.anotherChange();
          }
     }
     
class MyBetterClass extends ComplexObservable
     {
     Gear backEnd = new Gear();
          
     private void doThisChangeWithFactoryMethod()
          {
          backEnd.yetAnotherChange();
          }
     }

Doc 18 Observer Slide # 20

Adding information about the change

class IncreaseDetector extends Counter implements Observer
     { // stuff not shown
          
     public void update( Observable whatChanged, Object
message)
          {
          if ( message.equals( INCREASE) )
               increase();
          }
     }

class Counter extends Observable 
     {          // some code removed
     public void increase() 
          { 
          count++; 
          setChanged();
          notifyObservers( INCREASE ); 
          }
     }

Doc 18 Observer Slide # 21

class IncreaseDetector extends Counter implements Observer
     { // stuff not shown
          
     public void update( Observable whatChanged )
          {
          if ( whatChanged.didYouIncrease() )
               increase();
          }
     }


class Counter extends Observable 

{// some code removed
public void increase() 

{ 
count++; 
setChanged();
notifyObservers( ); 
}
}