Ereignisbehandlung in Java

Jede Änderung des Zustands eines vorhandenen Objekts wird als Ereignis bezeichnet. Ereignishandler sind so konzipiert, dass sie auf bestimmte Ereignisse hören und dementsprechend einige logische Aktionen ausführen. AWT-Komponenten können bei erforderlichen Listenern registriert werden, die Benutzerereignisse abhören und dann Behandeln Sie Ereignisse entsprechend. In diesem Thema lernen wir etwas über die Ereignisbehandlung in Java.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax

Hier ist eine Syntax zur Verwendung von AWT-Ereignishandlern:

// importing awt package
import java.awt.*;
// create a class extending Frame component
class <className> extends Frame implements <ListenerInterface>{
// override methods of implemented interface
@Override
public void <methodName>(){
// do required actions on event happened
}
<className>(){
component.addActionListerner(listenerClassobject);  // register component with listener
}}

Die obige Syntax zeigt, wie ein Listener in Java awt verwendet wird.

In der obigen Syntax bezeichnet den Namen der Java-Klasse. kann der Name des zu verwendenden Listeners sein. Um unsere Komponente für das Ereignis zu registrieren, müssen wir die Komponente mit der oben gezeigten Methode beim Listener registrieren.

Ereignisbehandlung in Java

Im Folgenden sind verschiedene Arten von Listenern aufgeführt, die in Java AWT verfügbar sind:

Event	ListenerInterface	Description
ActionEvent	ActionListener	Produced on click of a button, selection of an item from menu or other.
MouseEvent	MouseListener	Produced when mouse event takes place like moved, pressed, click, double-click or enter/exit of mouse pointer into a specified area.
KeyEvent	KeyListener	Produced on the press of the key.
ItemEvent	ItemListener	Produced when the checkbox is checked or unchecked or item present in a list is clicked.
WindowEvent	WindowListener	Produced on different operations performed on a window.
ComponentEvent	ComponnetEventListener	Produced when a component is made visible, hidden, moved or changes are made in component size.
ContainerEvent	ContainerListener	Produced when a component is inserted or deleted from a container.
FocusEvent	FocusListener	Produced when a component attains or loses keyboard focus.
AdjustmentEvent	AdjustmentListener	Produced when changes are made to using the scrollbar.
MouseWheelEvent	MouseWheelListener	Produced when the mouse wheel is rotated.
TextEvent	TextListener	Produced whenever there is a change in the value of textarea or textfield.

Die folgenden wichtigen Schritte sind bei der Behandlung eines Ereignisses in Java AWT erforderlich:

• Implementieren Sie die erforderliche Schnittstelle und überschreiben Sie ihre Methoden.
• Registrieren Sie die Komponente beim Listener.

Beispiel für die Ereignisbehandlung in Java

Das folgende Beispiel zeigt, wie Event-Handler in Java awt verwendet werden:

Code:

package com.edubca.awtdemo;
// importing important packages
import java.awt.*;
import java.awt.event.*;
public class EventHandlerDemo {
private Frame parentFrame;
private Label headerTitle;
private Label status;
private Panel panel;
public EventHandlerDemo(){
prepareInterface();
}
public static void main(String[] args){
EventHandlerDemo  awtdemo = new EventHandlerDemo();
awtdemo.showEventHandlingDemo();
}
private void prepareInterface(){
parentFrame = new Frame("Java Event Handling Example");
parentFrame.setSize(400,400);
parentFrame.setLayout(new GridLayout(3, 1));
parentFrame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent windowEvent){
System.exit(0);
}
});
headerTitle = new Label();
headerTitle.setAlignment(Label.CENTER);
status = new Label();
status.setAlignment(Label.CENTER);
status.setSize(350,100);
panel = new Panel();
panel.setLayout(new FlowLayout());
parentFrame.add(headerTitle);
parentFrame.add(panel);
parentFrame.add(status);
parentFrame.setVisible(true);
}
private void showEventHandlingDemo(){
headerTitle.setText("Handling Button Click Event");
Button firstButton = new Button("First Button");
Button secondButton = new Button("Second Button");
Button thirdButton = new Button("Third Button");
firstButton.setActionCommand("First Button Clicked");
secondButton.setActionCommand("Second Button Clicked");
thirdButton.setActionCommand("Third Button Clicked");
//registering button with listener
firstButton.addActionListener(new ButtonClickEventListener());
//registering button with listener
secondButton.addActionListener(new ButtonClickEventListener());
//registering button with listener
thirdButton.addActionListener(new ButtonClickEventListener());
panel.add(firstButton);
panel.add(secondButton);
panel.add(thirdButton);
parentFrame.setVisible(true);
}
// inner class implementing Action Listener
private class ButtonClickEventListener implements ActionListener{
// overriding method
public void actionPerformed(ActionEvent e) {
String command = e.getActionCommand();
// do different actions according to different commands
if( command.equals( "First Button Clicked" ))  {
status.setText ("First Button Clicked.");
}
else if( command.equals( "Second Button Clicked" ) )  {
status.setText ("Second Button Clicked.");
}
else  {
status.setText ("Third Button Clicked.");
}
}
}
}

Das obige Programm zeigt, wie man AWT-Ereignishandler in Java verwendet. Dazu gehört die Implementierung der erforderlichen Listener-Schnittstelle und ihrer Methoden, gefolgt von der Registrierung der Komponente beim angegebenen Listener.

Im obigen Beispiel haben wir drei Schaltflächen und ein Klick auf die Schaltflächen ändert die Beschriftung in der Fußzeile. Nachdem das obige Programm ausgeführt wurde, erscheint das folgende Fenster:

Beim Klicken auf die Schaltfläche „Erstes“ wird der folgende Text erzeugt:

Beim Klicken auf die zweite Schaltfläche wird die folgende Ausgabe erzeugt:

Beim Klicken auf die dritte Schaltfläche wird die folgende Ausgabe erzeugt:

Daher können wir sehen, dass Klickereignisse verschiedener Schaltflächen vom Listener erkannt werden und dann entsprechend unterschiedliche Funktionen ausgeführt werden.

Fazit

Der obige Artikel bietet ein klares Verständnis der Event-Handler in Java AWT.

Das obige ist der detaillierte Inhalt vonEreignisbehandlung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!