Why Use Key Bindings Instead of Key Listeners in Swing Applications?

How to Utilize Key Bindings Instead of Key Listeners

Why Consider Key Bindings?

Key bindings offer advantages over key listeners, including:

• No need to click components for input: This removes confusing behavior for users and allows multiple objects to receive input simultaneously.
• Easier maintenance and manipulation: Bindings simplify disabling, rebinding, and reassigning user actions.

Implementing Key Bindings

Key bindings involve two objects: InputMap and ActionMap. An InputMap associates user input with an action name, while an ActionMap maps action names to actions. When a key is pressed, the InputMap retrieves the action name and the ActionMap executes the corresponding action.

This process is illustrated in the following code:

myComponent.getInputMap().put("userInput", "myAction");
myComponent.getActionMap().put("myAction", action);

Using WHEN_IN_FOCUSED_WINDOW

In the given example, the InputMap uses WHEN_IN_FOCUSED_WINDOW, which allows input for components within a focused window. This is appropriate for scenarios where multiple objects need to receive input simultaneously.

Key Binding Example

The provided example in the question code can be modified to use key bindings, as shown below:

import javax.swing.*;

public class MyGame extends JFrame {

    private static final String MOVE_UP = "move up";
    private static final String MOVE_DOWN = "move down";
    private static final String FIRE = "move fire";

    static JLabel obj1 = new JLabel();
    static JLabel obj2 = new JLabel();

    public MyGame() {

        obj1.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("UP"), MOVE_UP);
        obj1.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("DOWN"), MOVE_DOWN);
        obj1.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("control CONTROL"), FIRE);

        obj1.getActionMap().put(MOVE_UP, new MoveAction(1, 1));
        obj1.getActionMap().put(MOVE_DOWN, new MoveAction(2, 1));
        obj1.getActionMap().put(FIRE, new FireAction(1));

        obj2.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("W"), MOVE_UP);
        obj2.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("S"), MOVE_DOWN);
        obj2.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("T"), FIRE);

        obj2.getActionMap().put(MOVE_UP, new MoveAction(1, 2));
        obj2.getActionMap().put(MOVE_DOWN, new MoveAction(2, 2));
        obj2.getActionMap().put(FIRE, new FireAction(2));

        add(obj1);
        add(obj2);
    }

    static void rebindKey(KeyEvent ke, String oldKey) {

        obj1.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .remove(KeyStroke.getKeyStroke(oldKey));
        obj1.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStrokeForEvent(ke),
                        obj1.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                                .get(KeyStroke.getKeyStroke(oldKey)));
    }

    public static void main(String[] args) {

        new MyGame();
    }

    private class MoveAction extends AbstractAction {

        int direction;
        int player;

        MoveAction(int direction, int player) {

            this.direction = direction;
            this.player = player;
        }

        @Override
        public void actionPerformed(ActionEvent e) {

            // Implement move action for the player.
        }
    }

    private class FireAction extends AbstractAction {

        int player;

        FireAction(int player) {

            this.player = player;
        }

        @Override
        public void actionPerformed(ActionEvent e) {

            // Implement fire action for the player.
        }
    }
}

Additional Features

Key bindings provide additional capabilities:

• Rebind keys: Easily replace the key associated with an action.
• Disable actions: Temporarily prevent certain actions from being performed.
• Control actions directly: Access the action directly for further control.

The above is the detailed content of Why Use Key Bindings Instead of Key Listeners in Swing Applications?. For more information, please follow other related articles on the PHP Chinese website!