CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2004 Observer & Singleton
	Previous    Lecture Notes Index    Next     © 2004, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 26-Feb-04

Doc 11, Observer & Singleton 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 11, Observer & Singleton Slide # 3

Structure

Doc 11, Observer & Singleton Slide # 4

Collaborations

Doc 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton Slide # 7

Smalltalk Implementation

Model handles dependents better

Doc 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton Slide # 11

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

Doc 11, Observer & Singleton Slide # 12

Java’s Implementation

Doc 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton Slide # 20

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

Doc 11, Observer & Singleton Slide # 21

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

Doc 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton Slide # 27

Scaling the Pattern

Doc 11, Observer & Singleton 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 11, Observer & Singleton 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 11, Observer & Singleton Slide # 30

Doc 11, Observer & Singleton Slide # 31

Singleton

Intent

Motivation

Applicability

• There must be only one instance of a class, and it must be accessible to clients from a well-known access point

• When the sole instance should be extensible by subclassing, and clients should be able to use an extended instance without modifying their code

Doc 11, Observer & Singleton Slide # 32

Doc 11, Observer & Singleton Slide # 33

Implementation

Java

// Only one object of this class can be created
class Singleton
   {
   private static Singleton _instance = null;
   
   private Singleton()   { fill in the blank }
   
   public static Singleton getInstance()
      {
      if (  _instance == null )
          _instance = new Singleton();
      return _instance;
      }
   public void otherOperations() { blank; }
   }
   
class Program
   {
   public void aMethod()
      {
      X = Singleton.getInstance();
      }
   }

Doc 11, Observer & Singleton Slide # 34

• No references to instances of the class
• No references to the class

• Disable class garbage collection with -Xnoclassgc flag

• Insure singleton or class always has a reference

Store singleton or class in system property

Doc 11, Observer & Singleton Slide # 35

C++

// Only one object of this class can be created
class Singleton
   {
   private:
      static Singleton* _instance;
      void otherOperations();
   protected:
      Singleton();
   public:
      static Singleton* getInstance();
   }
   
   
Singleton*  Singleton::_instance = 0;
Singleton* Singleton::getInstance()
   {
   if (  _instance == 0 )
       _instance = new Singleton;
   return _instance;
   }

Doc 11, Observer & Singleton Slide # 36

Smalltalk

Smalltalk.CS635 defineClass: #SingletonExample
   superclass: #{Core.Object}
   indexedType: #none
   private: false
   instanceVariableNames: ''
   classInstanceVariableNames: 'uniqueInstance '
   imports: ''
   category: 'Lecture notes'!

current
   uniqueInstance isNil ifTrue:[uniqueInstance := super new].
   ^uniqueInstance

new
   self error: 'Use current to get an instance of Class: ' , self name

Doc 11, Observer & Singleton Slide # 37

new
   uniqueInstance isNil ifTrue:[uniqueInstance := super new].
   ^uniqueInstance

| left right |
left := SingleWindow new.
Right := SingleWindow new.
left position: 100@ 100.
right position: 500@100.

Doc 11, Observer & Singleton Slide # 38

Doc 11, Observer & Singleton Slide # 39

Singletons and Static

• Classes do not inherit Object's protocol

• Hard to modify design if need more that one instance

• Builds bad habits in beginners

Doc 11, Observer & Singleton Slide # 40

Consequences

• Controlled access to sole instance
• Reduced name space
• Permits subclassing
• Permits a variable number of instances
• More flexible than class operations
• Leads to improper use of globals

Doc 11, Observer & Singleton Slide # 41

Questions for Thought

Doc 11, Observer & Singleton Slide # 42

Previous    visitors since 26-Feb-04    Next