Event Listeners and Timers

1. Event Listeners and Timers

Title

Think Java 2e · Chapter 17 · Advanced Topics

Sections 17.8-17.9 · pp. 290-295

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 17 (Advanced Topics), Sections 17.8-17.9, pp. 290-295. Everything on these slides can be checked against those pages.

1. Write a class that implements more than one interface.

2. Read an image from a file and handle the exception that may result.

3. Implement the three KeyListener methods and explain when each is invoked.

4. Use a switch statement with deliberate fall-through to handle two cases identically.

5. Register a listener and give a component the keyboard focus.

6. Replace an animation loop with a Timer and an ActionListener.

• 17.8 — Event Listeners
• 17.9 — Timers

3. Retrieve before you read

Warm-up

Four things, and every one of them is about to be used at once.

4. The framework calls you

Concept

Every program so far has driven itself: a loop you wrote, calling methods you wrote. Event-driven programming inverts that — you write methods and something else decides when to call them.

• 17.8 — Sprite, and the KeyListener interface
• 17.8 — wiring a listener to a component
• 17.9 — Timer and ActionListener

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 17 (Advanced Topics), Sections 17.8-17.9, pp. 290-295 — Section 17.8 opens on printed page 290.

5. The Sprite class

Section

Section 17.8

6. Two interfaces at once

Concept

Here is the beginning of a class that reads an image from a file and shows the image moving across the canvas. The class is called Sprite because a moving image is sometimes called a sprite, in the context of computer graphics.

public class Sprite implements Actor, KeyListener {
    private int xpos;
    private int ypos;
    private int dx;
    private int dy;
    private Image image;

    public Sprite(String path, int xpos, int ypos) {
        this.xpos = xpos;
        this.ypos = ypos;
        try {
            this.image = ImageIO.read(new File(path));
        } catch (IOException exc) {
            exc.printStackTrace();
        }
    }
}

sprite — A computer graphic that may be moved or otherwise manipulated on the screen.

Sprite implements two interfaces: Actor and KeyListener. It extends nothing at all — which is only possible because both of the things it needs to be are interfaces rather than classes.

7. Reading a file that might not be there

Notation

The constructor's three lines of file handling repay a close reading.

A catch block should do something proportionate to what the exception means. Here the book chooses report and continue, which is honest for a teaching example and would deserve a harder look in real code.

8. The two Actor methods

Worked example

Actor requires that we provide draw and step methods.

public void draw(Graphics g) {
    g.drawImage(image, xpos, ypos, null);
}

public void step() {
    xpos += dx;
    ypos += dy;
}

9. What does Sprite extend?

Prediction

Look at the declaration.

public class Sprite implements Actor, KeyListener {

10. Position and velocity

Concept

Four integers, and the split between them is the standard way to animate anything.

step reads velocity and writes position; the key handlers write velocity and never touch position. That separation is why holding a key produces smooth movement rather than a single jump — the key sets a rate, and the timer applies it.

11. Moving the sprite in keyPressed

Trap

public void keyPressed(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
            ypos -= 5;      // moves once per event
            break;
        ...
    }
}

public void keyPressed(KeyEvent e) {
    case KeyEvent.VK_UP:
        dy = -5;            // sets a rate
}

public void step() {
    xpos += dx;             // applied every frame
    ypos += dy;
}

12. Position or velocity?

Definition probe

Which methods write which fields.

13. Read the image

Fill the middle

The file might not exist.

14. Is printStackTrace enough?

Socratic

The constructor catches, reports, and returns.

15. The KeyListener interface

Section

Section 17.8

16. Three methods the system calls

Concept

KeyListener is an interface for receiving keyboard events, which means we can detect and respond to key presses. A class that implements KeyListener has to provide the following methods.

void keyPressed(KeyEvent e)
void keyReleased(KeyEvent e)
void keyTyped(KeyEvent e)

