Gestion des clés Java Swing : liaisons de touches ou écouteurs de clés – Lequel devriez-vous choisir ?

Reliures de touches et écouteurs de touches dans Java Swing : un guide complet

Les liaisons de touches et les écouteurs de touches sont deux approches pour gérer les événements de saisie utilisateur à partir de clés dans les applications Java Swing. Alors que les écouteurs de touches offrent un moyen simple de détecter les pressions sur les touches, les raccourcis clavier offrent plusieurs avantages, notamment :

• Réactivité améliorée : Les raccourcis clavier n'obligent pas l'utilisateur à cliquer sur un objet. pour lui donner le focus, conduisant à une gestion des entrées plus rapide et plus intuitive.
• Maintenabilité améliorée : Les raccourcis clavier permettent pour faciliter la désactivation, la réaffectation et la réaffectation des actions de l'utilisateur, simplifiant ainsi la maintenance et la lisibilité du code.

Comprendre les liaisons de touches

Les liaisons de touches impliquent deux objets :

• InputMap : Mappe l'entrée de l'utilisateur à une action nom.
• ActionMap : Mappe un nom d'action à une action.

Lorsqu'une touche est enfoncée, la carte d'entrée recherche la clé et trouve une action nom. La carte d'action recherche ensuite le nom de l'action et exécute l'action.

Implémentation des liaisons de touches

Pour créer une seule liaison de touches, utilisez la structure suivante :

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

Utilisation de WHEN_IN_FOCUSED_WINDOW InputMap

L'InputMap pour WHEN_IN_FOCUSED_WINDOW permet à plusieurs composants dans une fenêtre ciblée de recevoir des entrées simultanément. Par exemple, si vous avez plusieurs réservoirs dans une fenêtre ciblée et que vous souhaitez qu'ils reçoivent des informations, utilisez la structure suivante :

tank1.getInputMap(IFW).put(KeyStroke.getKeyStroke("W"), "move up");
tank2.getInputMap(IFW).put(KeyStroke.getKeyStroke("S"), "move down");
// ...
tankN.getInputMap(IFW).put(KeyStroke.getKeyStroke("T"), "fire");

Clés de reliure

Pour relier un clé à l'aide d'un KeyListener :

obj1.getInputMap(IFW).remove(KeyStroke.getKeyStroke(oldKey));
// ...
obj1.getInputMap(IFW).put(KeyStroke.getKeyStrokeForEvent(ke),
                 obj1.getInputMap(IFW).get(KeyStroke.getKeyStroke(oldKey)));

Code Exemple

Voici un exemple de code illustrant les raccourcis clavier :

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

public class MyGame extends JFrame {

    public MyGame() {
        // Do layout management, create objects, etc.
        JLabel obj1 = new JLabel();
        JLabel obj2 = new JLabel();

        // Set key bindings for object 1
        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));

        // Set key bindings for object 2
        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 objects to the JFrame
        add(obj1);
        add(obj2);
    }

    // Handle key rebinding
    public static void rebindKey(KeyEvent ke, String oldKey) {
        // Find and replace key binding
    }

    // Main method
    public static void main(String[] args) {
        new MyGame();
    }

    // Inner class for move action
    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 logic
        }
    }

    // Inner class for fire action
    private class FireAction extends AbstractAction {

        int player;

        FireAction(int player) {
            this.player = player;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            // Implement fire logic
        }
    }
}

Conclusion

Les raccourcis clavier offrent un moyen puissant et flexible de gérer les événements d'entrée utilisateur dans les applications Java Swing. En tirant parti des raccourcis clavier, les développeurs peuvent améliorer la réactivité, la maintenabilité et la réutilisabilité de leurs applications.

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!