KeyEvent Tutorial for Java Swing/AWT Applications

[pwgit-create]

In Java Swing and AWT applications, the KeyEvent class is used to handle keyboard input. Understanding how to
work with KeyEvent is crucial for creating interactive GUI applications. This tutorial will guide you through
the basics of using KeyEvent in a Swing/AWT application.

Table of Contents

1. Introduction
2. Setting Up the Environment
3. Basic Key Listener
4. Handling Specific Keys
5. Key Codes and Constants
6. Example: Simple Calculator

Introduction

The KeyEvent class is part of the Java AWT (Abstract Window Toolkit) event model. It represents keyboard events,
such as key presses, key releases, and key type actions. In Swing applications, you typically use key listeners to
handle these events.

Setting Up the Environment

Before we start coding, make sure you have a Java development environment set up. You can use any IDE like
IntelliJ IDEA, Eclipse, or NetBeans, or simply use a text editor and compile your code from the command line.

Here's a simple setup to get started:

1. Create a new Java project.
2. Add a main class with a main method.
3. Import necessary Swing/AWT packages:

   import javax.swing.*;
   import java.awt.event.KeyEvent;
   import java.awt.event.KeyListener;

Basic Key Listener

To handle key events, you need to implement the KeyListener interface and override its methods. Here's a basic
example:

public class KeyEventDemo extends JFrame implements KeyListener {

    public KeyEventDemo() {
        // Set up the frame
        setTitle("Key Event Demo");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);

        // Add key listener to the frame
        addKeyListener(this);
    }

    @Override
    public void keyPressed(KeyEvent e) {
        System.out.println("Key Pressed: " + KeyEvent.getKeyText(e.getKeyCode()));
    }

    @Override
    public void keyReleased(KeyEvent e) {
        System.out.println("Key Released: " + KeyEvent.getKeyText(e.getKeyCode()));
    }

    @Override
    public void keyTyped(KeyEvent e) {
        System.out.println("Key Typed: " + e.getKeyChar());
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new KeyEventDemo());
    }
}

In this example:

• keyPressed is called when a key is pressed down.
• keyReleased is called when a key is released.
• keyTyped is called when a character is typed.

Handling Specific Keys

You can handle specific keys by checking the key code in the event. For example, let's add functionality to react
to the Enter and Escape keys:

@Override
public void keyPressed(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_ENTER:
            System.out.println("Enter key pressed");
            break;
        case KeyEvent.VK_ESCAPE:
            System.out.println("Escape key pressed");
            break;
        default:
            System.out.println("Key Pressed: " + KeyEvent.getKeyText(e.getKeyCode()));
    }
}

Key Codes and Constants

The KeyEvent class provides several constants for common keys. Here are some examples:

• VK_ENTER: Enter key
• VK_ESCAPE: Escape key
• VK_SPACE: Space key
• VK_LEFT, VK_RIGHT, VK_UP, VK_DOWN: Arrow keys

You can find a complete list of key codes in the Java
Documentation.

Example: Simple Calculator

Let's create a simple calculator that responds to number keys and basic arithmetic operations:

import javax.swing.JFrame;
import java.awt.event.KeyEvent;
import javax.swing.SwingConstants;
import java.awt.event.KeyListener;
import javax.swing.JLabel;
import java.awt.BorderLayout;


import javax.swing.SwingUtilities;

public class Calculator extends JFrame implements KeyListener {

    private JLabel display;

