1. Event Handling in Java: Alternatives and Patterns Raja Sooriamurthi www.kelley.iu.edu/raja Information Systems Department Kelley School of Business Indiana University, Bloomington Portions of this talk are from my presentation Prelude to the Java Event Model given at the 6th annual conference on Innovation and Technology in Computer Science Education (ITiCSE), June 2001, Canterbury, UK.

2. Concepts Event handling Event handling models Inheritance vs delegation based models Notion of first class values Use of interfaces Callback methods Observable / Observer pattern Learning is finding out what you already know. --- Richard Bach

3. Event Handling event source event listener event object event listener event listener

4. Event Handling Models Giant Case Statement MS Windows, X-Windows Object Oriented Models –Inheritance based MFC, Motif, Java 1.0 –Delegation based Java 1.1

5. Giant Case Statement case event of KEY_PRESS: action_1 MOUSE_CLICK: action_2 … end Extension => need to edit code No hierarchy of events Problems:

6. Anatomy of a Button Object label color handle code

7. Inheritance Based Event Model (Java 1.0) class Button { // other state information and behavior //... text //... color //... parent widget boolean handleEvent() { System.out.println( "button has been clicked" ) ; return true; } class Start extends Button { boolean handleEvent() { System.out.print( "Start... " ) ; return super.handleEvent(); } Button Start

8. Restrictions of the 1.0 Model Can not change the behavior of the start button at run-time. The inheritance chain is static. Computationally expensive. The action is being associated with the button. Should be associated with the application. Lots of classes needed.

9. Delegation Based Event Handling (Java 1.1 +) First Class Values Callback functions Key Concepts:

10. First Class Values store in a variable pass to a function return from a function Can … ? f

11. Examples of First Class Values Pascal C Lisp Scheme, Ruby Java scalar types (integer, real, char, boolean) arrays and records are not structs functions continuations objects methods are not first class (research systems like GJ and Pizza )

12. A Simple Example // count the positive numbers in an array class F { static int countPositive( int[] a ) { int cnt = 0; for (int i=0; i < a.length; i++) if ( a[i] > 0 ) cnt ++; return cnt; } Usage: F.countPositive( x ) 3 -6 57 -2 0 0 -8 9 4 2 5 1 X =

13. The Flexibility of First Class Objects class F { static int countIf( int[] a, Predicate pred ) { int cnt = 0; for (int i=0; i < a.length; i++) if (pred.test( a[i] )) cnt ++; return cnt; } class Predicate { public boolean test( int n ) { return( n > 0 ); } Usage: F.countIf(b, new Predicate() );

14. Abstracting Once More class F { static int countIf( int[] a, Predicate pred ) { int cnt = 0; for (int i=0; i < a.length; i++) if (pred.test( a[i]) ) cnt ++; return cnt; } class Predicate { public boolean test( int n ) { ? } } class IsPositive extends Predicate { public boolean test( int n ) { return( n > 0 ); }

15. interface Predicate { boolean test( int n ); } class IsPositive implements Predicate { public boolean test( int n ) { return( n > 0 ); } Better Design with an Interface Predicate IsPositive IsPrime …

16. Use of Anonymous Classes int[] a = { -4, -2, 0, 1, 3, 5, 7 }; int n1, n2; n1 = F.countIf( a, new IsPositive() ); // testing for -ve numbers with an anonymous class n2 = F.countIf( a, new Predicate() { public boolean test( int n ) { return( n<0 ); } );

17. Event Handling with Callbacks Observable Observer 1.Observers register themselves with each observable item they are interested in 2.Observables inform each interested observer when a relevant change occurs

18. Callback Methods investor = new Investor( "Bob" ); // each investor defines a call back method void on_change( Stock stk ) { System.out.println( "Price of " + stk ); if (stk.price < 10.00) { System.out.println ("... falls below 10.00... sell"); }

19. stk = new Stock( "ABC", 12.50 ); // register an investor stk.add_watch( investor ); // when a stock price changes... stk.percentChange( -10.5 ); // falls by 10.5 % //... the stock notifies the interested investors void percentChange( double change ) { price += price * (change/100.0); notifyInvestors(); } // the book keeping code is simple private Vector handlers = new Vector(); void add_watch( Investor p ){ handlers.add( p ); } void notifyInvestors() { for( int i=0; i<handlers.size(); i++ ) ((Investor) handlers.get(i)).on_change( this ); } Callback Methods (contd.)

20. class Stock extends Observable {... void percentChange (double change) { price += price*(change/100.0); setChanged(); notifyObservers(); } class Investor implements Observer {... public void update (Observable s, Object ignore){ Stock stk = (Stock) s;... } stk.addObserver (... ) Observable / Observer Design Pattern

21. Summary Ubiquity of event driven programming Models of event handling –Big switch statement –Inheritance based –Delegation based Some design patterns