event handling in java alternatives and patterns n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Event Handling in Java: Alternatives and Patterns PowerPoint Presentation
Download Presentation
Event Handling in Java: Alternatives and Patterns

Loading in 2 Seconds...

play fullscreen
1 / 21

Event Handling in Java: Alternatives and Patterns - PowerPoint PPT Presentation


  • 123 Views
  • Uploaded on

Event Handling in Java: Alternatives and Patterns. Raja Sooriamurthi. Information Systems Department Kelley School of Business Indiana University, Bloomington. www.kelley.iu.edu/raja.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Event Handling in Java: Alternatives and Patterns' - marli


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
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
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 handling

event object

event

listener

event

listener

event

listener

event source

Event Handling
event handling models
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
giant case statement

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
Anatomy of a Button Object

label

color

code

handle

inheritance based event model java 1 0
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
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
Delegation Based Event Handling (Java 1.1 +)

Key Concepts:

  • First Class Values
  • Callback functions
first class values
First Class Values

Can …

  • store in a variable
  • pass to a function
  • return from a function

?

f

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 )

Examples of First Class Values
a simple example

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

}

}

better design with an interface

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
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
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
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
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
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
Summary
  • Ubiquity of event driven programming
  • Models of event handling
    • Big switch statement
    • Inheritance based
    • Delegation based
  • Some design patterns