Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger

 << zurück
Java ist auch eine Insel von Christian Ullenboom
Programmieren für die Java 2-Plattform in der Version 5
Java ist auch eine Insel

Java ist auch eine Insel
5., akt. und erw. Auflage
1454 S., mit CD, 49,90 Euro
Galileo Computing
ISBN 3-89842-747-1
gp Kapitel 15 Komponenten, Container und Ereignisse
  gp 15.1 Es tut sich was – Ereignisse beim AWT
    gp 15.1.1 Die Klasse AWTEvent
    gp 15.1.2 Events auf verschiedenen Ebenen
    gp 15.1.3 Ereignisquellen und Horcher (Listener)
    gp 15.1.4 Listener implementieren
    gp 15.1.5 Listener bei Ereignisauslöser anmelden/abmelden
    gp 15.1.6 Aufrufen der Listener
  gp 15.2 Varianten, das Fenster zu schließen
    gp 15.2.1 Eine Klasse implementiert die Schnittstelle WindowListener
    gp 15.2.2 Adapterklassen nutzen
    gp 15.2.3 Innere Mitgliedsklassen und innere anonyme Klassen
    gp 15.2.4 Generic Listener
  gp 15.3 Komponenten im AWT und in Swing
    gp 15.3.1 Peer-Klassen und Lightweight-Komponenten
    gp 15.3.2 Die Basis aller Komponenten: Component und JComponent
    gp 15.3.3 Proportionales Vergrößern eines Fensters
    gp 15.3.4 Dynamisches Layout während einer Größenänderung
    gp 15.3.5 Hinzufügen von Komponenten
  gp 15.4 Swing-Fenster JFrame, JDialog, JWindows
    gp 15.4.1 Kinder auf einem Swing-Fenster
    gp 15.4.2 Schließen eines Swing-Fensters
    gp 15.4.3 JWindow und JDialog
  gp 15.5 Informationstext über die Klasse JLabel
    gp 15.5.1 Mehrzeiliger Text, HTML in der Darstellung
  gp 15.6 Die Klasse ImageIcon
    gp 15.6.1 Die Schnittstelle Icon
    gp 15.6.2 Was Icon und Image verbindet
  gp 15.7 Eine Schaltfläche (JButton)
    gp 15.7.1 Der aufmerksame ActionListener
    gp 15.7.2 Generic Listener für Schaltflächen-Ereignisse verwenden
    gp 15.7.3 AbstractButton
    gp 15.7.4 JToggleButton
  gp 15.8 Tooltips
  gp 15.9 Der Container JPanel
  gp 15.10 Alles Auslegungssache: die Layoutmanager
    gp 15.10.1 FlowLayout
    gp 15.10.2 Mit BorderLayout in allen Himmelsrichtungen
    gp 15.10.3 GridLayout
    gp 15.10.4 Der GridBagLayout-Manager
    gp 15.10.5 Null-Layout
    gp 15.10.6 Weitere Layoutmanager
  gp 15.11 Horizontale und vertikale Rollbalken
    gp 15.11.1 Der AdjustmentListener, der auf Änderungen hört
  gp 15.12 JSlider
  gp 15.13 Ein Auswahlmenü – Choice, JComboBox
    gp 15.13.1 ItemListener
    gp 15.13.2 Zuordnung einer Taste mit einem Eintrag
    gp 15.13.3 DateComboBox
  gp 15.14 Eines aus vielen – Kontrollfelder (JCheckBox)
    gp 15.14.1 Ereignisse über ItemListener
  gp 15.15 Kontrollfeldgruppen, Optionsfelder, JRadioButton
  gp 15.16 Der Fortschrittsbalken JProgressBar
  gp 15.17 Rahmen (Borders)
  gp 15.18 Symbolleisten alias Toolbars
  gp 15.19 Menüs
    gp 15.19.1 Die Menüleisten und die Einträge
    gp 15.19.2 Menüeinträge definieren
    gp 15.19.3 Mnemonics und Shortcuts (Accelerator)
    gp 15.19.4 Popup-Menüs
  gp 15.20 Das Konzept des Model-View-Controllers
  gp 15.21 List-Boxen
  gp 15.22 JSpinner
  gp 15.23 Texteingabefelder
    gp 15.23.1 Text in einer Eingabezeile
    gp 15.23.2 Die Oberklasse der JText-Komponenten: JTextComponent
    gp 15.23.3 JPasswordField
    gp 15.23.4 Validierende Eingabefelder
    gp 15.23.5 Mehrzeilige Textfelder
    gp 15.23.6 Die Editor-Klasse JEditorPane
  gp 15.24 Bäume mit JTree-Objekten
    gp 15.24.1 Selektionen bemerken
  gp 15.25 Tabellen mit JTable
    gp 15.25.1 Ein eigenes Tabellen-Model
    gp 15.25.2 AbstractTableModel
    gp 15.25.3 DefaultTableModel
    gp 15.25.4 Ein eigener Renderer für Tabellen
    gp 15.25.5 Zell-Editoren
    gp 15.25.6 Größe und Umrandung der Zellen
    gp 15.25.7 Spalteninformationen
    gp 15.25.8 Tabellenkopf von Swing-Tabellen
    gp 15.25.9 Selektionen einer Tabelle
    gp 15.25.10 Ein professionelles Tabellenlayout mit JGrid
  gp 15.26 JRootPane, JLayeredPane und JDesktopPane
    gp 15.26.1 JRootPane und JLayeredPane
    gp 15.26.2 JDesktopPane und die Kinder JInternalFrame
  gp 15.27 Dialoge
    gp 15.27.1 Der Farbauswahldialog JColorChooser
    gp 15.27.2 Der Dateiauswahldialog
  gp 15.28 Flexibles Java-Look&Feel
    gp 15.28.1 UIManager
    gp 15.28.2 Ändern des Aussehens Laufzeit
    gp 15.28.3 Verbessern des Aussehens unter Windows mit WinLAF
  gp 15.29 Swing-Beschriftungen einer anderen Sprache geben
  gp 15.30 Die Zwischenablage (Clipboard)
  gp 15.31 Undo durchführen
  gp 15.32 Ereignisverarbeitung auf unterster Ebene
    gp 15.32.1 Eigene Ereignisse in die Queue setzen
    gp 15.32.2 Auf alle Ereignisse hören
  gp 15.33 AWT, Swing und die Threads
    gp 15.33.1 Swing ist nicht Thread-sicher
    gp 15.33.2 Swing-Elemente bedienen mit invokeLater(), invokeAndWait()
  gp 15.34 Selbst definierte Cursor
    gp 15.34.1 Flackern des Mauszeigers bei Animationen vermeiden
  gp 15.35 Benutzerinteraktionen automatisieren
    gp 15.35.1 Automatisch in die Tasten hauen
    gp 15.35.2 Mausoperationen
    gp 15.35.3 Methoden zur Zeitsteuerung
    gp 15.35.4 Screenshots
    gp 15.35.5 Funktionsweise und Beschränkungen
    gp 15.35.6 MouseInfo und PointerInfo
  gp 15.36 Zeitliches Ausführen mit dem javax.swing.Timer
  gp 15.37 Alternativen zu AWT und Swing
    gp 15.37.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor
    gp 15.37.2 SWT