These methods get invoked when the user presses and releases any key. They take a KeyEvent object as a parameter, which specifies which key was pressed, released, or typed. You never call them; the window system does — which is what event-driven means.

17. Three events for one keystroke

Notation

Pressing and releasing a key produces three separate calls, and knowing which is which matters.

Press-and-hold is a state, not an event. The design here uses keyPressed to enter that state and keyReleased to leave it — which is why the sprite moves for exactly as long as the key is down.

18. Responding to the arrow keys

Worked example

We can use these methods to design a simple animation using the arrow keys.

public void keyPressed(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
            dy = -5;
            break;
        case KeyEvent.VK_DOWN:
            dy = +5;
            break;
        case KeyEvent.VK_LEFT:
            dx = -5;
            break;
        case KeyEvent.VK_RIGHT:
            dx = +5;
            break;
    }
}

19. Which method fires repeatedly?

Prediction

Hold an arrow key down.

void keyPressed(KeyEvent e)
void keyReleased(KeyEvent e)
void keyTyped(KeyEvent e)

20. Stopping the motion

Concept

When the user releases the key, keyReleased sets dx or dy to 0, so the sprite stops moving in that direction.

public void keyReleased(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
        case KeyEvent.VK_DOWN:
            dy = 0;
            break;
        case KeyEvent.VK_LEFT:
        case KeyEvent.VK_RIGHT:
            dx = 0;
            break;
    }
}

The two vertical cases share one body, because releasing either up or down should stop vertical motion. This is Lesson 5a's fall-through used deliberately — two labels on one block, with the break only after the shared code.

21. Forgetting a required method

Trap

public class Sprite implements Actor, KeyListener {
    public void keyPressed(KeyEvent e) { ... }
    public void keyReleased(KeyEvent e) { ... }
    // no keyTyped
}

// error: Sprite is not abstract and does not override
//        abstract method keyTyped(KeyEvent) in KeyListener

public void keyTyped(KeyEvent e) {
    // do nothing
}

22. What happens with no default branch?

Prediction

The switch lists only four cases.

switch (e.getKeyCode()) {
    case KeyEvent.VK_UP:    dy = -5; break;
    case KeyEvent.VK_DOWN:  dy = +5; break;
    case KeyEvent.VK_LEFT:  dx = -5; break;
    case KeyEvent.VK_RIGHT: dx = +5; break;
}
// the user presses 'q'

23. Stop on release

Fill the middle

Two keys, one shared body.

24. What if you hold two arrows at once?

Edge cases

Up and right together.

25. Registering the listener

Section

Section 17.8

26. Implementing is not enough

Concept

Writing the three methods makes Sprite capable of receiving key events. It does not make anything send them.

Sprite sprite = new Sprite("face-smile.png", 25, 150);
drawing.add(sprite);
drawing.addKeyListener(sprite);
drawing.setFocusable(true);

Recall that the add method is one that we wrote in Section 17.5. It adds an Actor to the list of objects to be drawn. The second line is a different list entirely — and the same object is on both, which is why it implements two interfaces.

27. Two lists, and the focus

Notation

Three lines and every one of them is necessary. Missing any produces a different silent failure.

Key events are sent to components only when they have the keyboard focus. That is a rule about windows, not about Java — and forgetting it produces a program that works only after you click on it.

28. Diagnosing the three failures

Worked example

Each missing line fails silently and differently. Being able to tell them apart is most of debugging event code.

// what is missing if...
//   the sprite never appears           -> drawing.add
//   the sprite appears but never moves -> addKeyListener
//   it moves only after you click it   -> setFocusable

29. What does setFocusable do?

Prediction

Key events go somewhere specific.

drawing.setFocusable(true);

30. One object, two roles

Concept

Sprite is on two lists because it implements two interfaces, and each list wants a different capability.

Neither list knows about the other. Drawing's list holds Actors and would be perfectly happy with a polygon; the listener list holds KeyListeners and knows nothing about drawing. The object satisfies both contracts independently — which is the practical payoff of implements as many as needed.

