Verwendung von KeyListener in Java
-
KeyEvent-Klasse -
Implementierung der
KeyListener-Schnittstelle - Eine einfache Anwendung von KeyListener
- Eine einfache Spielanwendung mit KeyListener
- Zusammenfassung
Dieses Tutorial führt in die Verwendung von KeyListener in Java ein und listet einige Beispielcodes auf, um das Thema zu verstehen.
KeyListener ist eine Schnittstelle, die sich mit Änderungen im Zustand der Tasten unserer Tastatur befasst. Wie der Name der Schnittstelle vermuten lässt, hört sie auf die Tasten und handelt entsprechend.
In diesem Tutorial lernen wir, wie Sie diese Schnittstelle implementieren und mit Schlüsselereignissen arbeiten.
KeyEvent-Klasse
Immer wenn eine Tastaturtaste gedrückt wird, benachrichtigt ein Objekt der Klasse KeyEvent den KeyListener. Die Klasse KeyEvent hat einige Methoden, die verwendet werden, um mehr Informationen über das Schlüsselereignis zu erhalten. Im Folgenden sind drei der wichtigsten Methoden dieser Klasse zusammengefasst.
- Die Methode
getKeyChar()holt das dem Ereignis zugeordnete Schlüsselzeichen. Diese Methode ist sehr nützlich, wenn wir einem bestimmten Schlüssel einige Funktionen hinzufügen möchten. Wenn zum Beispielegedrückt wird, sollte die Anwendung beendet werden. - Die Methode
getKeyCode()ist der MethodegetKeyChar()sehr ähnlich. Es gibt einen ganzzahligen Tastencode zurück, der der gedrückten Taste zugeordnet ist. - Die Methode
isActionKey()kann erkennen, ob eine Aktionstaste (wie Caps Lock) gedrückt wird. Es gibt ein boolesches true oder false zurück.
Implementierung der KeyListener-Schnittstelle
Die KeyListener-Schnittstelle lauscht auf Schlüsselereignisse und führt eine Aktion aus. Die Deklaration dieser Schnittstelle ist unten dargestellt.
public interface KeyListener extends EventListener
Wir müssen die folgenden drei Methoden dieser Schnittstelle in unserer Klasse überschreiben.
- Die Methode
keyPressed(KeyEvent e)wird aufgerufen, wenn eine Taste gedrückt wird. - Beim Loslassen der Taste wird die Methode
keyReleased(KeyEvent e)aufgerufen. - Die Methode
keyTyped(KeyEvent e)wird aufgerufen, wenn eine Taste ein Zeichen eingibt.
Wir werden auch die Methode addKeyListener() verwenden. Wir müssen dieser Methode ein Objekt der Klasse übergeben, die das Interface KeyListener implementiert. Es ist eine Möglichkeit, das Objekt zu registrieren, um auf Schlüsselereignisse zu hören und darauf zu reagieren.
Eine einfache Anwendung von KeyListener
Lassen Sie uns eine einfache Anwendung erstellen, die auf Schlüsselereignisse lauscht und etwas an die Konsole ausgibt. Wir erstellen einen Rahmen und fügen ihm ein Label hinzu. Unser Programm sollte das Tastenzeichen und die Tastenaktion an die Konsole ausgeben. Wenn die gedrückte Taste eine Aktionstaste ist, sollte das Programm beendet werden.
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
public class KeyListenerExample implements KeyListener {
@Override
public void keyTyped(KeyEvent e) {
System.out.println("The key Typed was: " + e.getKeyChar());
}
@Override
public void keyPressed(KeyEvent e) {
if (e.isActionKey())
System.exit(0);
System.out.println("The key Pressed was: " + e.getKeyChar());
}
@Override
public void keyReleased(KeyEvent e) {
System.out.println("The key Released was: " + e.getKeyChar());
}
public static void main(String[] args) {
// Setting the Frame and Labels
Frame f = new Frame("Demo");
f.setLayout(new FlowLayout());
f.setSize(500, 500);
Label l = new Label();
l.setText("This is a demonstration");
f.add(l);
f.setVisible(true);
// Creating and adding the key listener
KeyListenerExample k = new KeyListenerExample();
f.addKeyListener(k);
}
}
Ausgabe:
The key Pressed was: a
The key Typed was: a
The key Released was: a
The key Pressed was: b
The key Typed was: b
The key Released was: b
Eine einfache Spielanwendung mit KeyListener
Lassen Sie uns ein weiteres Programm erstellen, das die Pfeiltasten als Eingabe verwendet. Dieses Programm verschiebt die Zahl 0 entsprechend der gedrückten Taste an verschiedene Stellen in der Matrix. Die Ausgabe wird an die Konsole ausgegeben.
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Arrays;
public class KeyListenerExample implements KeyListener {
// Matrix and x, y coordinates of 0
int[][] matrix;
int x;
int y;
KeyListenerExample() {
// Initializing the Matrix
matrix = new int[3][3];
matrix[0] = new int[] {1, 1, 1};
matrix[1] = new int[] {1, 0, 1};
matrix[2] = new int[] {1, 1, 1};
x = 1;
y = 1;
// Printing the Matrix
for (int i = 0; i < 3; i++) System.out.println(Arrays.toString(matrix[i]));
System.out.println();
}
// keyPressed() method takes care of moving the zero according to the key pressed
@Override
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
if (x != 2) {
x += 1;
System.out.println("Moving Right");
} else
System.out.println("Cannot Move Right");
}
if (e.getKeyCode() == KeyEvent.VK_LEFT) {
if (x != 0) {
x -= 1;
System.out.println("Moving Left");
} else
System.out.println("Cannot Move Left");
}
if (e.getKeyCode() == KeyEvent.VK_DOWN) {
if (y != 2) {
y += 1;
System.out.println("Moving Down");
} else
System.out.println("Cannot Move Down");
}
if (e.getKeyCode() == KeyEvent.VK_UP) {
if (y != 0) {
y -= 1;
System.out.println("Moving Up");
} else
System.out.println("Cannot Move Up");
}
matrix[0] = new int[] {1, 1, 1};
matrix[1] = new int[] {1, 1, 1};
matrix[2] = new int[] {1, 1, 1};
matrix[y][x] = 0;
for (int i = 0; i < 3; i++) System.out.println(Arrays.toString(matrix[i]));
System.out.println();
}
// We don't need the other two methods
@Override
public void keyReleased(KeyEvent e) {}
@Override
public void keyTyped(KeyEvent e) {}
public static void main(String[] args) {
// Setting the frame and labels
Frame f = new Frame("Demo");
f.setLayout(new FlowLayout());
f.setSize(200, 200);
Label l = new Label();
l.setText("This is a Game");
f.add(l);
f.setVisible(true);
// Creating and adding the key listener
KeyListenerExample k = new KeyListenerExample();
f.addKeyListener(k);
}
}
Ausgabe:
[1, 1, 1]
[1, 0, 1]
[1, 1, 1]
Moving Right
[1, 1, 1]
[1, 1, 0]
[1, 1, 1]
Cannot Move Right
[1, 1, 1]
[1, 1, 0]
[1, 1, 1]
Moving Left
[1, 1, 1]
[1, 0, 1]
[1, 1, 1]
Moving Left
[1, 1, 1]
[0, 1, 1]
[1, 1, 1]
Cannot Move Left
[1, 1, 1]
[0, 1, 1]
[1, 1, 1]
Moving Up
[0, 1, 1]
[1, 1, 1]
[1, 1, 1]
Cannot Move Up
[0, 1, 1]
[1, 1, 1]
[1, 1, 1]
Moving Down
[1, 1, 1]
[0, 1, 1]
[1, 1, 1]
Moving Down
[1, 1, 1]
[1, 1, 1]
[0, 1, 1]
Cannot Move Down
[1, 1, 1]
[1, 1, 1]
[0, 1, 1]
Zusammenfassung
Klassen implementieren das Interface KeyListener, um auf Schlüsselereignisse zu hören und darauf zu reagieren. In diesem Tutorial haben wir einige wichtige Methoden der Klasse KeyEvent kennengelernt. Wir haben auch gelernt, wie man das KeyListener-Interface implementiert und wie man die Methoden keyPressed(), keyReleased() und keyTyped() überschreibt. Wir haben auch einige Beispiele gesehen, die die Verwendung dieser Schnittstelle demonstriert haben.