Galileo Computing

15.2 Varianten, das Fenster zu schließedowntop

Beim ersten AWT-Programm mit Fenstern konnte das Fenster nicht sauber geschlossen werden. Dies liegt ganz einfach daran, dass spezielle Fensterereignisse ausgelöst werden, die wir abfangen müssen (was wir aber nicht getan haben). Nur dann ist jedoch ein sauberer Ausstieg möglich, da sich unter den vielen Ereignissen, die das Fenstersystem sendet, auch die Aufforderung zum Schließen des Fensters befindet. Unter Swing reagiert ein JFrame auf WindowEvents, reagiert in der protected-Methode processWindowEvent() auf das WINDOW_CLOSING und kann das Fenster so auch ohne hinzugefügten Ereignisbehandler schließen.

Um ein Fenster korrekt zu schließen, müssen wir das WindowListener-Interface implementieren. WindowListener definiert eine Anzahl von Funktionen, die mit addWindowListener() an ein Fenster gebunden werden. Immer wenn ein Event ausgelöst wird, kümmert sich die jeweilige Funktion um dessen Abarbeitung.

Wir wollen im Folgenden einige populäre Möglichkeiten zum Schließen eines Fensters aufzeigen.


Galileo Computing

15.2.1 Eine Klasse implementiert die Schnittstelle WindowListener  downtop

Die erste Möglichkeit, Ereignisbehandlung zu implementieren, besteht in der Implementierung aller vorgeschriebenen Methoden der Listener-Schnittstelle. Dafür bieten sich zwei Klassen an: zum einen die auch das Fenster öffnende Hauptklasse, und zum anderen eine externe Klasse, die nichts anderes tut, als die Listener-Schnittstelle zu implementieren. Wir wollen im folgenden Beispiel unser Hauptprogramm – die Schnittstelle WindowListener – implementieren lassen.

Abbildung
Hier klicken, um das Bild zu Vergrößern

