Event-driven programming: listeners, anonymous classes, lambdas

The programs you have written so far ran from start to finish in order. A GUI program, on the other hand, waits after opening the window: when the user clicks a button, presses a key or moves the mouse, the related code runs. This is called event-driven programming. In the exam this topic brings “write a handler” questions, converting an anonymous class to a lambda, and compile errors (effectively final, missing public, wrong signature).

Golden rules:

1. Event source, event object, listener. When a button is clicked, Swing creates an ActionEvent and calls the actionPerformed method of every ActionListener registered on the button.
2. Registration is required. If you write a listener and do not attach it with addActionListener, nothing happens, and there is no error either.
3. A lambda works only with a single-method interface. ActionListener yes, MouseListener no.
4. A lambda and an anonymous class cannot modify a local variable. Make anything that will change a field.

The event model

The listeners you will use:

All of them are in the java.awt.event package: do not forget to write import java.awt.event.*;.

Four ways to write a handler

1. Inner class

A class defined inside another class that is not static. Its biggest advantage: it accesses the outer object’s private fields directly.

public class CounterPanel extends JPanel {
    private int count = 0;
    private final JButton button = new JButton("Click");
    private final JLabel label = new JLabel("Count: 0");

    public CounterPanel() {
        add(button);
        add(label);
        button.addActionListener(new ClickHandler());   // registration
    }

    private class ClickHandler implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            count++;                                     // field of the outer class
            label.setText("Count: " + count);
        }
    }
}

After three clicks:

Count: 3

2. The class itself is the listener

The class says implements ActionListener and registers itself with addActionListener(this). Several buttons share the same method; e.getSource() tells which one was clicked.

public class CalcPanel extends JPanel implements ActionListener {
    private final JTextField a = new JTextField("8", 4), b = new JTextField("2", 4);
    private final JButton plus = new JButton("+"), div = new JButton("/");
    private final JLabel result = new JLabel("=");

    public CalcPanel() {
        add(a); add(b); add(plus); add(div); add(result);
        plus.addActionListener(this);
        div.addActionListener(this);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        int x = Integer.parseInt(a.getText());
        int y = Integer.parseInt(b.getText());
        if (e.getSource() == plus) result.setText("= " + (x + y));
        else if (e.getSource() == div) result.setText("= " + (x / y));
        System.out.println("command=" + e.getActionCommand() + " " + result.getText());
    }
}

When + and then / are clicked, and then b is set to “0” and / is clicked again:

command=+ = 10
command=/ = 4
ArithmeticException: / by zero

The handler did not print the last line: the exception that was not caught inside the handler came out, and in the test run the try/catch around the doClick() call caught it. In a real window this exception goes up to Swing’s event thread and a stack trace is printed to the console. That is why you use try/catch inside a handler (see the TemperatureFrame example below).

3. Anonymous inner class

A class with no name, of which a single object is created at the place where it is written. It has the form new InterfaceName() { ...methods... }. You cannot new an interface, but if you add a body, that body becomes a nameless class that implements the interface.

JButton hello = new JButton("Hello");
JLabel msg = new JLabel();
hello.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        msg.setText("Hi, " + e.getActionCommand());
    }
});

msg.getText() after a click:

Hi, Hello

4. Lambda expression

An interface with a single abstract method is called a functional interface. ActionListener is one. In that case, instead of the whole template of the anonymous class, you write only the parameter and the body:

hello.addActionListener(e -> msg.setText("Hi, " + e.getActionCommand()));

If the body has more than one line, braces are used: e -> { line1; line2; }.

Captured variables and this

Anonymous classes and lambdas can use local variables from outside but cannot modify them. The local variable they use must be final or effectively final (never reassigned).

int count = 0;
b.addActionListener(e -> count++);   // DOES NOT COMPILE

local variables referenced from a lambda expression must be final or effectively final. Fields (instance variables) are not subject to this rule; use a field for counters, totals and state information.

this means different things in the two:

Inside Outer.wire(), Outer.toString() = "Outer":
  lambda:     this                            → Outer
  anonymous:  this.toString().equals("Outer") → false
  anonymous:  Outer.this                      → Outer

Mouse and adapter classes

