Umgang mit Java-Swing-Schlüsseln: Tastenzuordnungen oder Schlüssel-Listener – was sollten Sie wählen?

Tastenkombinationen vs. Schlüssel-Listener in Java Swing: Ein umfassender Leitfaden

Tastenkombinationen und Schlüssel-Listener sind zwei Ansätze zum Umgang mit Benutzereingabeereignissen von Schlüsseln in Java Swing-Anwendungen. Während Tastenlistener eine einfache Möglichkeit bieten, Tastendrücke zu erkennen, bieten Tastenkombinationen mehrere Vorteile, darunter:

• Verbesserte Reaktionsfähigkeit: Tastenkombinationen erfordern nicht, dass der Benutzer auf ein Objekt klickt um ihm den Fokus zu geben, was zu einer schnelleren und intuitiveren Eingabeverarbeitung führt.
• Verbesserte Wartbarkeit:Tastenkombinationen ermöglichen zum einfacheren Deaktivieren, erneuten Zuweisen und Neuzuweisen von Benutzeraktionen, wodurch die Wartung und die Lesbarkeit des Codes vereinfacht werden.

Tastenkombinationen verstehen

Tastenkombinationen umfassen zwei Objekte:

• InputMap: Ordnet Benutzereingaben einer Aktion zu Name.
• ActionMap: Ordnet einen Aktionsnamen einer Aktion zu.

Wenn eine Taste gedrückt wird, sucht die Eingabezuordnung nach der Taste und findet eine Aktion Name. Anschließend wird die Aktionskarte nach dem Aktionsnamen durchsucht und die Aktion ausgeführt.

Tastenzuordnungen implementieren

Um eine einzelne Tastenzuordnung zu erstellen, verwenden Sie die folgende Struktur:

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

Verwenden von WHEN_IN_FOCUSED_WINDOW InputMap

Die InputMap für WHEN_IN_FOCUSED_WINDOW ermöglicht es mehreren Komponenten innerhalb eines fokussierten Fensters, gleichzeitig Eingaben zu empfangen. Wenn Sie beispielsweise mehrere Tanks in einem fokussierten Fenster haben und möchten, dass diese Eingaben empfangen, verwenden Sie die folgende Struktur:

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");

Tasten neu binden

Um einen erneut zu binden Schlüssel mithilfe eines KeyListener:

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

Code Beispiel

Hier ist ein Codebeispiel, das Tastenkombinationen demonstriert:

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

Fazit

Tastenkombinationen bieten eine leistungsstarke und flexible Möglichkeit Behandeln Sie Benutzereingabeereignisse in Java Swing-Anwendungen. Durch die Nutzung von Tastenkombinationen können Entwickler die Reaktionsfähigkeit, Wartbarkeit und Wiederverwendbarkeit ihrer Anwendungen verbessern.

Das obige ist der detaillierte Inhalt vonUmgang mit Java-Swing-Schlüsseln: Tastenzuordnungen oder Schlüssel-Listener – was sollten Sie wählen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!