Listing 15.1   FensterWegImplementsAll.java

import javax.swing.*;
import java.awt.event.*;
class FensterWegImplementsAll extends JFrame implements WindowListener
{
  public FensterWegImplementsAll()
  {
    setSize( 400400 );
    addWindowListener( this );
    setVisible( true );
  }
  // Implementiere WindowListener
  public void windowClosing( WindowEvent event ) {
    System.exit( 0 );
  }
  public void windowClosed( WindowEvent event ) {}
  public void windowDeiconified( WindowEvent event ) {}
  public void windowIconified( WindowEvent event ) {}
  public void windowActivated( WindowEvent event ) {}
  public void windowDeactivated( WindowEvent event ) {}
  public void windowOpened( WindowEvent event ) {}
  public static void main( String[] args )
  {
    new FensterWegImplementsAll();
  }
}

Die anderen Funktionen sind hier nicht implementiert, doch lässt sich die Funktion leicht am Namen ablesen. Das Fenster wird geschlossen, wenn der Anwender auf das X drückt.


interface java.awt.event.  WindowListener
  extends EventListener

gp  void windowOpened( WindowEvent e ) Aufgerufen, wenn das Fenster geöffnet wurde.
gp  void windowClosing( WindowEvent e ) Aufgerufen, wenn das Fenster geschlossen wird.
gp  void windowClosed( WindowEvent e ) Aufgerufen, wenn das Fenster mit dispose() geschlossen wurde.
gp  void windowIconified( WindowEvent e ) Aufgerufen, wenn das Fenster zum Icon verkleinert wird.
gp  void windowDeiconified( WindowEvent e ) Aufgerufen, wenn das Fenster wieder hochgeholt wird.
gp  void windowActivated( WindowEvent e ) Aufgerufen, wenn das Fenster aktiviert wird.
gp  void windowDeactivated( WindowEvent e ) Aufgerufen, wenn das Fenster deaktiviert wird.

Der Unterschied zwischen windowClosing() und windowClosed()

Die Schnittstelle WindowListener schreibt zwei Methoden vor, deren Namen sich ziemlich ähnlich anhören: windowClosing() und windowClosed(). Betrachten wir den Unterschied zwischen beiden und wie ein Programm beide Methoden nutzen oder meiden kann.

In den einfachen Programmen setzen wir in die windowClosing()-Methode ein System.exit() ein, um die Applikation zu beenden, da windowClosing()immer bei Beendigung der Applikation mit dem X am Fenster aufgerufen wird. Was allerdings leicht vergessen wird, ist die Tatsache, dass nicht nur der Benutzer über das X das Fenster schließen kann, sondern auch die Applikation über die spezielle Methode dispose(). Sie gibt alle Ressourcen frei und schließt das Fenster. Die Applikation ist dann allerdings noch nicht beendet. Damit wir das Schließen mit dem X und durch dispose() unterscheiden können, kümmert sich windowClosing() um das X und windowClosed() um das dispose(). Wenn wir lediglich mit dem X das Fenster schließen und die Applikation beendet werden soll, muss nicht noch extra dispose() schön brav die Ressourcen freigeben. Daher reicht oft ein System.exit(). Soll das Fenster jedoch mit X und dispose() einfach nur geschlossen werden oder ist eine gemeinsame Behandlung gewünscht, ist es sinnvoll, in windowClosing() mit dispose() indirekt windowClosed() aufzurufen. Das sieht dann folgendermaßen aus:

class WL extends WindowAdapter
{
  public void windowClosing( WindowEvent e )
  {
    event.getWindow().dispose();
  }
  public void windowClosed( WindowEvent e )
  {
    // Das Fenster ist geschlossen, und jetzt können wir hier
    // weitermachen, etwa mit System.exit(), wenn alles
    // vorbei sein soll.
  }
}

Galileo Computing

15.2.2 Adapterklassen nutzedowntop

Der Nachteil der ersten Variante ist, dass wir immer alle Methoden implementieren müssen, auch wenn wir nur eine der vielen Funktionen benötigen. Hier helfen Adapterklassen – Klassen, die die Schnittstellen mit leeren Rümpfen implementieren. Hat beispielsweise die Schnittstelle WindowListener sieben Methoden, so steht in der Adapterklasse folgende Implementierung:

Listing 15.2   java.awt.event.WindowAdapter