    public Calculator() {
        setTitle("Simple Calculator");
        setSize(300, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        display = new JLabel("0", SwingConstants.RIGHT);
        add(display, BorderLayout.NORTH);

        addKeyListener(this);
        setFocusable(true);

        setVisible(true);
    }

    @Override
    public void keyPressed(KeyEvent e) {
        switch (e.getKeyCode()) {
            case KeyEvent.VK_0:
            case KeyEvent.VK_1:
            case KeyEvent.VK_2:
            case KeyEvent.VK_3:
            case KeyEvent.VK_4:
            case KeyEvent.VK_5:
            case KeyEvent.VK_6:
            case KeyEvent.VK_7:
            case KeyEvent.VK_8:
            case KeyEvent.VK_9:
                appendToDisplay(KeyEvent.getKeyText(e.getKeyCode()));
                break;
            case KeyEvent.VK_PLUS:
                appendToDisplay(" + ");
                break;
            case KeyEvent.VK_MINUS:
                appendToDisplay(" - ");
                break;
            case KeyEvent.VK_MULTIPLY:
                appendToDisplay(" * ");
                break;
            case KeyEvent.VK_DIVIDE:
                appendToDisplay(" / ");
                break;
            case KeyEvent.VK_ENTER:
                calculate();
                break;
            default:
                // Ignore other keys
        }
    }

    private void appendToDisplay(String text) {
        display.setText(display.getText() + text);
    }

    private void calculate() {
        try {
            String expression = display.getText().replaceAll(" ", "");
            double result = eval(expression);
            display.setText(Double.toString(result));
        } catch (Exception ex) {
            display.setText("Error");
        }
    }

    // Simple evaluator for basic arithmetic expressions
    private double eval(final String str) {
        return new Object() {
            int pos = -1, ch;

            void nextChar() {
                ch = (++pos < str.length()) ? str.charAt(pos) : -1;
            }

            boolean eat(int charToEat) {
                while (ch == ' ') nextChar();
                if (ch == charToEat) {
                    nextChar();
                    return true;
                }
                return false;
            }

            double parse() {
                nextChar();
                double x = parseExpression();
                if (pos < str.length()) throw new RuntimeException("Unexpected: " + (char) ch);
                return x;
            }

            // Grammar:
            // expression = term | expression + term | expression - term
            // term = factor | term * factor | term / factor
            // factor = + factor | - factor | number

            double parseExpression() {
                double x = parseTerm();
                for (; ; ) {
                    if (eat('+')) x += parseTerm(); // addition
                    else if (eat('-')) x -= parseTerm(); // subtraction
                    else return x;
                }
            }

            double parseTerm() {
                double x = parseFactor();
                for (; ; ) {
                    if (eat('*')) x *= parseFactor(); // multiplication
                    else if (eat('/')) x /= parseFactor(); // division
                    else return x;
                }
            }

            double parseFactor() {
                if (eat('+')) return parseFactor();
                if (eat('-')) return -parseFactor();

                double x = 0;
                boolean decimalPointEncountered = false;

                while ((ch >= '0' && ch <= '9') || ch == '.') {
                    if (ch == '.') {
                        if (!decimalPointEncountered) {
                            decimalPointEncountered = true;
                            nextChar();
                        } else throw new RuntimeException("Unexpected: " + (char) ch);
                    }
                    x = x * 10 + ch - '0';
                    nextChar();
                }

                return x / (decimalPointEncountered ? Math.pow(10, pos - String.valueOf(x).length()) : 1);
            }
        }.parse();
    }

    @Override
    public void keyReleased(KeyEvent e) {
        // Not used in this example
    }

    @Override
    public void keyTyped(KeyEvent e) {
        // Not used in this example
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Calculator());
    }
}

In this calculator example:

• Number keys (0-9) append digits to the display.
• Arithmetic operators (+, -, *, /) are handled and displayed as part of the expression.
• The Enter key triggers the calculation.

This tutorial should give you a solid foundation for working with KeyEvent in Java Swing/AWT applications.
Experiment with different keys and event handlers to create more complex interactions!

[lilstiffy]

This is actually really cool!
So in theory it's possible to make a snake game in Java Swing!
I'll actually do it for the memes some time in the future haha 😎

I'll think of this when working on the GUI, maybe we can do something cool with it.

Thanks for sharing the knowledge 🫡 @pwgit-create