1 / 30

Lecture 9: Java’s Observable & Observer

CSC 313 – Advanced Programming Topics. Lecture 9: Java’s Observable & Observer. Observer Pattern Intent. Efficiently perform 1 -to- many communication Easy to respond dynamically when event(s) occurs Can create many, many possible actions to occur

marcus
Download Presentation

Lecture 9: Java’s Observable & Observer

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. CSC 313 – Advanced Programming Topics Lecture 9:Java’s Observable & Observer

  2. Observer Pattern Intent • Efficiently perform 1-to-many communication • Easy to respond dynamically when event(s) occurs • Can create many, many possible actions to occur • Update which actions used throughout execution • Can also use to break mutual dependency • UML class diagram cycles split and managed • Dirty & ugly hack that also is incredibly useful

  3. Registering an Observer • Subjectadds & removes Observers as needed • Adding is simple • Events also simple, call Observers’ update method • Removing not as simple, but still not very hard • Requires some means of holding Observers • Array • ArrayList or LinkedList • HashMap

  4. Registering an Observer • Subjectadds & removes Observers as needed • Adding is simple • Events also simple, call Observers’ update method • Removing not as simple, but still not very hard • Requires some means of holding Observers • Array* • ArrayList or LinkedList • HashMap * Anyone who still did not object to this, fails BIG!

  5. Getting the Word Out • Calling Observers’ update methods is simple • But for call Observerneeds associated information • Not always clear what is best way to share this data • Must understand strengths & weaknesses of each • Push model is easiest of two approaches • Observers get data directly from Subject • Method’s parameters have values to be used • Another approach using pattern’s pull model • Subjectprovides strategy to Observers via a param • To get data, Observeruses strategies methods

  6. Observer Pattern in Java • Java ♥ Observer Pattern & uses everywhere • Find pattern in JButton & ActionListeners • Tracking mouse in Swing using Observer Pattern • Much of the multi-threaded API uses this • Event-based code needs Observers to work • Not limited to Java; true for most OO languages

  7. java.util.Observable • Among original classes included in Java • Works with java.util.Observer interface • Observable manages Observersin code void addObserver(Observer o)void deleteObserver(Observer o)void deleteObservers() intcountObservers()

  8. Handling Updates • Observable approach supports push… void notifyObserver(Object arg) … & pull model available as well void notifyObserver()booleanhasChanged()void clearChanged()void setChanged() • Notifications sent to Observer’s only method void update(Observableo, Object arg)

  9. Using Observable Problem public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.notifyObservers(“Go drinking!”);} }

  10. Using Observable Problem public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.notifyObservers(“Go drinking”);} }

  11. Using Observable Problem public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.notifyObservers(“Go drinking”);} }

  12. Bad & Worse Design Decisions • No update was sent

  13. Bad & Worse Design Decisions • No update was sent; sobriety ruled the day

  14. Bad & Worse Design Decisions • No update was sent; sobriety ruled the day

  15. Bad & Worse Design Decisions • No update was sent; sobriety ruled the day • notifyObservers misnamed horribly • Should be notifyObserversIfChanged • Must call setChangedbefore notifying • Use of notifyObservers inconsistent, too • Calls clearChanged automatically once updates sent

  16. Updated Code public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.setChanged();obs.notifyObservers(“Go drinking”);} }

  17. Next Attempt public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.setChanged();obs.notifyObservers(“Go drinking”);} }

  18. Next Attempt public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.setChanged();obs.notifyObservers(“Go drinking”);} }

  19. Next Attempt public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.setChanged();obs.notifyObservers(“Go drinking”);} }

  20. Next Attempt public class CSCClass {private Observable obs;// Lots of unimportant code herepublic void cancelClass() {obs.setChanged();obs.notifyObservers(“Go ski”);} } setChanged has protected access

  21. %&#*@ Awful Design

  22. %&#*@ Awful Design • setChanged & clearChangedprotected access • java.util package is sealed; cannot write class for it • Can only be called & used from within subclass • Must write subclass of Observable to use it • As this is Java, that class cannot extend others • Updates received in method of Observer: void update(Observable o, Object arg) • This really means that can onlypush 1 object • Kills point of push model since cannot push much

  23. %&#*@ Awful Design • setChanged & clearChangedprotected access • java.util package is sealed; cannot write class for it • Can only be called & used from within subclass • Must write subclass of Observableto use it • As this is Java, that class cannot extend others • Updates received in method of Observer: void update(Observable o, Object arg) • This really means that can onlypush 1 object • Kills point of push model since cannot push much Useless

  24. Final Attempt public class CSCClassextends Observable {public void cancelClass() {setChanged(); notifyObservers(“Go drinking”);} } public class Student implements Observer {public void update(Observable o, Object arg) { String s = (String)arg; if (!s.equals(“Get here NOW!!!”)) // Go drinking else // Go to class} }

  25. Final Attempt public class CSCClassextends Observable{public void cancelClass() {setChanged(); notifyObservers(“Go drinking”);} } public class Student implements Observer{public void update(Observable o, Object arg) { String s = (String)arg; if (!s.equals(“Get here NOW!!!”)) // Go drinking else // Go to class with a drink} }

  26. Final Attempt

  27. Final Attempt

  28. Observable Pros & Cons • Cons: • Pros:

  29. Observable Pros & Cons • Cons: • Need a subclass of Observableto use • Must call setChange before notifyObservers • Can push only 1 object to Observers • Pros: • Already has code to add & remove Observers • Easy to rewrite and improve upon this design

  30. For Next Lecture • Two (short) readings available on web • Will start looking into how code is optimized • How does Java run & make programs faster? • What can we do to make our code faster? • Using final can be huge. Why would it matter? • Lab #2 due at week’s end & still on Angel • Make sure that you also check the grading rubric • Use Assignment Submitter when turning it in

More Related