Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 23 - Grafikausgabe

## 23.2 Grundlagen der Grafikausgabe

- 23.2 Grundlagen der Grafikausgabe
  - 23.2.1 Anlegen eines Fensters
  - 23.2.2 Die Methode paint
  - 23.2.3 Das grafische Koordinatensystem
  - 23.2.4 Schließen eines Fensters

### 23.2.1 Anlegen eines Fensters

Um die Grafikfähigkeiten von Java nutzen zu können, muß das Paket `java.awt` eingebunden werden. Dies geschieht zweckmäßigerweise mit Hilfe folgender Anweisung am Anfang der Klassendefinition:

    import java.awt.*;

Danach stehen alle Klassen aus dem Paket `java.awt` zur Verfügung.

Zur Ausgabe von grafischen Elementen benötigt die Anwendung ein Fenster, auf das die Ausgabeoperationen angewendet werden können. Während bei der Programmierung eines Applets ein Standardfenster automatisch zur Verfügung gestellt wird, muß eine Applikation ihre Fenster selbst erzeugen. Da die Kommunikation mit einem Fenster über eine Reihe von Callback-Methoden abgewickelt wird, wird eine Fensterklasse in der Regel nicht einfach instanziert. Statt dessen ist es meist erforderlich, eine eigene Klasse aus einer der vorhandenen abzuleiten und die benötigten Interfaces zu implementieren.

Zum Ableiten einer eigenen Fensterklasse wird in der Regel entweder die Klasse `Frame` oder die Klasse `Dialog` verwendet, die beide aus `Window` abgeleitet sind. Da `Dialog` vorwiegend dafür verwendet wird, Dialogboxen zu erstellen, die über darin enthaltene Komponenten mit dem Anwender kommunizieren, wollen wir ihre Verwendung bis zum Kapitel 31 zurückstellen. Die wichtigste Klasse zur Ausgabe von Grafiken in Java-Applikationen ist also `Frame`.

Um ein einfaches Fenster zu erzeugen und auf dem Bildschirm anzuzeigen, muß ein neues Element der Klasse `Frame` erzeugt, auf die gewünschte Größe gebracht und durch Aufruf der Methode `setVisible` sichtbar gemacht werden:

    001 /* Listing2301.java */
    002
    003 import java.awt.*;
    004
    005 class Listing2301
    006 {
    007   public static void main(String[] args)
    008   {
    009     Frame wnd = new Frame("Einfaches Fenster");
    010
    011     wnd.setSize(400,300);
    012     wnd.setVisible(true);
    013   }
    014 }
| Listing2301.java

Listing 23.1: Ein einfaches Fenster erzeugen

Das Ausführen dieses Programms führt dazu, daß ein Fenster mit dem Titel »Einfaches Fenster« erzeugt und in der Größe 400*300 Pixel auf dem Bildschirm angezeigt wird.

|  | Da wir noch keinen Code für die Behandlung von GUI-Events eingebaut haben, bietet das Fenster lediglich das von Windows her bekannte Standardverhalten. Es läßt sich verschieben und in der Größe verändern und besitzt eine Titel- und Menüleiste, die mit einem Systemmenü ausgestattet ist. Anders als in anderen grafikorientierten Systemen gibt es noch keine Funktionalität zum Beenden des Fensters. Das Beispielprogramm kann daher nur durch einen harten Abbruch seitens des Benutzers (z.B. durch Drücken von `[STRG]`+`[C]` in der DOS-Box, aus der das Fenster gestartet wurde) beendet werden. Wir werden im nächsten Beispiel Programmcode zum ordnungsgemäßen Schließen des Fensters einfügen. |  |
Hinweis

### 23.2.2 Die Methode paint

Die Ausgabe in ein Fenster erfolgt durch Überlagern der Methode `paint`, die immer dann aufgerufen wird, wenn das Fenster ganz oder teilweise neu gezeichnet werden muß. Dies ist beispielsweise dann der Fall, wenn das Fenster zum ersten Mal angezeigt wird oder durch Benutzeraktionen ein Teil des Fensters sichtbar wird, der bisher verdeckt war. `paint` bekommt beim Aufruf eine Instanz der Klasse `Graphics` übergeben:

    public void paint(Graphics g)
| java.awt.Component

`Graphics` ist Javas Implementierung eines Device-Kontexts (auch Grafikkontext genannt) und stellt somit die Abstraktion eines universellen Ausgabegeräts für Grafik und Schrift dar. Die Klasse bietet Methoden zur Erzeugung von Linien-, Füll- und Textelementen. Darüber hinaus verwaltet `Graphics` die Zeichenfarbe, in der alle Ausgaben erfolgen, und einen Font, der zur Ausgabe von Schrift verwendet wird. Ein Device-Kontext kann daher als eine Art universelles Ausgabegerät angesehen werden, das elementare Funktionen zur Ausgabe von farbigen Grafik- und Schriftzeichen zur Verfügung stellt.

