Pourquoi utiliser des liaisons de touches au lieu d'écouteurs de touches dans les applications Swing ?

Comment utiliser les raccourcis clavier au lieu des auditeurs clés

Pourquoi envisager les raccourcis clavier ?

Les raccourcis clavier offrent des avantages par rapport aux auditeurs clés, notamment :

• Non besoin de cliquer sur les composants pour la saisie : Cela supprime les comportements déroutants pour les utilisateurs et permet à plusieurs objets de recevoir des entrées simultanément.
• Maintenance et manipulation plus faciles : Les liaisons simplifient la désactivation, la réaffectation et la réaffectation actions de l'utilisateur.

Clé d'implémentation Liaisons

Les liaisons de touches impliquent deux objets : InputMap et ActionMap. Un InputMap associe l'entrée de l'utilisateur à un nom d'action, tandis qu'un ActionMap mappe les noms d'action aux actions. Lorsqu'une touche est enfoncée, l'InputMap récupère le nom de l'action et l'ActionMap exécute l'action correspondante.

Ce processus est illustré dans le code suivant :

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

Utilisation de WHEN_IN_FOCUSED_WINDOW

Dans l'exemple donné, l'InputMap utilise WHEN_IN_FOCUSED_WINDOW, qui permet la saisie de composants dans une fenêtre ciblée. Ceci est approprié pour les scénarios dans lesquels plusieurs objets doivent recevoir une entrée simultanément.

Exemple de liaison de touches

L'exemple fourni dans le code de la question peut être modifié pour utiliser des liaisons de touches, comme indiqué ci-dessous :

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.
        }
    }
}

Fonctionnalités supplémentaires

Les raccourcis clavier fournissent des capacités :

• Relier les clés : Remplacez facilement la clé associée à une action.
• Désactivez les actions : Empêchez temporairement certaines actions d'être effectuée.
• Contrôlez directement les actions : Accédez directement à l'action pour contrôle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!