MouseListener has five methods. So that you do not have to write all five when you are only interested in clicks, Java provides ready-made adapter classes: MouseAdapter, KeyAdapter, WindowAdapter. They implement all the methods of the interface with empty bodies; you override only what you want. Since an adapter is a class, it is used with an anonymous class, not a lambda.

JPanel area = new JPanel();
area.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("clicked at " + e.getX() + "," + e.getY());
    }
});

When the point (40, 25) is clicked:

clicked at 40,25

Checkbox and other events

JCheckBox and JRadioButton produce an ItemEvent when the selection changes. With e.getStateChange() == ItemEvent.SELECTED you learn whether it was checked; or directly with checkBox.isSelected().

JCheckBox bold = new JCheckBox("Bold");
bold.addItemListener(e -> System.out.println("bold=" + (e.getStateChange() == ItemEvent.SELECTED)));
// clicked twice

bold=true
bold=false

Other useful methods:

• button.setEnabled(false): the component turns gray and produces no events. In the test run, doClick() on a disabled button did not run the listener.
• button.removeActionListener(l): removes the registration. For this you need to keep the listener in a variable.
• textField.addActionListener(...): runs when Enter is pressed in the text field.

PITFALL · the order of several listeners. If you register two listeners on a button, both run. The Java documentation does not guarantee in which order they are called. In the test run (JDK 26) the last registered ran first: second registered, then first registered. In the exam, do not write code that depends on the order; do the two jobs in order inside a single handler.

Building a window from start to finish

Let’s add events to last week’s TemperatureFrame example. The order: define the components as fields, place them in the constructor, attach the listener at the end.

public class TemperatureFrame extends JFrame {
    private final JTextField celsiusField = new JTextField(6);
    private final JButton convertButton = new JButton("Convert");
    private final JLabel resultLabel = new JLabel("F: ?");

    public TemperatureFrame() {
        super("C to F");
        setLayout(new FlowLayout());
        add(new JLabel("Celsius:"));
        add(celsiusField);
        add(convertButton);
        add(resultLabel);

        convertButton.addActionListener(e -> {
            try {
                double c = Double.parseDouble(celsiusField.getText().trim());
                double f = c * 9 / 5 + 32;
                resultLabel.setText("F: " + f);
            } catch (NumberFormatException ex) {
                resultLabel.setText("Invalid number");
            }
        });

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(300, 100);
    }
}

When Convert is pressed with the value “100”, then ” 37 ”, then “abc”, the label shows:

F: 212.0
F: 98.6
Invalid number

The lambda parameter is e and the variable in the catch is ex. If you had used the same name (e), you would get a compile error: the lambda parameter is already defined in that scope.

Common mistakes

class CounterPanel extends JPanel {
    private int count = 0;
    private JButton button = new JButton("Click");
    private JLabel label = new JLabel("Count: 0");
    CounterPanel() {
        add(button); add(label);
        button.addActionListener(new ClickHandler());
    }
    private class ClickHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            count++;
            label.setText("Count: " + count);
        }
    }
}
// after 3 clicks: System.out.println(label.getText());

JButton b = new JButton("+1");
int count = 0;
b.addActionListener(e -> count++);

class Handler implements ActionListener {
    public void actionPerformed() {
        System.out.println("clicked");
    }
}

JPanel p = new JPanel();
p.addMouseListener(e -> System.out.println("click"));

// a = "8", b = "2"; both buttons call this same handler
public void actionPerformed(ActionEvent e) {
    int x = Integer.parseInt(a.getText());
    int y = Integer.parseInt(b.getText());
    if (e.getSource() == plus) result.setText("= " + (x + y));
    else if (e.getSource() == div) result.setText("= " + (x / y));
    System.out.println("command=" + e.getActionCommand() + " " + result.getText());
}
// user clicks "+" then "/"

JButton b = new JButton("ok");
b.addActionListener(new ActionListener());

hello.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        msg.setText("Hi, " + e.getActionCommand());
    }
});

convertButton.addActionListener(e -> {
    try {
        double c = Double.parseDouble(celsiusField.getText().trim());
        double f = c * 9 / 5 + 32;
        resultLabel.setText("F: " + f);
    } catch (NumberFormatException ex) {
        resultLabel.setText("Invalid number");
    }
});