Java AWT

Jetzt soll auch was passieren - die Ereignisbehandlung

Die bisher eingefügten Objekte des AWT verfügen mit ihrer Instanziierung bereits über grundlegende Methoden.

In ein TextField kann Text eingetragen und verändert werden. Aus Auswahlfeldern (Choice) kann man einen beliebigen Eintrag auswählen. In einer Bildlauflauleiste (Scrollbar) lässt sich der Regler direkt mit der Maus und mit Hilfe der Pfeilbuttons an den Endern verschieben usw.

Jetzt soll aber genau das passieren, was der Nutzer möchte. Dazu sollte man wissen, wie man seinem Programm beibringen kann, auf Ereignisse zu reagieren.

Das Betriebssystem registriert und meldet ständig das Stattfinden von Ereignissen.
Die Maus wird bewegt, eine Taste wird gedrückt, ich schiebe einen Regler, ich bewege die Maus mit gedrückter Maustaste, ich ändere in einem Feld den Text, ein Element wird markiert und erhält dadurch den Fokus, ich wähle aus einem Auswahlfeld etwas aus und Vieles mehr.

Merke:
Ein Listener-Interface (oder eine Schnittstelle) ist ein Objekt, welches die vom Betriebssystem gemeldeten Ereignisse erfasst und an mein Programm weiterleitet.
Für jedes zu überwachende Ereignis existiert ein entsprechendes Interface.

Eine grafische Oberfläche besteht meist aus mehreren Objekten. Nicht jedes Objekt soll auf dasselbe Ereignis reagieren.

Merke
Ich muss das Interface-Objekt bei dem Objekt registrieren, welches auf das Eintreten des Ereignisses reagieren soll.

Wenn mein Programm auf Ereignisse reagieren kann, können je nach Objekt verschiedene Dinge gefordert werden. Beim Drücken auf einen Button soll eine Berechnung ausgeführt werden, ein Text ist gleich bei der Eingabe auf Fehler zu prüfen oder Farbwerte haben sich bei der Bedienung eines Reglers sofort zu ändern.

Merke
Ich muss eine Methode schreiben, die beim Eintreten des Ereignsses ausgeführt wird.

Das erste Beispiel zeigt eine grafische Oberfläche mit einem TextField für die Eingabe. Das erste Ereignis, welches ich abfangen möchte, ist das Betätigen des Schliessen-Symbols (Kreuz) oben rechts auf dem Fensterrahmen.

Hier zunächst der komplette Quelltext


      
       01 
       import java.awt.*;
      
      
       02 
       import java.awt.event.*;
      
      
       03 
        
      
      
       04 
       /** 
      
      
       05 
         Mein erste grafische Oberfläche mit Ereignisbehandlung
      
      
       06 
       */
      
      
       07 
        
      
      
       08 
       public class GrafischeOberflaeche05a extends Frame {
      
      
       09 
       
      
      
       10 
         TextField tfEingabe = new TextField(30);
      
      
       11 
       
      
      
       12 
         FlowLayout flAnordnung = new FlowLayout();
      
      
       13 
       
      
      
        14 
          WindowLauscher wlSchliesser = new WindowLauscher(); 
      
      
       15 
        
      
      
       16 
         public GrafischeOberflaeche05a() {
      
      
       17 
           this.setSize(400,300);
      
      
       18 
           this.setTitle("Ich bin eine grafische Oberfläche");
      
      
       19 
           this.setVisible(true);
      
      
        20 
         
      
      
       21 
           this.addWindowListener(wlSchliesser); 
      
      
        22 
         
      
      
        23 
            this.setLayout(flAnordnung); 
      
      
        24 
         
      
      
        25 
            this.add(tfEingabe); 
      
      
        26 
          }
      
      
       27 
        
      
      
       28 
         public static void main(String[] args) {   
      
      
       29 
           GrafischeOberflaeche05a programm = new GrafischeOberflaeche05a();  
      
      
       30 
         }
      
      
       31 
       
      
      
       32 
         class WindowLauscher implements WindowListener {
      
      
       33 
       
      
      
       34 
           public void windowActivated(WindowEvent e){
      
      
       35 
        
      
      
       36 
           }
      
      
       37 
       
      
      
       38 
           public void windowClosed(WindowEvent e){
      
      
       39 
        
      
      
       40 
           }
      
      
       41 
       
      
      
       42 
           public void windowClosing(WindowEvent e){
      
      
       43 
             Frame frAusloeser =(Frame) e.getSource(); 
      
      
       44 
             frAusloeser.dispose();
      
       45 
           }
      
      
       46 
       
      
      
       47 
           public void windowDeactivated(WindowEvent e){
      
      
       48 
        
      
      
       49 
           }
      
      
       50 
       
      
      
       51 
           public void windowDeiconified(WindowEvent e){
      
      
       52 
        
      
      
       53 
           }
      
      
       54 
       
      
      
       55 
           public void windowIconified(WindowEvent e){
      
      
       56 
        
      
      
       57 
           }
      
      
       58 
       
      
      
       59 
           public void windowOpened(WindowEvent e){
      
      
       60 
        
      
      
       61 
           }
      
       
       62 
         }
      
       
       63 
       }
      
      
       64