public abstract class WindowAdapter
  implements WindowListenerWindowStateListenerWindowFocusListener
{
    public void windowOpened(WindowEvent e) {}
    public void windowClosing(WindowEvent e) {}
    public void windowClosed(WindowEvent e) {}
    public void windowIconified(WindowEvent e) {}
    public void windowDeiconified(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowDeactivated(WindowEvent e) {}
    public void windowStateChanged(WindowEvent e) {}
    public void windowGainedFocus(WindowEvent e) {}
    public void windowLostFocus(WindowEvent e) {}
}

Zusätzlich entdecken wir einige Methoden, die nicht direkt von unserem WindowListener stammen, sondern von zwei weiteren Schnittstellen, die in Java 1.4 hinzugekommen sind.

Abbildung
Hier klicken, um das Bild zu Vergrößern


Beispiel   Wenn wir jetzt einen Ereignisbehandler verwenden, erweitern wir einfach die Adapterklasse. Unser Programm zum Schließen des Fensters mit einer externen Adapterklasse sieht dann wie folgt aus:

Listing 15.3   FensterWegExternerAdapter.java

import java.awt.event.*;
import javax.swing.*;
public class FensterWegExternerAdapter
{
  public static void main( String[] args )
  {
    JFrame f = new JFrame();
    f.setSize( 400, 400 );
    f.setVisible( true );
    f.addWindowListener( new FensterWegAdapter() );
  }
}
class FensterWegAdapter extends WindowAdapter
{
  @Override
  public void windowClosing( WindowEvent e ) { System.exit(0); }
}


Galileo Computing

15.2.3 Innere Mitgliedsklassen und innere anonyme Klassedowntop

Wir haben für die Adapterklasse eine externe Klasse benutzt, das Erweitern wegen der Einfachvererbung schnell an seine Grenzen stößt. Mit inneren Klassen wird allerdings alles elegant. Dabei lassen sich innere Klassen auf unterschiedliche Weise verwenden. Einmal als Mitgliedsklasse, das heißt, die bisher als externe Klasse vorgelegene Klasse wird in eine andere Klasse hineingenommen. Im vorigen Beispiel bedeutet dies: Wir nehmen FensterWegAdapter in die Klasse FensterWegExternerAdapter auf und schreiben die Klassendefinition nicht unter der anderen Klasse. Dann kann die innere Klasse wie eine lokale Variablendeklaration noch in der Methode aufgenommen werden, die die addXXX-Listener()-Funktion beinhaltet.

Der zweite Weg führt über innere anonyme Klassen. Dadurch wird das Programm zwar schön kurz, doch lange Ereignisbehandler führen schnell zu unübersichtlichem Quellcode.


Beispiel   Wir implementieren unser Programm zum Schließen des Fensters mit einer inneren anonymen Klasse.

Listing 15.4   FensterWegInnerAnonym.java

import java.awt.event.*;
import javax.swing.*;
public class FensterWegInnerAnonym extends JFrame
{
  public FensterWegInnerAnonym()
  {
    setSize( 400400 );
      addWindowListener( new WindowAdapter() {
      @Override public void windowClosing ( WindowEvent e) {
        System.exit( 0 );
      }
    } );
    }
  public static void main( String[] args )
  {
    new FensterWegInnerAnonym().setVisible( true );
  }
}

Die Lösung hat den Vorteil, dass nicht extra eine eigene Klasse mit einem häufig überflüssigen Namen angelegt wird. Die Unterklasse von WindowAdapter ist nur hier sinnvoll und wird nur in diesem Kontext benötigt.


Galileo Computing

15.2.4 Generic Listener  toptop

Eine recht neue Methode haben die Entwickler ab Version 1.3 hinzugefügt: Generic Listener. Sie ist noch nicht sehr verbreitet, dennoch sollte sie erwähnt werden. Der Unterschied zu den bisher vorgestellten Möglichkeiten liegt darin, einem Verwalter die Ereignisquelle und das Ereignisziel vorzugeben. Das Ziel ist dabei eine beliebige Methode. Beim Auftreten eines Ereignisses findet das System automatisch mittels Reflection die von uns angegebene Methode und ruft sie auf. Bisher sind Generic Listener eine einfache Erweiterung der Proxy-Klassen und noch nicht in die Java-Standardbibliothek eingeflossen. Die Implementierung fasst jedoch mit Kommentaren nur zweihundert Zeilen. Wir werden auf Generic Listener zurückkommen, wenn wir Ereignisse von Schaltflächen kennen gelernt haben. Informationen zu den Generic Listenern gibt es auf der Web-Seite von Sun unter:

gp  http://java.sun.com/products/jfc/tsc/articles/generic-listener2/index.html
gp  http://java.sun.com/products/jfc/tsc/articles/generic-listener/index.html

Von dort kann auch die allgemeine Implementierung für eine Klasse GenericListener bezogen werden.

 << zurück




Copyright © Galileo Press GmbH 2005
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de