Event-Driven Programming

Starter: think before typing

Before running this events example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Button clicked`; predict how the focus line helps produce that evidence.

Learning Objectives

• Explain event, listener and handler.
• Describe control flow in an event-driven program.
• Keep interface code separate from model logic.
• Test event responses.

Learning Outcomes

• By the end of the lesson, you can explain event, listener and handler.
• By the end of the lesson, you can describe control flow in an event-driven program.
• By the end of the lesson, you can keep interface code separate from model logic.
• By the end of the lesson, you can test event responses.

Why this idea exists

Event-driven programming became central as interactive systems replaced purely batch-style programs. Instead of one fixed sequence from start to finish, the program waits for user actions, messages or system events.

Graphical interfaces, games, web applications and many networked systems all rely on this model. It changes how programmers think about control flow because the next action may come from outside the program.

Good event-driven design keeps event handlers small. The handler should translate the event and delegate real work to model or service code that can be tested independently.

Deep dive

Lesson visual

Type this and run it

Create EventDrivenProgrammingDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

import java.util.ArrayList;
import java.util.List;

public class EventDrivenProgrammingDemo {
  public static void main(String[] args) {
    Button button = new Button();
    button.onClick(() -> System.out.println("Button clicked"));
    button.click();
  }
}

class Button {
  private final List<Runnable> listeners = new ArrayList<>();

  void onClick(Runnable listener) {
    listeners.add(listener);
  }

  void click() {
    for (Runnable listener : listeners) listener.run();
  }
}

Build and run it with:

javac EventDrivenProgrammingDemo.java && java EventDrivenProgrammingDemo

Expected baseline: Button clicked

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is button.onClick(() -> System.out.println("Button clicked"));; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in event-driven programming is treating the example as a finished answer. For events, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

How to study this lesson

For Event-Driven Programming, predict how events changes the run before you press Run.

Use the first portfolio task as your main edit: Create a button-click counter or equivalent event task.

Use the second task as your variation: Draw the event flow.

Finish with evidence, not a diary entry: Move business logic out of the handler.

Portfolio Practice

1. Create a button-click counter or equivalent event task.
2. Draw the event flow.
3. Move business logic out of the handler.

Final self-check

Study route

Practise events by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Operator-Style API Design and carry forward one improvement from this lesson into the next program.