Erläuterung zum Quelltext

Zeile 02

Die Ereignisbehandlung erfordert die Einbindung von Klassen, die Methoden dafür bereitstellen. Mit import java.awt.event.*; werden gleich die Klassen für alle möglichen Ereignisse importiert.

Zeile 32-62

Es wird eine Schnittstelle gebraucht, um Ereignisse zu behandeln, die am Rahmen des Programmfensters stattfinden.
Dazu schreibe ich eine eigene Klasse "WindowLauscher". Hier habe ich sie als Klasse innerhalb meiner Klasse, also als innere Klasse, eingefügt. Aus der Klasse WindowLauscher möchte ich das Interface erzeugen.
Eine Klasse, aus der ein Interface erzeugt werden soll, muss sämtliche Methoden des Interfaces implementieren (daher das Schlüsselwort implements in Zeile 32).
In der Javadokumentation sehe ich unter den Packages (oben links) nach java.awt.event. Dann finde ich darunter bei den Interfaces den WindowListener.. Wenn ich den anklicke, stehen im rechten Fenster unter "Method Summary" alle Methoden, welche das Interface WindowListener implementieren muss (Ganz schön viel Schreibarbeit, nur um ein Programm zu beenden).
An den Namen der Methoden sollte erkennbar sein, beim Eintreten welchen Ereignisses sie automatisch ausgeführt werden.
Da gibt es eine Methode, die beim Aktivieren des Fensters (windowActivated) ausgeführt wird. Oder eine andere, die beim Minimieren des Fensters, wenn das Programmfenster auf Icongröße schrumpft (windowIconified), startet. Mich interessiert aber nur die, die beim Drücken auf das Kreuz im Programmfenster (windowClosing) ausgeführt wird.

Zeile 14

Hier wird ein Objekt wlSchliesser vom Typ WindowLauscher erzeugt, also aus der Klasse, die ich selbst geschrieben habe. Damit ist wlSchliesser meine Schnittstelle ins Betriebssystem und registriert Ereignisse am Programmfenster.

Zeile 21

Das in Zeile 14 erzeugte Interface wird beim Programmobjekt (this) registriert. Damit weiß das Programm, dass es dasjenige Objekt ist, welches auf die eintretenden Windowereignisse reagieren soll.

Zeile 43-44

Tritt nun tatsächlich das Ereignis (WindowEvent e) ein, dass jemand auf das Kreuz geklickt hat. so kann man das WindowEvent e mit der Methode getSource() befragen, wer der Auslöser war.
Da die Methode getSource() in Zeile 43 ein Objekt vom Typ Object (das allgemeinste Objekt) als Antwort zurückgibt, wird es noch zu einem Frame gecastet. In Zeile 44 wird das auslösende Frame mit der Methode dispose() geschlossen.

