CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2002 Observer
	Previous    Lecture Notes Index    Next     © 2002, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 11-Apr-02

Doc 13, Observer Slide # 2

Observer

• 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.

Doc 13, Observer Slide # 3

Structure

Doc 13, Observer Slide # 4

Collaborations

Doc 13, Observer Slide # 5

public class Subject {
   Window display;
   public void someMethod() {
      this.modifyMyStateSomeHow();
      display.addText( this.text() );
   }
}

public class Subject {
   ArrayList observers = new ArrayList();
   
   public void someMethod() {
      this.modifyMyStateSomeHow();
      changed();
   }
   
   private void changed() {
      Iterator needsUpdate = observers.iterator();
      while (needsUpdate.hasNext() )
         needsUpdate.next().update( this );
   }
}
   
public class SampleWindow {
   public void update(Object subject) {
      text = ((Subject) subject).getText();
      etc.
   }
}
Doc 13, Observer Slide # 6

Consequences

• Abstract coupling between Subject and Observer

• Support for broadcast communication

• Unexpected updates

Simple change in subject can cause numerous updates, which can be expensive or distracting

• Updates can take too long

Subject cannot perform any work until all observers are done

Doc 13, Observer Slide # 7

Smalltalk Implementation

Model handles dependents better

Doc 13, Observer Slide # 8

update: anAspectSymbol with: aParameter

update: anAspectSymbol with: aParameter from: aSender

Receive an update message from a Model(Subject)

Receiver changed.

return collection of all dependents

Doc 13, Observer Slide # 9

Smalltalk Example

Smalltalk.CS635 defineClass: #Counter
   superclass: #{Core.Object}
   indexedType: #none
   private: false
   instanceVariableNames: 'count '
   classInstanceVariableNames: ''
   imports: ''
   category: 'Observer Examples'

new
   ^super new initialize 

decrease
   count := count - 1.
   self changed: #decrease

increase
   count := count + 1.
   self changed: #increase

initialize
   count := 0

printOn: aStream
   aStream
      nextPutAll: count printString 

Doc 13, Observer Slide # 10

on: aCounter
   | detector |
   detector := super new.
   aCounter    addDependent: detector.
   ^detector 

update: anAspectSymbol with: aParameter from: aSender
   anAspectSymbol = #increase ifTrue:
      [Transcript 
          show: 'Count is now: ' , aSender printString;
         cr] 

Doc 13, Observer Slide # 11

| counter |
counter := Counter new.
IncreaseDetector on: counter.
counter
   increase;
   decrease;
   decrease;
   increase

Doc 13, Observer Slide # 12

Java’s Implementation

Doc 13, Observer Slide # 13

Adds an observer to the observer list.

Clears an observable change.

Counts the number of observers.

Deletes an observer from the observer list.

Deletes observers from the observer list.

Returns a true boolean if an observable change has occurred.

Notifies all observers if an observable change occurs.

Notifies all observers of the specified observable change which occurred.

Sets a flag to note an observable change.

Called when observers in the observable list need to be updated

Doc 13, Observer Slide # 14

A Java Example

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

class IncreaseDetector implements Observer
   {
   public void update( java.util.Observable whatChanged, 
                     java.lang.Object message)
      {
      if ( message.equals( Counter.INCREASE) ) 
         {
         Counter increased = (Counter) whatChanged;
         System.out.println( increased.label() + " changed to " + 
                              increased.value());
         }   
      }
   }

Doc 13, Observer Slide # 16

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

class IncreaseButton extends CounterButton
   {
   public IncreaseButton( Counter count )
      { 
      super( "Increase", count ); 
      }
   protected void changeCounter()
      { 
      count.increase(); 
      }   
   }
Doc 13, Observer Slide # 17
class DecreaseButton extends CounterButton
   {
   public DecreaseButton( Counter count )
      {
      super( "Decrease", count );
      }
      
   protected void changeCounter()
      { 
      count.decrease();
      }
   }

class ButtonController extends Frame
   {
   public ButtonController( Counter model, int x, int y, 
                        int width, int height )
      {
      setTitle( model.label() );
      reshape(x, y,  width, height );
      setLayout( new FlowLayout() );
      
      // buttons to change counter
      add( new IncreaseButton( model ));
      add( new DecreaseButton( model ));
      show();
      }
   }

Doc 13, Observer Slide # 18

class TestButton
   {
   public  static  void  main( String  args[] ){
      Counter x = new Counter( "x" );
      Counter y = new Counter( "y" );
   
      IncreaseDetector plus = new IncreaseDetector(  );
      x.addObserver( plus ); 
      y.addObserver( plus ); 
   
      new ButtonController( x,  30, 30, 150, 50 );
      new ButtonController( y,  30, 100, 150, 50 );
      }
 
Doc 13, Observer Slide # 19

Implementation Issues

public class Observable {
    private boolean changed = false;
    private Vector obs;
   
public Observable() {
        obs = new Vector();
    }
   
public synchronized void addObserver(Observer o) {
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

Doc 13, Observer Slide # 20

update: anAspectSymbol with: aParameter from: aSender
   anAspectSymbol = #increase ifTrue:
      [Transcript 
          show: 'Count is now: ' , aSender printString;
         cr] 

Doc 13, Observer Slide # 21

Observer reference to Subject may keep Subject around after Subject is not needed

Doc 13, Observer Slide # 22

• Have methods that change the state trigger update

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

If there are several of changes at once, you may not want each change to trigger an update

It might be inefficient or cause too many screen updates

class Counter extends Observable 
      {   // some code removed
      public void increase()  {    count++;    }
      }
Counter pageHits = new Counter();
pageHits.increase();
pageHits.increase();
pageHits.increase();
pageHits.notifyObservers();

Doc 13, Observer Slide # 23

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

class MySubclass extends ComplexObservable
   {
   Gear backEnd = new Gear();
      
   public void trickyChange()
      {
      super.trickyChange();
      backEnd.yetAnotherChange();
      setChanged();
      notifyObservers( ); 
      }
   }

Doc 13, Observer Slide # 24

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

Doc 13, Observer Slide # 25

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

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

Doc 13, Observer Slide # 27

Scaling the Pattern

Doc 13, Observer Slide # 28

ComponentEvent

FocusEvent

KeyEvent

MouseEvent

MouseListener

MouseMotionListener

mouseClicked()

mouseEntered()

mousePressed()

mouseReleased()

• Only register for events of interest
• Don't need case statements to determine what happened

Doc 13, Observer Slide # 29

• Simplifies the main object
• Observers can register for only the data they are interested in

• Set/get the value

Setting the value notifies the observers of the change

• Add/Remove dependents

Doc 13, Observer Slide # 30

Previous    visitors since 11-Apr-02    Next