Event Handling in Java: Alternatives and Patterns

Event Handling in Java: Alternatives and Patterns Raja Sooriamurthi Information Systems Department Kelley School of Business Indiana University, Bloomington www.kelley.iu.edu/raja 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.

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

event object event listener event listener event listener event source Event Handling

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

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

Anatomy of a Button Object label color code handle

Inheritance Based Event Model (Java 1.0) Button 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(); } } Start

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.

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

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

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 ) Examples of First Class Values

7 5 -6 9 -2 -8 2 0 4 0 3 1 5 A Simple Example X = // 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 )

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

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

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

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

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

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

Callback Methods (contd.) 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 ); }

Observable / Observer Design Pattern 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 ( ... )

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

Event Handling in Java: Alternatives and Patterns