31. Expecting events without registering

Trap

Sprite sprite = new Sprite("face-smile.png", 25, 150);
drawing.add(sprite);
// no addKeyListener

// the sprite is drawn, and the arrow keys do nothing

drawing.add(sprite);              // to be drawn
drawing.addKeyListener(sprite);   // to receive key events
drawing.setFocusable(true);       // so key events arrive at all

32. Which list, which method?

Definition probe

The same object on two lists.

33. Wire it up

Fill the middle

Draw it, listen to it, focus it.

34. Why are these two lists separate?

Explain it to yourself

The same object is on both.

35. Timers

Section

Section 17.9

36. A better way to animate

Concept

Now that you know about interfaces and events, we can show you a better way to create animations. Previously, we implemented the animation loop by using while (true) and Thread.sleep. Java provides a Timer class (in javax.swing) that encapsulates this behavior.

// The constructor for Timer takes two parameters:
//   int delay                  // milliseconds between events
//   ActionListener listener    // for handling timer events

Timer timer = new Timer(33, game);
timer.start();

A Timer is useful for executing code at regular intervals. It is the same idea as while (true) with a sleep — packaged, so that the loop, the delay and the exception handling are the library's problem rather than yours.

37. An interface with one method

Notation

The ActionListener interface requires only one method, actionPerformed.

Three interfaces in two lessons — Actor, KeyListener, ActionListener — and all three exist so that something else can call your code. That is what event-driven programming is.

38. The VideoGame class

Worked example

Using a Timer, we can reorganize the code in main by defining a class that implements ActionListener.

public class VideoGame implements ActionListener {
    private Drawing drawing;

    public VideoGame() {
        Sprite sprite = new Sprite("face-smile.png", 50, 50);
        drawing = new Drawing(800, 600);
        drawing.add(sprite);
        drawing.addKeyListener(sprite);
        drawing.setFocusable(true);

        JFrame frame = new JFrame("Video Game");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(drawing);
        frame.pack();
        frame.setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        drawing.step();
    }

    public static void main(String[] args) {
        VideoGame game = new VideoGame();
        Timer timer = new Timer(33, game);
        timer.start();
    }
}

39. How many times per second does actionPerformed run?

Prediction

The delay is in milliseconds.

Timer timer = new Timer(33, game);
timer.start();

40. The chain of calls, once per frame

Concept

One timer tick reaches every object on the canvas, through four calls that were each written separately.

Each link was written in a different section and none of them knows about the others. The Timer knows only ActionListener; VideoGame knows only Drawing; Drawing knows only Actor. Every join is an interface, which is why the pieces could be built independently.

41. Doing slow work in actionPerformed

Trap

public void actionPerformed(ActionEvent e) {
    drawing.step();
    loadNextLevelFromDisk();     // takes two seconds
}

public void actionPerformed(ActionEvent e) {
    drawing.step();     // update and repaint - fast
}

42. What replaces the while loop?

Prediction

There is no loop in VideoGame at all.

public static void main(String[] args) {
    VideoGame game = new VideoGame();
    Timer timer = new Timer(33, game);
    timer.start();
}

43. Who calls what?

Definition probe

Some methods you call; some are called on you.

44. Why is a Timer better than a loop?

Real world

The while loop worked for three chapters.

45. What the book built

Section

Sections 17.8-17.9 and back

46. Every interface exists so something can call you

Concept

At this point, you have all of the elements you need to write your own video games. Four callback mechanisms have appeared, and they are all the same shape.

In every row you write a method and something else decides when it runs. That inversion is what event-driven means, and interfaces are what make it possible — the caller needs a type it can rely on without knowing your class.

47. The finished program

Picture it

Six classes and three interfaces, and no two of them are tightly coupled.

Sprite implements two interfaces and extends nothing; VideoGame implements one. Every arrow into an interface is a promise that lets some other class call in without knowing what it is calling.

48. Tracing one frame

Worked example