So viel Programmcode, nur um ein Programm zu beenden. Das dachten sich wohl auch die Entwickler von Java und haben einen großen Teil der Schreibarbeit selbst übernommen.
Sie haben alle Methoden eines Interfaces in eine sogenannte Adapterklasse mit gleichem Namen geschrieben.
Ich kann mir also die Adapterklasse nehmen und muss nur die Methode, die ich ändern will, um meine Wünsche erweitern (extends)

Merke:
Die Verwendung der Adapterklassen entbindet mich nicht davon, in der Dokumentation nachzulesen, welches Interface auf welche Ereignisse reagiert.


      
       01 
       import java.awt.*;
      
      
       02 
       import java.awt.event.*;
      
      
       03 
        
      
      
       04 
       /** 
      
      
       05 
         Mein erste grafische Oberfläche mit Ereignisbehandlung
      
      
       06 
       */
      
      
       07 
        
      
      
       08 
       public class GrafischeOberflaeche05b extends Frame {
      
      
       09 
       
      
      
       10 
         TextField tfEingabe = new TextField(30);
      
      
       11 
       
      
      
       12 
         FlowLayout flAnordnung = new FlowLayout();
      
      
       13 
       
      
      
        14 
          WindowLauscher wlSchliesser = new WindowLauscher(); 
      
      
       15 
        
      
      
       16 
         public GrafischeOberflaeche05b() {
      
      
       17 
           this.setSize(400,300);
      
      
       18 
           this.setTitle("Ich bin eine grafische Oberfläche");
      
      
       19 
           this.setVisible(true);
      
      
        20 
         
      
      
       21 
           this.addWindowListener(wlSchliesser); 
      
      
        22 
         
      
      
        23 
            this.setLayout(flAnordnung); 
      
      
        24 
         
      
      
        25 
            this.add(tfEingabe); 
      
      
        26 
          }
      
      
       27 
        
      
      
       28 
         public static void main(String[] args) {   
      
      
       29 
           GrafischeOberflaeche05b programm = new GrafischeOberflaeche05b();  
      
      
       30 
         }
      
      
       31 
       
      
      
       32 
         class WindowLauscher extends WindowAdapter {
      
      
       33 
       
      
      
       34 
           public void windowClosing(WindowEvent e){
      
      
       35 
             Frame frAusloeser =(Frame) e.getSource(); 
      
      
       36 
             frAusloeser.dispose();
      
       37 
           }
      
       
       38 
         }
      
       
       39 
       }
      
      
       40

Damit habe ich beim Abfangen eines einzigen Ereignisses (Zeilen 32 - 38) bereits über 20 Zeilen Programmcode eingespart.

Hier nun einige Listener

Die Angaben stammen direkt aus der Javadokumentation aus dem Bereich java.awt.event.

Listener

Methoden

Adapterklasse

WindowListener

windowActivated(WindowEvent e)
Wird beim Aktivieren des Fensters aufgerufen.
windowClosed(WindowEvent e)
Wird aufgerufen, wenn ein Fenster durch den Aufruf von dispose auf dem Fenster geschlossen wurde.
windowClosing(WindowEvent e)
Wird aufgerufen, wenn der Benutzer versucht, das Fenster über das Systemmenü des Fensters zu schließen.
windowDeactivated(WindowEvent e)
Wird aufgerufen, wenn ein Fenster nicht mehr das aktive Fenster ist, z.B. beim Aktivieren eines anderen Fensters.
windowDeiconified(WindowEvent e)
Wird aufgerufen, wenn ein Fenster von einem minimierten in einen normalen Zustand übergeht.
windowIconified(WindowEvent e)
Wird aufgerufen, wenn ein Fenster von einem normalen in einen minimierten Zustand übergeht.
windowOpened(WindowEvent e)
Wird beim ersten Sichtbarmachen des Fensters aufgerufen.

WindowAdapter

ActionListener