### 23.2.3 Das grafische Koordinatensystem

Die Ausgabe von Grafik basiert auf einem zweidimensionalen Koordinatensystem, dessen Ursprungspunkt (0,0) in der linken oberen Ecke liegt (siehe Abbildung 23.1). Positive x-Werte erstrecken sich nach rechts, positive y-Werte nach unten. Die Maßeinheit entspricht einem Bildschirmpixel und ist damit geräteabhängig.

In den meisten Fällen steht dem Programm nicht das gesamte Fenster zur Ausgabe zur Verfügung, sondern es gibt Randelemente wie Titelzeilen, Menüs oder Rahmen, die nicht überschrieben werden können. Mit der Methode `getInsets` kann die Größe dieser Randelemente ermittelt werden. Wir werden darauf in Kapitel 24 noch einmal zurückkommen.

Abbildung 23.1: Das Koordinatensystem von Java

### 23.2.4 Schließen eines Fensters

Ein einfaches Hauptfenster, wie es im vorigen Beispiel gezeigt wurde, besitzt keinerlei Funktionalität, um vom Anwender auf geordnete Weise geschlossen werden zu können. Alle entsprechenden Dialogelemente im Systemmenü sind ohne Funktion. Tatsächlich mußten wir das Programm durch Drücken von `[STRG]`+`[C]` abbrechen. Ohne zu tief in Details einzusteigen (diese werden in Kapitel 28 und Kapitel 29 nachgereicht) wollen wir an dieser Stelle beispielhaft einen geeigneten Mechanismus zum Schließen des Hauptfensters vorstellen.

Soll der Anwender ein Hauptfenster schließen können, muß ein `WindowListener` registriert werden. Dabei handelt es sich um ein Interface, dessen Methode `windowClosing` aufgerufen wird, wenn der Anwender über das System-Menü oder den Schließen-Button das Fenster schließen will. Das Programm wird in diesem Fall `setVisible(false)` aufrufen, um das Fenster zu schließen, und nötigenfalls `System.exit` anhängen, um zusätzlich das Programm zu beenden.

Da ein solcher `WindowListener` in praktisch jedem GUI-Programm benötigt wird, wollen wir eine Klasse `WindowClosingAdapter` vorstellen, die in allen folgenden Beispielen wiederverwendet werden kann:

    001 /* WindowClosingAdapter.java */
    002
    003 import java.awt.*;
    004 import java.awt.event.*;
    005
    006 public class WindowClosingAdapter
    007 extends WindowAdapter
    008 {
    009   private boolean exitSystem;
    010
    011   /**
    012    * Erzeugt einen WindowClosingAdapter zum Schliessen
    013    * des Fensters. Ist exitSystem true, wird das komplette
    014    * Programm beendet.
    015    */
    016   public WindowClosingAdapter(boolean exitSystem)
    017   {
    018     this.exitSystem = exitSystem;
    019   }
    020
    021   /**
    022    * Erzeugt einen WindowClosingAdapter zum Schliessen
    023    * des Fensters. Das Programm wird nicht beendet.
    024    */
    025   public WindowClosingAdapter()
    026   {
    027     this(false);
    028   }
    029
    030   public void windowClosing(WindowEvent event)
    031   {
    032     event.getWindow().setVisible(false);
    033     event.getWindow().dispose();
    034     if (exitSystem) {
    035       System.exit(0);
    036     }
    037   }
    038 }
| WindowClosingAdapter.java

Listing 23.2: Die Klasse WindowClosingAdapter

Um den gewünschten Effekt zu erzielen, muß der Listener beim zu schließenden Fenster durch Aufruf von `addWindowListener` registriert werden. Dadurch wird beim Anklicken des Schließen-Buttons (bzw. beim Aufrufen des entsprechenden Systemmenüeintrags) die Methode `windowClosing` aufgerufen und das Fenster geschlossen. Falls `true` an den Konstruktor übergeben wurde, beendet der Listener das gesamte Programm.

Damit kann Listing 23.1 wie folgt verbessert werden:

    001 /* Listing2303.java */
    002
    003 import java.awt.*;
    004
    005 class Listing2303
    006 {
    007   public static void main(String[] args)
    008   {
    009     Frame wnd = new Frame("Fenster schließen");
    010     wnd.addWindowListener(new WindowClosingAdapter(true));
    011     wnd.setSize(400,300);
    012     wnd.setVisible(true);
    013   }
    014 }
| Listing2303.java

Listing 23.3: Das Schließen des Fensters ermöglichen

|  | Damit sich die Beispiele, in denen der `WindowClosingAdapter` verwendet wird, kompilieren lassen, muß die Datei WindowClosingAdapter.java im aktuellen Verzeichnis vorhanden sein. Sie befindet sich auf der CD-ROM zum Buch oder kann direkt aus Listing 23.2 entnommen werden. |  |
Hinweis

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de