The user is holding the right arrow key. Follow 33 milliseconds all the way through.

// the user holds RIGHT; the timer fires

49. Which interface declares it?

Definition probe

Three interfaces in this program.

50. What the whole book covered

Concept

We hope this final chapter has been a helpful summary of topics presented throughout the book.

Congratulations on making it to the end! Every technique in this last program was introduced somewhere earlier — the switch statement in Chapter 5, the try-catch in Chapter 15, the interfaces two sections ago. The chapter is a summary as much as a new topic.

51. Thinking event-driven means concurrent

Trap

// "keyPressed and actionPerformed are both being called,
//  so I need to worry about them interfering"

public void keyPressed(KeyEvent e) {
    synchronized (this) { dx = -5; }    // unnecessary here
}

public void keyPressed(KeyEvent e) {
    dx = -5;              // no locking needed
}

public void actionPerformed(ActionEvent e) {
    drawing.step();       // runs only when no handler is running
}

52. What holds the program open after main returns?

Prediction

main creates a timer, starts it, and ends.

public static void main(String[] args) {
    VideoGame game = new VideoGame();
    Timer timer = new Timer(33, game);
    timer.start();
}

53. Match the callback to its caller

Matching

Four methods you write and never call.

54. What could you build from here?

Real world

At this point, you have all of the elements you need to write your own video games.

55. The loop against the Timer

Comparison

Fill the blanks.

The last row is the practical difference. With a Timer, main finishes and the program is free to respond to everything else — which is why every graphical framework works this way.

56. The pattern to carry away

Pattern

Implement an interface, register the object, and let the framework call you.

// 1. implement the interface the framework declares
public class Sprite implements Actor, KeyListener {
    public void draw(Graphics g)      { ... }
    public void step()                { ... }
    public void keyPressed(KeyEvent e)  { dx = +5; }
    public void keyReleased(KeyEvent e) { dx = 0; }
    public void keyTyped(KeyEvent e)  { /* do nothing */ }
}

// 2. register the object with whatever sends the events
drawing.add(sprite);              // Actor
drawing.addKeyListener(sprite);   // KeyListener
drawing.setFocusable(true);       // so events arrive

// 3. let something else drive the repetition
Timer timer = new Timer(33, game);
timer.start();

• Input sets a velocity; the clock applies it. Never move things in a key handler.
• Two labels on one case body is deliberate fall-through, and it needs no comment when the intent is obvious.
• An interface method you do not want still has to exist — empty, with a comment.
• Event handlers run on the thread that keeps the interface alive, so keep them short.

57. Check: keyPressed

Check

Work it out before you click.

public void keyPressed(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
            dy = -5;
            break;
        ...
    }
}

58. Check: registration

Check

Work it out before you click.

Sprite sprite = new Sprite("face-smile.png", 25, 150);
drawing.add(sprite);
drawing.setFocusable(true);
// drawing.addKeyListener(sprite);  <- omitted

59. Check: Timer

Check

Work it out before you click.

VideoGame game = new VideoGame();
Timer timer = new Timer(33, game);
timer.start();

60. Every graphical program works this way

Real world

The structure of this last program is the structure of essentially every interactive application.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, out loud.

63. Exit ticket

Exit ticket

One question before you close the deck — and the book.

64. Draw the whole lesson

Connect it up

One page, from memory — and then close the book.

65. Recap

Recap

Two sections that hand the driving over to the framework — and the end of Think Java.

• Sprite implements two interfaces and extends nothing — a sprite is a moving image.
• ImageIO.read may throw an IOException, which the compiler insists you handle.
• Position and velocity are separate: keys set the velocity, step applies it.
• KeyListener declares three methods, and keyPressed repeats while a key is held.
• Two case labels on one body share the code — deliberate fall-through.
• Implementing is not registering: add, addKeyListener and setFocusable are all needed.
• A Timer takes a delay and an ActionListener, and replaces the while loop entirely.
• Handlers run on one thread, so they must be short.