actionPerformed(ActionEvent e)
Wird bei Aktionen aufgerufen, z.B. in einem TextField ENTER-Taste drücken oder auf einen Button klicken.

TextListener

textValueChanged(TextEvent e)
Wird aufgerufen, wenn sich der Text ändert, z.B. in einem TextField oder einem TextArea.

KeyListener

keyPressed(KeyEvent e)
Wird beim Runterdrücken einer Taste aufgerufen.
keyReleased(KeyEvent e)
Wird beim Loslassen einer Taste aufgerufen.
keyTyped(KeyEvent e)
Wird beim Betätigen (runter und hoch) einer Taste aufgerufen.

KeyAdapter

MouseListener

mouseClicked(MouseEvent e)
Wird aufgerufen, wenn die Maustaste auf eine Komponente geklickt (gedrückt und losgelassen) wurde.
mouseEntered(MouseEvent e)
Wird aufgerufen, wenn die Maus in eine Komponente eintritt, lso der Mauszeiger über die Komponente geht.
mouseExited(MouseEvent e)
Wird aufgerufen, wenn die Maus bzw. der Mauszeiger eine Komponente verlässt.
mousePressed(MouseEvent e)
Wird aufgerufen, wenn eine Maustaste auf einer Komponente gedrückt wurde.
mouseReleased(MouseEvent e)
Wird aufgerufen, wenn eine Maustaste auf einer Komponente losgelassen wurde.

MouseAdapter

MouseMotionListener

mouseDragged(MouseEvent e)
Wird aufgerufen, wenn die Maus bei gedrückter Maustaste auf einer Komponente bewegt wird.
mouseMoved(MouseEvent e)
Wird aufgerufen, wenn der Mauszeiger auf eine Komponenter bewegt wurde, aber keine Maustasten gedrückt wurden.

MouseMotionAdapter

FocusListener

focusGained(FocusEvent e)
Wird aufgerufen, wenn eine Komponente den Tastaturfokus erhält. focusLost(FocusEvent e)
Wird aufgerufen, wenn eine Komponente den Tastaturfokus verliert.

FocusAdapter

AdjustmentListener

adjustmentValueChanged(AdjustmentEvent e)
Wird aufgerufen, wenn sich der Wert des Einstellbereichs (z.B. einer Scrollbar) geändert hat.

ItemListener

itemStateChanged(ItemEvent e)
Wird aufgerufen, wenn ein Element (z.B. bei einem Auswahlfeld Choice) vom Benutzer ausgewählt oder abgewählt wurde.

01	import java.awt.*;
02	import java.awt.event.*;
03
04	/**
05	Mein erste grafische Oberfläche mit Ereignisbehandlung
06	*/
07
08	public class GrafischeOberflaeche05a extends Frame {
09
10	TextField tfEingabe = new TextField(30);
11
12	FlowLayout flAnordnung = new FlowLayout();
13
14	WindowLauscher wlSchliesser = new WindowLauscher();
15
16	public GrafischeOberflaeche05a() {
17	this.setSize(400,300);
18	this.setTitle("Ich bin eine grafische Oberfläche");
19	this.setVisible(true);
20
21	this.addWindowListener(wlSchliesser);
22
23	this.setLayout(flAnordnung);
24
25	this.add(tfEingabe);
26	}
27
28	public static void main(String[] args) {
29	GrafischeOberflaeche05a programm = new GrafischeOberflaeche05a();
30	}
31
32	class WindowLauscher implements WindowListener {
33
34	public void windowActivated(WindowEvent e){
35
36	}
37
38	public void windowClosed(WindowEvent e){
39
40	}
41
42	public void windowClosing(WindowEvent e){
43	Frame frAusloeser =(Frame) e.getSource();
44	frAusloeser.dispose();
45	}
46
47	public void windowDeactivated(WindowEvent e){
48
49	}
50
51	public void windowDeiconified(WindowEvent e){
52
53	}
54
55	public void windowIconified(WindowEvent e){
56
57	}
58
59	public void windowOpened(WindowEvent e){
60
61	}
62	}
63	}
64