Utiliser KeyListener en Java

  1. Classe KeyEvent
  2. Implémentation de l’interface KeyListener
  3. Une application simple de KeyListener
  4. Une application de jeu simple utilisant KeyListener
  5. Sommaire

Ce tutoriel explique comment utiliser KeyListener en Java et répertorie quelques exemples de codes pour comprendre le sujet.

KeyListener est une interface qui gère les changements d’état des touches de notre clavier. Comme le nom de l’interface l’indique, elle écoute les touches et agit en conséquence.

Dans ce tutoriel, nous allons apprendre à implémenter cette interface et à travailler avec des événements clés.

Classe KeyEvent

Chaque fois qu’une touche du clavier est enfoncée, un objet de la classe KeyEvent notifie le KeyListener. La classe KeyEvent a quelques méthodes utilisées pour obtenir plus d’informations sur l’événement de clé. Trois des méthodes les plus importantes de cette classe sont résumées ci-dessous.

  • La méthode getKeyChar() récupère le caractère clé associé à l’événement. Cette méthode est très utile si nous voulons ajouter des fonctionnalités à une clé particulière. Par exemple, si e est appuyé, alors l’application devrait se fermer.
  • La méthode getKeyCode() est très similaire à la méthode getKeyChar(). Il renvoie un code-clé entier associé à la touche enfoncée.
  • La méthode isActionKey() peut dire si une touche d’action (comme Caps Lock) est enfoncée. Il renvoie un booléen vrai ou faux.

Implémentation de l’interface KeyListener

L’interface KeyListener écoute les événements clés et effectue certaines actions. La déclaration de cette interface est présentée ci-dessous.

public interface KeyListener extends EventListener

Nous devons surcharger les trois méthodes suivantes de cette interface dans notre classe.

  • La méthode keyPressed(KeyEvent e) sera invoquée lors de l’appui sur une touche.
  • La méthode keyReleased(KeyEvent e) sera invoquée au relâchement de la touche.
  • La méthode keyTyped(KeyEvent e) sera invoquée lorsqu’une touche saisira un caractère.

Nous utiliserons également la méthode addKeyListener(). Nous devons passer un objet de la classe qui implémente l’interface KeyListener à cette méthode. C’est une façon d’enregistrer l’objet pour écouter et réagir aux événements clés.

Une application simple de KeyListener

Créons une application simple qui écoute les événements clés et imprime quelque chose sur la console. Nous allons créer un cadre et y ajouter une étiquette. Notre programme doit imprimer le caractère clé et l’action clé sur la console. Si la touche enfoncée est une touche d’action, le programme doit se terminer.

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

Production:

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

Une application de jeu simple utilisant KeyListener

Créons un autre programme qui prendra les touches fléchées comme entrée. Ce programme déplacera le numéro 0 à différents endroits de la matrice en fonction de la touche enfoncée. La sortie est imprimée sur la console.

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

Production:

[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]

Sommaire

Les classes implémentent l’interface KeyListener pour écouter et réagir aux événements clés. Dans ce tutoriel, nous avons appris quelques méthodes importantes de la classe KeyEvent. Nous avons également appris à implémenter l’interface KeyListener et à surcharger les méthodes keyPressed(), keyReleased() et keyTyped(). Nous avons également vu quelques exemples qui ont démontré l’utilisation de cette interface.