AWT-Detailbetrachtung

JAVA 3D – Seminar
Wintersemester 2002/2003
Christian Schneider
AWT – Detailbetrachtung
Das Abstract Window Toolkit
Fachhochschule Fulda – University of Applied Sciences
Fachbereich Angewandte Informatik
Marquardstraße 35, 36039 Fulda
Postfach 2254, 36012 Fulda
Inhalt
0
EINLEITUNG ................................................................................................................................... 1
1
EINFÜHRUNG INS AWT ................................................................................................................ 2
2
1.1
Was ist das AWT? ................................................................................................................... 2
1.2
Plattformunabhängigkeit .......................................................................................................... 2
1.3
Komponenten – Die Grundlage des AWT ............................................................................... 4
1.4
Klassendiagramme des AWT .................................................................................................. 5
DIE BAUSTEINE DER GRAFISCHEN BENUTZEROBERFLÄCHE DES AWT IM DETAIL ........ 7
2.1
2.1.1
Knöpfe (Button) ............................................................................................................. 8
2.1.2
Schalter (Checkbox) ....................................................................................................... 9
2.1.3
Auswahlfelder (Choice) ................................................................................................ 11
2.1.4
Listenfelder (List) ........................................................................................................ 12
2.1.5
Menüs (Menu, MenuItem etc.) .................................................................................. 13
2.1.6
Textmarken (Label) ..................................................................................................... 14
2.1.7
Textfelder (TextField) ................................................................................................ 15
2.2
3
4
Die Basis-Bausteine ................................................................................................................ 7
Weitere Bausteine, um Benutzereingaben zu ermöglichen .................................................. 16
2.2.1
Textbereiche (TextArea) ............................................................................................. 16
2.2.2
Bildlaufleisten und Schiebebalken (Scrollbar) .......................................................... 17
2.3
Containers: Windows, Panels und Scroll Panes ................................................................... 19
2.4
Canvas................................................................................................................................... 19
DAS EVENT-MODELL DES AWT ................................................................................................ 21
3.1
Event-Lauscher definieren ..................................................................................................... 22
3.2
Lauscher für Quelle registrieren ............................................................................................ 23
3.3
Adapter .................................................................................................................................. 23
3.4
Eventverarbeitung durch Listener und Adapter ..................................................................... 24
3.5
Ein einfaches Beispiel für Eventbehandlung ......................................................................... 25
GRAFIKAUSGABE ....................................................................................................................... 26
4.1
Graphics-Klasse .................................................................................................................... 26
4.2
Methoden allgemein .............................................................................................................. 26
4.3
Zeichengebiete ...................................................................................................................... 27
4.3.1
Koordinatensystem ........................................................................................................ 27
4.3.2
Clipping .......................................................................................................................... 27
4.4
Farbe ..................................................................................................................................... 28
4.5
Grafikfiguren .......................................................................................................................... 28
4.6
Übersicht über die Methoden der Graphics-Klasse............................................................... 29
5
LITERATUR- UND QUELLENANGABE ...................................................................................... 30
6
ANHANG ....................................................................................................................................... 30
Christian Schneider
AWT - Detailbetrachtung
0
Einleitung
Diese Arbeit entstand im Rahmen der Lehrveranstaltung „Java3D – Seminar“ bei Prof. Dr.
Heinzel. Ziel der Ausarbeitung ist es, dem Teilnehmer der Veranstaltung eine Übersicht über
die verschiedenen Möglichkeiten des AWT-Packages zu geben. AWT (Abstrakt Window
Toolkit) ist die Grundlage aller Grafikanwendungen in Java, so dass der Programmierer
dieses Package auf jeden Fall kennen sollte.
Diese Einführung stellt nicht den Anspruch der absoluten Vollständigkeit, da es im zur
Verfügung stehenden Zeitrahmen unmöglich wäre, alle Aspekte des AWT zu behandeln. Die
folgende Ausarbeitung dient als Leitfaden durch die große Welt des AWT von Java. Es sei
auch auf Fachliteratur verwiesen (s. Absatz 5. Literatur- und Quellenangabe).
Christian Schneider
1
AWT - Detailbetrachtung
1
Einführung ins AWT
1.1
Was ist das AWT?
Zur Entwicklung von Applets und grafischen Applikationen in Java™ benötigt man zu einem
gewissen Grad das Abstract Window Toolkit, im Nachfolgenden AWT genannt. Es ist ein Teil
des frei verfügbaren Java 2 SDK, des Java 2 Software Development Kits. Auch in den
früheren Versionen der Java-Entwicklungsumgebungen, dem JDK (Java Development Kit)
war das AWT bereits vorhanden. In den folgenden Ausführungen werden die alten JDK-1.0Standards nicht mehr berücksichtigt.
Das AWT beinhaltet verschiedene Klassen, welche alle mit java.awt beginnen. Mit ihnen
werden dem Programmierer hunderte von Klassen und Methoden zur Verfügung gestellt,
aus denen er sich, einem Baukasten ähnlich, die gewünschte Oberfläche und Funktion holen
kann. Es ist also nicht schwer, in einer Applikation oder einem Applet eine grafische
Benutzeroberfläche zu nutzen, man muss „nur“ die richtige Klasse zur Hand nehmen und sie
nach seinen Wünschen (um-)gestalten.
1.2
Plattformunabhängigkeit
Das AWT ist eine der wichtigsten Klassenbibliotheken von Java, wenn nicht sogar die
wichtigste. Es ist plattformunabhängig und stellt das GUI auf jeder Plattform etwas anders
dar.
Was ist das GUI? Unter GUI (Graphical User Interface) versteht man die grafische
Benutzerschnittstelle einer Anwendung (Applikation oder Applet). Das AWT stellt eine GUIBibliothek dar und „vermittelt“ quasi zwischen dem Java-Programm und dem GUI des
Betriebssystems. Das AWT wurde von Anfang an so entworfen, dass es ein
plattformunabhängiges API (engl. application programming interface) haben und dennoch
der Applikation das jeweilige betriebssystemspezifische Aussehen geben sollte. Zum
Beispiel hat das AWT nur ein API für Knöpfe (in der Button-Klasse), aber es sieht auf einem
Macintosh anders aus als auf einem PC, auf dem z.B. Windows XP läuft.
Das AWT nutzt die Standardsteuerelemente der jeweiligen Plattform, was zur Folge hat,
dass sich die Funktionalität der AWT-Komponenten an diesen Standardsteuerelementen
orientiert. Für jedes Standardsteuerelement des Betriebssystems gibt es im AWT eine
eigene
Klasse.
Die
AWT-Komponenten
setzten
als
so
genannte
„heavyweight“-
Komponenten auf den betriebssystemspezifischen Implementierungen (auch „peers“ (auf
deutsch „Gleiche“) genannt) auf.
Christian Schneider
2
AWT - Detailbetrachtung
Java
Java
Native GUI
Programm
AWT
(WinXP, etc.)
Christian Schneider
Display
3
AWT - Detailbetrachtung
1.3
Komponenten – Die Grundlage des AWT
Ein Programm, das auf Fenster basiert, wird vom AWT als eine Hierarchie von ineinander
verschachtelten Bausteinen angesehen, den so genannten Komponenten. Für jede
Komponente gibt es im AWT eine eigene Klasse, von der der Programmierer entweder direkt
eine Instanz bilden oder eigene Klassen ableiten kann.
Man kann folgende wichtigen Gruppen von Klassen unterscheiden, je nach dem, welche
Aufgabe den einzelnen Bausteinen beim Aufbau der grafischen Benutzeroberfläche
zukommt:

Component: Das AWT ist eine Welt von Komponenten. Die java.awt.ComponentKlasse ist eine abstrakte Klasse für Komponenten wie Buttons, Labels, Lists usw. Die
meisten Klassen im AWT sind Unterklassen der java.awt.Component-Klase. Auf ihr
baut das AWT auf. Siehe Klassendiagramm unter 1.4.

Container ist eine abstrakte Klasse, die von Component erbt. Container sind
Bausteine, die mehrere andere Komponenten enthalten (engl. contain) können. In ihnen
werden die Oberflächenelemente gruppiert und die Oberfläche wird so strukturiert. Die
wichtigsten Unterklassen von Container sind Panel, Applet, Window, Dialog und
Frame.

LayoutManager
ist
ein
Interface,
das
Methoden
zur
Positionierung
und
Größeneinteilung von Objekten innerhalb eines Containers definiert. Java™ definiert
mehrere Standard-Layout-Manager. (Hierzu gibt es im Rahmen der Veranstaltung einen
gesonderten Beitrag.)

Die Klasse Graphics ist die abstrakte Oberklasse aller Grafikkontexte, die
Anwendungen ermöglichen, auf Komponenten usw. zu zeichnen.

Eine Komponente der Klasse Canvas (dt. Zeichenfläche) ist ein spezieller Baustein, der
zum Malen und zur Anzeige von Bildern und Grafiken verwendet wird.
Christian Schneider
4
AWT - Detailbetrachtung
1.4
Klassendiagramme des AWT
Abbildung 1-1 Klassendiagramm - java.awt
Christian Schneider
5
AWT - Detailbetrachtung
Abbildung 1-2 Klassendiagramm - java.awt-components
Wie in dem Klassendiagramm
(aus Java™ API, Band 2, der offiziellen Dokumentation von JavaSoft)
zu sehen
ist, erben die meisten Komponenten der grafischen Benutzeroberfläche von der AWT
Component-Klasse, mit Ausnahme der Menü-Komponenten. Aufgrund von Plattform
übergreifenden Einschränkungen (z.B. die fehlende Möglichkeit, die Menü-HintergrundFarbe zu setzen) erben die Menü-Komponenten von der AWT-Klasse MenuComponent.
Christian Schneider
6
AWT - Detailbetrachtung
2
Die Bausteine der grafischen Benutzeroberfläche des AWT im Detail
2.1
Die Basis-Bausteine
Die Klassen (besser gesagt die Instanzen/Objekte der Klassen) Button, Checkbox,
Choice, List, MenuItem und TextField stellen „klassische“ Kontrollmittel dar. Sie sind
die am meisten genutzten Arten, einem Java-Programm Instruktionen zu geben. Wenn ein
Benutzer einen dieser Bausteine aktiviert – z.B. durch Klicken eines Knopfes oder durch
Drücken der Eingabetaste in einem Textfeld – dann erzeugt er ein sog. ActionEvent.
Damit können mittels des entsprechenden Event-Listeners Befehle ausgeführt werden. Das
Event-Modell von AWT wird später in Abschnitt 3 betrachtet. Das Label stellt eine
Ausnahme dar. Es stellt lediglich eine nicht auswählbare Textzeile dar.
Abbildung 2-1 Überblick über alle wichtigen AWT-Komponenten
Christian Schneider
7
AWT - Detailbetrachtung
2.1.1
Knöpfe (Button)
public class java.awt.Button
extends java.awt.Component
{
// Konstruktoren
public Button();
public Button(String label);
// Methoden
public void addNotify();
public String getLabel();
// Die Button-Klasse
// erzeugt Knopf unbeschriftet
// erzeugt Knopf mit Beschriftung
// hier nicht betrachtet
/* Rückgabe der Beschriftung oder
null, wenn kein Label vorh.*/
protected String paramString(); /* Rückgabe des Zustands des
Knopfes als Zeichenkette */
public void setLabel(String label);
}
Diese Klasse erzeugt eine beschriftete Schaltfläche (engl. labeled button), auch kurz Knopf
genannt. Die Anwendung kann reagieren, wenn auf die Schaltfläche gedrückt wird.
Nachfolgend sehen wir drei verschiedene Ansichten eines „Abbrechen“-Knopfes unter
Windows:
Abbildung 2-2 Knopfzustände
Das erste Bild zeigt den Knopf im Normalzustand. In der zweiten Ansicht hat der Knopf den
Eingabefokus, d.h. der dunkle Rand zeigt dem Benutzer, dass der Knopf aktiv ist. Und im
dritten Fall wird gerade vom Benutzer auf den Knopf per Maus geklickt. So werden die damit
verbundenen Aktionen ausgelöst. Wird ein Knopf gedrückt und danach wieder losgelassen,
so sendet das AWT ein entsprechendes Ereignis (Event) an das Knopfobjekt1. Das EventHandling wird in Abschnitt 3 noch eingehender betrachtet.
Im Folgenden ist das Bild eines (einfachen) Applets zu sehen, das drei Knöpfe zeigt.
Abbildung 2-3 ButtonDemo – Applet
//In der Initialisierung des Applets steht folgendes:
public void init() {
b1 = new Button();
b1.setLabel("Mittleren Knopf deaktivieren");
b2 = new Button("Mittleren Knopf");
b3 = new Button("Mittleren Knopf aktivieren");
b3.disable();
1
In Java 1.1 sendet das AWT alle Maus-, Tastatur und Fokusereignisse, die über dem Knopf auftreten.
In Java 1.0 sendet das AWT keine Maus- oder Fokusereignisse.
Christian Schneider
8
AWT - Detailbetrachtung
. . .
Hier kann man gut sehen, wie ein Knopf angelegt wird. In der init()-Funktion des Applets,
d.h. bei seiner Initialisierung, werden drei Instanzen der Klasse Button angelegt, nämlich
b1, b2 und b3. Der Knopf b1 wird mittels des einfachen Konstruktors instanziiert, ohne ihm
eine Beschriftung zu verpassen. Dies wird mit b1.setLabel("Mittleren
Knopf
deaktivieren"); nachgeholt. Den Knöpfen b2 und b3 werden mittels des Konstruktors
Beschriftungen übergeben. „b3.disable();“ bedeutet, wie oben leicht zu sehen, dass der
dritte Knopf zu Beginn des Applets deaktiviert wird, d.h. nicht der Benutzer kann ihn nicht
anklicken. Nun müssen die Knöpfe nur noch dem Applet, welches ja auch einen Container
darstellt, hinzugefügt werden.
. . .
// und hier werden die Knöpfe dem Applet (Container) hinzugefügt.
add(b1);
add(b2);
add(b3);
}
2.1.2
Schalter (Checkbox)
Die Klasse Checkbox stellt Checkboxen oder auch Schalter zur Verfügung, die zwei
Zustände annehmen können, entweder „ein“ oder „aus“. Diese Zustände werden durch eine
boolsche Variable beschrieben (z.B.: boolean state). Ist der Schalter aktiviert, so sein
Status „true“. Das folgende Bild zeigt ein (einfaches) Applet, das die Funktionsweise von
Schaltern demonstriert:
Abbildung 2-4 Checkbox-Demo
Wie leicht auf dem Bild zu sehen ist, gibt es zwei „Arten“ von Schaltern. Auf der linken Seite
sind voneinander unabhängige Schalter zu sehen, die alle entweder „ein“ oder „aus“ sein
können. Die Schalter auf der rechten Seite sind in einer sog. CheckboxGroup angeordnet,
also einer Gruppierung von Schaltern. Wenn Schalter zu einer Schaltergruppe gehören,
kann
immer
nur
einer
dieser
Schalter
„ein“
(true)
sein.
Die
Schaltergruppe
CheckboxGroup ist eine selbständige Klasse.
Christian Schneider
9
AWT - Detailbetrachtung
Der folgende Code-Ausschnitt zeigt, wie in das Applet in Abbildung 2-4 die Schalter
hinzugefügt werden:
. . .
Panel p1, p2;
//Diesen Panels werden die Schalter hinzugefügt.
Checkbox cb1, cb2, cb3; //Dies sind die unabhängigen Schalter.
Checkbox cb4, cb5, cb6; //Diese Schalter gehören zu der Gruppe.
CheckboxGroup cbg;
//Checkboxgruppe cbg wird deklariert.
cb1 = new Checkbox();
//Konstruktor. Default Status ist "aus" (false).
cb1.setLabel("Checkbox 1"); //Schalter wird beschriftet.
cb2 = new Checkbox("Checkbox 2"); //In der Klammer steht die Beschriftung.
cb3 = new Checkbox("Checkbox 3");
cb3.setState(true);
//Den Schalter auf “an” schalten (true).
. . .
cbg = new CheckboxGroup();
cb4 = new Checkbox("Checkbox 4", cbg, false); //Status: “aus” (false)
cb5 = new Checkbox("Checkbox 5", cbg, false); // Status: “aus”
cb6 = new Checkbox("Checkbox 6", cbg, true); // Status: “ein” (true)
. . . /* cb4, cb5 und cb6 werden im Konstruktor bereits der CheckboxGroup
cbg hinzugefügt.*/
p1 = new Panel();
p1.setLayout(new FlowLayout());
p1.add(cb1);
// Schalter zu Panel 1 hinzufügen
p1.add(cb2);
// Schalter zu Panel 1 hinzufügen
p1.add(cb3);
// Schalter zu Panel 1 hinzufügen
// usw...
Für Checkboxen gibt es auch interessante Methoden, z.B. liefert public boolean
getState() den Wert des Schalters, also seinen Zustand zurück. Angewendet auf den
dritten Schalter (auf dem Bild unten links), würde cb3.getState() den Wert „true“
zurückgeben. Mit der Methode void setState(boolean state) kann man einem
Schalter einen Zustand zuweisen, z.B. mit cb1.setState(true) würde man den Schalter
links oben aktivieren. Mit setLabel(String s) kann man dem Schalter eine neue
Beschriftung verpassen. Dann wird die Beschriftung mit dem Wert des Labels (Parameter in
der
Klammer
der
Methode)
mit
dem
neuen
String
überschrieben.
Mit
getCheckboxGroup() erhält man als Rückgabewert die CheckboxGroup, in der sich der
aufrufende
Schalter
befindet
oder
setCheckboxGroup(CheckboxGroup
null,
g)
wenn
er
keiner
Gruppe
angehört.
Mit
kann man den Schalter in eine Gruppe
hinzufügen, indem man ihn in dem Argument in der Klammer der Methode die
entsprechende CheckboxGroup übergibt. Befindet er sich bereits in einer Gruppe, wird er
aus dieser entfernt. Die CheckboxGroup überwacht den Status der in ihr enthaltenen
Schalter.
Christian Schneider
10
AWT - Detailbetrachtung
2.1.3
Die
Auswahlfelder (Choice)
Klasse
Choice
bietet
ein
aufblendbares
Menü,
das
dem
Benutzer
Auswahlmöglichkeiten zur Verfügung stellt. Daher heißt die Klasse Choice oder
Auswahlmenü (engl. choice menu). Die aktuelle Auswahl wird als Titel des Menüs angezeigt.
Auswahlmenüs sind nützlich, um eine (große) Anzahl von Alternativen mit begrenztem Platz
darzustellen, für den Fall, dass der Nutzer nicht alle Möglichkeiten gleichzeitig sehen muss.
Ein anderer Name für Choices sind Pop-Up-Listen. Im Folgenden wird ein Beispiel eines
(einfachen) Applets behandelt, das wie folgt aussieht, das volle Beispiel ist im Anhang
enthalten.
Abbildung 2-5 ChoiceDemo
//...Hier werden Instanzen der Variablen definiert:
Choice choice; //pop-up list of choices
//...Hier wird initialisiert:
choice = new Choice();
//neue Auswahl
choice.addItem("ichi");
//neues Auswahlelement “ichi”, index = 0!!!
choice.addItem("ni");
//neues Auswahlelement “ni”
choice.addItem("san");
//neues Auswahlelement “san”
choice.addItem("yon");
//neues Auswahlelement “yon”
label = new Label();
//Text neben der Auswahl
setLabelText(choice.getSelectedIndex(), choice.getSelectedItem());
//. . . usw...
Es gibt noch weitere nützliche Methoden, die von der Klasse bereitgestellt werden:
int countItems()
String getItem(int)
void select(int)
void select(String)
Christian Schneider
 gibt die Anzahl der Elemente in der Auswahl zurück
 gibt den String zurück, der an Position (int) der Auswahl steht
!!!Zu beachten: Die Nr. des ersten Elements der Liste ist 0!!!
 wählt das Element aus, das an Position (int) der Auswahl steht
 wählt das Element aus, das den spezifizierten String anzeigt
11
AWT - Detailbetrachtung
2.1.4
Listenfelder (List)
Die Komponente List stellt sich dem Anwender als eine verschiebbare Liste (engl. scrolling
list) von Texteinträgen (engl. text items) dar. Die Liste kann so konfiguriert werden, dass der
Benutzer nur einen oder mehrere Einträge auswählen kann. Das Anklicken eines noch nicht
gewählten Eintrages wählt ihn aus (engl. select) Das Anklicken eines bereits ausgewählten
Eintrages nimmt die Auswahl wieder zurück (engl. deselect). Ist bei der Erzeugung der Liste
mittels des Konstruktors public List(int rows, boolean multipleSelections);
das zweite Argument false, so kann maximal ein Eintrag der Liste ausgewählt werden. z.B.:
List l = new List(4, false); //4 Eintr. sichtbar, ein Element auswählbar.
Wird ein Element der Liste ausgewählt, so sendet das AWT der Liste ein LIST_SELECTEreignis. Gilt das Element als nicht ausgewählt, dann sendet das AWT der verschiebbaren
Liste ein LIST_DESELECT-Ereignis. Wird ein Doppelklick auf dem Element ausgeführt (oder
die Returntaste gedrückt), schickt das AWT dem LIST_SELECT- oder LIST_DESELECTEreignis ein ACTION_EVENT hinterher. Mit entsprechenden ActionListener und ItemListener
können dann Events auf der Liste abgefangen werden und Anweisungen aufgerufen werden.
List spanish = new List(4, true);
spanish.addItem("uno");
spanish.addItem("dos");
spanish.addItem("tres");
spanish.addItem("cuatro");
spanish.addItem("cinco"); //usw.
Abbildung 2-6 ListDemo
Außer addItem(String item) (s.o.) gibt es noch weitere wichtige Methoden:
public String getItem(int index)
int countItems()
void addItem(String, int)
void replaceItem(String, int)
void clear()
void delItem(int)
void delItems(int, int)
 gibt den String der Liste an der angegebenen Position zurück
 gibt die Anzahl der Elemente in der Liste zurück
 fügt einen String an der angegebenen Position ein (index)
 ersetzt den Eintrag an der angegebenen Position ein (index)
 leert die Liste
 löscht den Eintrag an der angegebenenPosition
 löscht Einträge zwischen den angegebenen Positionen
(inklusiv der „Ränder“)
int getSelectedIndex()
 gibt den Index des ausgewählten Elements zurück, -1, wenn
nichts gewählt ist.
int[] getSelectedIndexes()
 gibt den Index der ausgewählten Elemente zurück
String getSelectedItem()
 wie getSelectedIndex(), liefert nur den String des Items
String[] getSelectedItems()
 vgl. getSelectedIndexes()
void select(int),
 Selektiert oder deselektiert das Element an der angegebenen
void deselect(int)
Position
boolean isSelected(int)
 liefert “true”, wenn das angegebene Item ausgewählt ist.
int getRows()
 liefert Anzahl der sichtbaren Zeilen
boolean allowsMultipleSelections()
 liefert “true”, wenn mehrfache Auswahl möglich ist
boolean setMultipleSelections(true)  ermöglicht mehrfache Auswahl (bei true, bei false nicht)
void makeVisible(int)
 zwingt angegeben Eintrag, sichtbar zu sein
int getVisibleIndex()
 liefert Pos. des Eintrags, der zuletzt durch makeVisible()
sichtbar gemacht wurde
Christian Schneider
12
AWT - Detailbetrachtung
2.1.5
Menüs (Menu, MenuItem etc.)
Menüs sind mit Auswahlfelder (Choice) vergleichbar, jedoch sind sie wesentlich
umfassender. Im Gegensatz zu den bisher erklärten Komponenten erben Menüs ihre
Funktionalität nicht von der Klasse Component, sondern von MenuComponent, weil einige
Plattformen Menüs schwerwiegende Einschränkungen auferlegen.
Im AWT stehen folgende Subklassen von MenuComponent zur Realisierung von Menüs zur
Verfügung:

MenuItem zur Darstellung eines Menüeintrags

CheckboxMenuItem, denen eine Checkbox zugeordnet ist. So kann ein solches
Menüelement ähnlich einer Checkbox ausgewählt werden. CheckboxMenuItem ist
eine Subklasse von MenuItem.

Menu repräsentiert ein vollständiges Menü-Objekt und ist eine Subklasse der Klasse
MenuItem, so dass Submenüs leicht erzeugt werden können, indem ein Menü
einfach einem anderen hinzugefügt wird.

MenuBar repräsentiert die Zuweisung einer Gruppe von Menüs an ein Fenster.
Für jede Menükomponente können Events abgefangen werden, es kann auf Klicks
entsprechend reagiert werden. Dieses Event-Handling wird hier nicht weiter beachtet. EventHandling siehe Abschnitt 3 (Das Event-Modell des AWT).
Im Folgenden wird ein Beispielprogramm wird die Verwendung eines Menüs demonstriert:
Menu
MenuBar
MenuItem
Abbildung 2-7 Menü Demo
public class Menus extends Frame {// eigene Klasse Menus von Frame ableiten
public Menus(String s) {
// String s für Fenster Titel
super(s);
//Aufruf des Konstruktors der Oberklasse (für Titel)
MenuBar mb;
// Deklaration einer Menüleiste
Menu m1, m2;
// Deklaration der Menüs m1 und m2
MenuItem m1_1, m1_2,m2_1, m2_2;
// Deklaration der Menükomponenten
mb = new MenuBar();// Instanziierung der Menüleiste mb
Christian Schneider
13
AWT - Detailbetrachtung
setMenuBar(mb); // Aktivierung der Menüleiste im Fenster
m1 = new Menu("Menü 1"); // Instanziierung des Menüs m1
mb.add(m1);
// Hinzufügen des 1. Menüs zur Menüleiste
m1_1 = new MenuItem("Menüeintrag 1_1");
// Instanziierung der Menükomponente m1_1
m1.add(m1_1);
// Hinzufügen von m1_1 zum Menü 1
m1_2 = new MenuItem("Menüeintrag 1_2"); // usw. wie oben
m1.add(m1_2);
m2 = new Menu("Menü 2");
mb.add(m2);
m2_1 = new MenuItem("Menüeintrag 2_1");
m2.add(m2_1);
m2_2 = new MenuItem("Menüeintrag 2_2");
m2.add(m2_2);
} ...
2.1.6
Textmarken (Label)
Eine Textmarke (engl. label) ist eine Komponente, die einen Text in einem (beliebigen)
Container platziert. Der Text kann von der Anwendung verändert werden, der Benutzer kann
ihn jedoch nicht direkt editieren. Das Layout der Textmarke wird automatisch gesetzt.
Zur Definition eines Labels können folgende Konstruktoren verwendet werden:

Label() erzeugt eine leere Textmarke, in der der Text linksbündig angeordnet wird.

Label(String) erzeugt eine Textmarke mit dem als Parameter übergebenen Text.
Der Text wird ebenfalls linksbündig dargestellt.

Label(String, int) erzeugt die gleiche Ausgabe wie Label(String), nur legt
der zweite Parameter die Ausrichtung des Textes innerhalb der Textmarke fest.
Hierzu können die Integer-Konstanten (aus der Klasse Label) Label.LEFT,
Label.CENTER und Label.RIGHT verwendet werden.
Abbildung 2-8 Label Beispiel
Das folgende Applet stellt ein Beispiel für die Verwendung von Textmarken dar, wie sie in
Abbildung 2-8 zu sehen ist:
import java.awt.*;
import java.applet.*;
public class Textmarke extends Applet {
Label links = new Label("Label 1", Label.LEFT); // neue Textmarke
Label zentriert = new Label("Label 2", Label.CENTER); // neue Textmarke
Label rechts = new Label("Label 3", Label.RIGHT); // neue Textmarke
Font f = new Font("Times", Font.BOLD, 20);
public void init() {
setFont(f);
// Einstellen der Schriftart Times, Fett, Größe 20
add(links);
// 1. Textmarke hinzufügen
add(zentriert); // 2. Textmarke hinzufügen
Christian Schneider
14
AWT - Detailbetrachtung
add(rechts);
// 3. Textmarke hinzufügen
}
}
2.1.7
Textfelder (TextField)
Im Gegensatz zu Textmarken (s. 2.1.6) sind Textfelder vom Benutzer editierbar. Hierzu stellt
Java die Klasse TextField zur Verfügung, deren Instanzen mit den folgenden
Konstruktoren angelegt werden können:

TextField() erzeugt ein leeres Texteingabefeld ohne Größenangabe.

TextField(String) erzeugt ein Texteingabefeld, das mit dem als Parameter
übergebenen Text gefüllt wird. Es erfolgt ebenfalls keine Größenangabe.

TextField(String, int) erzeugt ein Textfeld, wobei der Integer-Parameter die
Breite des Feldes in der Anzahl der möglichen Buchstaben angibt. Es kann hier auch
ein leerer String als String-Parameter übergeben werden.
Die Klasse TextField stellt einige Methoden zur Verfügung, mit denen man die Textfelder
kontrollieren kann:

getText() gibt den im Textfeld enthaltenen Text zurück,

setText(String) setzt diesen Text entsprechend,

isEditable() gibt einen booleschen Wert zurück, der angibt, ob das Textfeld
editierbar ist (true) oder nicht (false),

setEditable(boolean) erlaubt (true) oder erlaubt nicht (false) das Editieren
des Feldes.

setEchoChar(Char) ersetzt den eingegebenen Text durch das Zeichen Char.
Abbildung 2-9 Textfeld-Demo
Der folgende Code erzeugt ein Applet, das Textfelder demonstriert. Die Ausgabe ist in
Abbildung 2-9 zu sehen.
Christian Schneider
15
AWT - Detailbetrachtung
import java.awt.*;
import java.applet.*;
public class Textfeld extends Applet {
Label benutzerLabel = new Label("Benutzername");
TextField benutzerFeld = new TextField(50);
// Textfeld Demo
// Beschriftung
// Textfeld erzeugen
Label passwortLabel = new Label("Passwort");
TextField passwortFeld = new TextField(50);
// Beschriftung
// Textfeld erzeugen
public void init() {
add(benutzerLabel);
add(benutzerFeld);
add(passwortLabel);
passwortFeld.setEchoChar('$');
add(passwortFeld);
}
hinzufügen
hinzufügen
hinzufügen
als $ darstellen
hinzufügen
//
//
//
//
//
Komponenten
Komponenten
Komponenten
Textausgabe
Komponenten
}
2.2
Weitere Bausteine, um Benutzereingaben zu ermöglichen
Sollten die unter 2.1 genannten Bausteine nicht geeignet oder ausreichend sein, kann man
auch noch die Klassen Scrollbar (engl. für Bildlaufleiste) und TextArea (engl. für
Textflächen) nutzen. Die Scrollbar-Klasse kann sowohl als Bildlaufleiste als auch als
Schiebebalken (zum Regeln z.B.) genutzt werden. Bildlaufleisten sind automatisch integriert
in Listen und Textflächen sowie in sog. Scrollfeldern (ScrollPane, s. 2.3).
2.2.1
Textbereiche (TextArea)
Mittels der Klasse TextArea können mehrzeilige Textbereiche erzeugt werden, die größere
Textmengen aufnehmen können als Textfelder. In einem Textbereich stehen horizontale und
vertikale Schiebebalken zur Verfügung, mit denen man den gewünschten Anzeigebereich
sichtbar machen kann. Folgende Konstruktoren dienen zur Erzeugung von Textbereichen:

TextArea() erzeugt einen leeren Textbereich ohne Angabe der Höhe und Breite.

TextArea() erzeugt einen Textbereich mit Angabe der Höhe und Breite. Der erste
Parameter gibt die Anzahl der Zeilen und der zweite die Anzahl der Zeichen pro Zeile
an.

TextArea(String) erzeugt einen Textbereich mit einem festgelegtem Text
(String), aber ohne Angabe der Höhe und Breite.

TextArea(String,
int,
int)
erzeugt
den
gleichen
Textbereich
wie
TextArea(String) nur mit Größenangabe.
Die Klasse TextArea stellt einige Methoden zur Verfügung, mit denen man die
Textbereiche kontrollieren kann:
Christian Schneider
16
AWT - Detailbetrachtung

getText(), setText(String), isEditable() und setEditable(boolean)
analog zu Textfeldern (2.1.7)

insert(String, int) fügt den Text, der durch den ersten Parameter angegeben
wird, an der Indexposition in das Feld ein, die durch den zweiten Parameter
angegeben wird (gemessen in Zeichen).

replace(String, int, int) ersetzt den Text zwischen den Positionen, die durch den
zweiten und dritten Parameter bestimmt werden, durch den als erstes Argument
übergebenen String.
Das folgende Beispiel zeigt die Handhabung eines Textbereichs:
Abbildung 2-10 Textbereich Demo
import java.awt.*;
import java.applet.*;
public class Textbereich extends Applet {
// Textbereich Demo
String inhalt = "Mittels der Klasse TextArea können mehrzeilige "
+"Textbereiche erzeugt werden,\ndie größere Textmengen aufnehmen können "
+"als Textfelder.\nIn einem Textbereich stehen horizontale und vertikale "
+"Schiebebalken zur Verfügung,\nmit denen man den gewünschten "
+"Anzeigebereich sichtbar machen kann.";
// Text für den Inhalt
TextArea textFeld;
// Deklaration von textFeld
public void init() {
textFeld = new TextArea(inhalt, 3, 20); // Instanz von textFeld
add(textFeld);
// textFeld hinzufügen
}
}
2.2.2
Bildlaufleisten und Schiebebalken (Scrollbar)
Mittels der Scrollbar-Komponenten kann man einen Wert in der Form auswählen, dass man
einen Schiebebalken (auch Slider genannt) horizontal oder vertikal verschiebt. Die jeweilige
Position des Schiebebalkens repräsentiert dann den Wert einer Variablen. Beim Generieren
des Schiebebalkens werden in der Regel der minimale und der maximale Wert angegeben,
welche die Auswahl begrenzen.
Es stehen folgende Konstruktoren zur Verfügung:

Scrollbar() erzeugt eine vertikale Scrollbar, bei der sowohl Minimum, als auch
Maximum 0 sind.
Christian Schneider
17
AWT - Detailbetrachtung

Scrollbar(int) erzeugt genau wie Scrollbar()eine Scrollbar, bei der sowohl
Minimum, als auch Maximum 0 sind, wobei der Parameter die Orientierung des
Schiebebalkens angibt. Man kann hier die in der Klasse Scrollbar enthaltenen
Integer-Konstanten
Scrollbar.VERTICAL
und
Scrollbar.HORIZONTAL
verwenden.

Scrollbar(int, int, int, int, int) erzeugt eine Scrollbar mit folgenden
Parametern:
Orientierung
(Scrollbar.VERTICAL
oder
Scrollbar.HORIZONTAL), Anfangswert des Schiebebalkens, Breite und Höhe der
Box, die zur Veränderung der Scrollbar verwendet wird, und der minimale und
maximale Wert, zwischen denen die Scrollbar selektiert.
Abbildung 2-11 Scrollbars
Das folgende Beispiel zeigt die Verwendung der Klasse Scrollbar. Die Ausgabe ist in
Abbildung 2-11 dargestellt.
import java.awt.*;
import java.applet.*;
public class Scroll extends Applet {
Scrollbar sbar0 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 10, 10, 200);
Scrollbar sbar1 = new Scrollbar(Scrollbar.VERTICAL, 100, 10, 10, 200);
public void init() {
add(sbar0);
add(sbar1);
}
}
Christian Schneider
18
AWT - Detailbetrachtung
2.3
Containers: Windows, Panels und Scroll Panes
Das AWT stellt drei Typen von Containern zur Verfügung, die alle als Unterklassen der
Container-Klasse implementiert sind (welche wiederum eine Unterklasse von Component
ist). Die von der Klasse Window abgeleiteten Klassen Dialog, FileDialog und Frame
stellen Fensterfunktionalitäten bereit, die Komponenten aufnehmen können. Frames
erzeugen vollständige Fenster mit allen Eigenschaften, die wir es z.B. von Windows her
kennen. Im Gegensatz dazu erzeugen Dialogs Fenster, die von Frames abhängen und die
modal sein können (d.h. dass z.B. einige Fensterkomponenten nicht vorhanden sind, wie
z.B. „Maximieren“, je nach Initialisierung). Nutzt man einen FileDialog, so erzeugt das
Programm einen Dialog zum öffnen oder speichern von Dateien. (Bekannt aus diversen
Anwendungen, z.B. unter Menüpunkt „öffnen“ oder „speichern unter“ usw.)
Ein Panel gruppiert Komponenten im Bereich eines bereits bestehenden Fensters. Ein
ScrollPane ist einem Panel sehr ähnlich, aber sein Zweck ist etwas anders. In einem
ScrollPane werden (mitunter sehr große) Komponenten dargestellt, wenn nur ein
beschränkter Raum zur Verfügung steht. Ist der Platz zu klein für das dargestellte Objekt, so
kann man mittels Bildlaufleisten im ScrollPane scrollen, um sich den gewünschten Ausschnitt
anzeigen zu lassen.
2.4
Canvas
Eine Canvas-Komponente (dt. Zeichenfläche, s. auch Abbildung 2-1) ist eine rechteckige
Fläche des Bildschirms, in die die Anwendung zeichnen kann oder darin auftretende
Eingabeereignisse des Benutzers abfangen kann. Um eine sinnvolle (d.h. nicht leere)
Ausgabe auf dem Bildschirm zu erreichen, muss der Programmierer eine Unterklasse von
Canvas bilden. Dabei muss er die paint-Methode der Klasse überschreiben, damit eine
beliebige Zeichnung, z.B. ein Dreieck, in die Zeichenfläche gesetzt werden kann.
Das AWT sendet der Zeichenfläche alle Maus-, Tastatur- und Fokusereignisse, die über ihr
auftreten. Die Methoden gotFocus, lostFocus, keyDown, keyUp, mouseEnter,
mouseExit, mouseMove, mouseDrag, mouseDown und mouseUp der übergeordneten
Klasse Component können überschrieben werden, um auf etwaige Ereignisse, die der
Benutzer hervorruft, reagieren zu können.
Christian Schneider
19
AWT - Detailbetrachtung
Nun folgt ein Code-Beispiel (Auszug) für eine Canvas, welche den Code für die Canvas aus
dem Fenster in Abbildung 2-1 darstellt.
class MeineCanvas extends Canvas {
// Eigene Klasse von Canvas ableiten
public void paint(Graphics g) {
// paint(...)-Methode überschreiben
int w = getSize().width;
// Integer-Wert für die Breite
int h = getSize().height;
// Integer-Wert für die Höhe
g.drawRect(0, 0, w - 1, h - 1);// Canvas einen "Rahmen" geben
g.drawString("Canvas", (w g.getFontMetrics().stringWidth("Canvas"))/2,10);
...
g.drawLine(10,10, 100,100);
// Linie zeichnen
g.fillRect(9,9,3,3);
// Rechteck zeichnen
g.drawString("(10,10)", 13, 10);// Beschriftung zeichnen
g.fillRect(49,49,3,3);
// Rechteck zeichnen
g.drawString("(50,50)", 53, 50);// Beschriftung zeichnen
g.fillRect(99,99,3,3);
// Rechteck zeichnen
g.drawString("(100,100)", 103, 100); //usw.
}
...
}
Die Methode public void paint(Graphics g) wird aufgerufen, um den Inhalt der
Zeichenfläche erneut zu zeichnen. Der Punkt <0,0> des Graphikkontexts ist die obere linke
Ecke der Zeichenfläche. Zum Koordinaten-System innerhalb der Canvas bzw. des AWT
allgemein wird noch in Abschnitt 4 (Grafikausgabe) Stellung genommen.
Christian Schneider
20
AWT - Detailbetrachtung
3
Das Event-Modell des AWT
Jede Benutzeraktion (z.B. Mausklick, Mausbewegung oder Tastaturanschlag) veranlasst das
im Hintergrund laufende Windowing-System (z.B. Windows XP) dazu, ein der Aktion
entsprechendes Ereignis (engl. Event) zu erzeugen. Dieses wird an das Programm
weitergeleitet, das gerade den Fokus hatte, d.h. in dessen Fensterbereich das Event
ausgelöst worden ist. Nun kommt das AWT ins Spiel, es verwendet zur Behandlung von
Events ein sog. Delegation Event Modell.
ActionListener
MouseListener
KeyListener
Quelle
Lauscher
mit der der Anwender interagiert
der Ereignis bearbeitet
Abbildung 3-1 Event-Quelle und Event-Lauscher
In dem Event-Modell wird zwischen Event-Quelle (event source) und Event-Lauscher (event
listener) unterschieden. Die Quellen sind die Komponenten der GUI, z.B. ein Knopf oder ein
Fenster. Die Event-Lauscher sind Klassen, die zum Abfangen und Behandeln der Events
erzeugt werden. Will man ein Ereignis über einer bestimmten Komponente abfangen, so
muss man einen passenden Event-Listener definieren und diesen für die betreffende Quelle
mit entsprechenden Methoden registrieren.
Der erste Schritt zur Ereignisbehandlung besteht darin, das Package java.awt.event zu
importieren. In diesem sind einige Klassen und Interfaces zusammengefasst, die für die
Ereignisbehandlung benötigt werden.
Prinzipiell ist das Ziel der Ereignisbehandlung, dass das Programm immer entsprechend
reagiert, wenn der Benutzer z.B. auf einen Schalter drückt. Daher müssen für jede
Komponente Methoden definiert werden, die immer dann aufgerufen werden, wenn das
zugehörige Ereignis über der Komponente eintritt.
Christian Schneider
21
AWT - Detailbetrachtung
3.1
Event-Lauscher definieren
Lauscher sind Klassen, die bestimmte Listener-Interfaces implementieren. In den Interfaces
werden die Methoden deklariert, die dann beim Eintreten des Events ausgeführt werden
sollen. Für jede Art von Ereignissen (Maus-, Tastatur-, Fensterereignisse) gibt es eigene
Listener-Interfaces (s. Tabelle 3-1).
Der
Programmierer
muss
nun
eigene
Klassen
definieren,
die
diese
Interfaces
implementieren. Die beispielhafte Syntax zur Definition einer eigenen Klasse, die das
„einfachste“ Listener-Interface, den ActionListener, implementiert, sieht so aus:
class MeinActionLauscher implements ActionListener {
// Definiton der Methoden des Interface
}
Das Interface ActionListener deklariert eine einzige Methode:
public abstract void actionPerformed(ActionEvent e)
Da die in den Interfaces deklarierten Methoden abstrakt sind, müssen sie noch definiert
werden, damit das Ereignis eine „Wirkung“ hervorruft. Ohne eine passende Implementierung
dieser Methoden ist eine Ereignisbehandlung nicht möglich.
Eine beispielhafte
Implementierung der Methode actionPerformed aus dem kleinen Beispiel sieht wie folgt
aus:
class MeinActionLauscher implements ActionListener {
public void actionPerformed(ActionEvent e) {
// das Ereignis ruft ein einmaliges Piepen hervor
java.awt.Toolkit.getDefaultToolkit().beep();
}
}
Man kann an diesem kleinen Beispiel mehrere interessante Punkte feststellen:

actionPerformed ist die Methode, die später beim entsprechenden Ereignis (z.B.
Button drücken) aufgerufen wird.

Die Signatur der Methode wird vom Interface vorgegeben, implementiert wird sie vom
Programmierer erst in der eigenen Klasse. D.h. die Methode im Interface ist abstrakt
und wird erst definiert, wenn der Programmierer das Interface nutzen will.

Die Methode definiert einen Parameter e, dem zur Laufzeit vom Betriebssystem eine
Instanz der Klasse ActionEvent übergeben wird. In dieser Instanz sind alle
wichtigen Informationen zum auslösenden Event enthalten.
Christian Schneider
22
AWT - Detailbetrachtung
3.2
Lauscher für Quelle registrieren
Wenn nun ein Lauscher und eine Quelle vorhanden sind, müssen diese nur noch adäquat
zusammengeführt werden. Man spricht davon, dass man einen Listener für eine Quelle
registriert.
Die
Komponenten,
also
die
Quellen,
definieren
hierfür
passende
add...Listener()-Methoden, für jedes der verschiedenen Listener-Interfaces eine.
Zum Beispiel wird nun die entsprechende Methode für einen Knopf (button) aufgerufen, um
ihm eine Instanz der oben exemplarisch definierten Lauscher-Klasse zu übergeben:
MeinActionLauscher abc = new MeinActionLauscher(); // Lauscher-Instanz
button.addActionListener(abc); // Lauscher beim Knopf registrieren
Man kann bei einer Komponente jede Art von Lauscher-Objekten registrieren. Die
verschiedenen Lauscher sind in Tabelle 3-1 dargestellt.
3.3
Adapter
Da die in den Interfaces deklarierten Methoden abstrakt sind, müssen sie immer
implementiert werden. In dem kleinen Beispiel mit dem ActionListener musste nur eine
Methode definiert werden, actionPerformed. Es gibt jedoch weitere Interfaces (s. Tabelle
3-1), die mehrere Methoden deklarieren. Z.B. deklariert der WindowListener sieben
Ereignisbehandlungsmethoden. Da der Benutzer aber alle Methoden definieren muss (da sie
abstrakt sind), sind manche Interfaces ziemlich „unhandlich“. Um den Zwang zu umgehen,
alle Methoden der Interfaces einzeln definieren zu müssen, kann der Programmierer auf sog.
Adapter-Klassen zurückgreifen. Diese Adapter-Klassen sehen eine Implementierung aller
Methoden eines Listener-Interfaces ohne Anweisungen vor. Also sind alle Methoden eines
Interfaces in der dazugehörigen Adapter-Klasse bereits definiert, so dass der Programmierer
sie nicht explizit definieren muss. Wenn er eine Adapter-Klasse verwendet, kann er alle
Methoden neu definieren, muss es aber nicht. Wenn nur eine Methode gebraucht wird (z.B.
windowClosing), dann muss nur diese neu definiert werden.
Um dies an einem Beispiel zu verdeutlichen, wird nun das Interface WindowListener
betrachtet. Es deklariert sieben Ereignisbehandlungsmethoden:
windowOpend(), windowClosing(), windowClosed(), windowActivated(),
windowDeactivated(), windowIconfied(), windowDeiconfied()
Wenn man seine Lauscher-Klasse selbst erstellt, welche das Interface WindowListener
implementiert, dann muss man alle sieben Ereignisbehandlungsmethoden definieren, egal,
ob sie gebraucht werden oder nicht. Leitet man aber stattdessen seinen Lauscher von der
Adapter-Klasse WindowAdapter ab, dann ist es lediglich notwendig, die benötigten
Methoden zu überschreiben. Alle anderen Methoden können ignoriert werden.
Christian Schneider
23
AWT - Detailbetrachtung
Ein Beispiel für eine selbst erstellte Lauscher-Klasse, die von der Klasse WindowAdapter
abgeleitet wird:
class MeinWindowLauscher extends WindowAdapter {
public void windowClosing(WindowEvent e) {
// Das Programm beenden
System.exit(0);
}
}
In diesem Beispiel wird nur eine Methode der insgesamt sieben Methoden des
WindowListene-Interfaces benötigt, so dass der Programmierer auf die zugehörige AdapterKlasse zurückgegriffen hat, um sich so eine Definition der anderen sechs Methoden zu
ersparen.
3.4
Eventverarbeitung durch Listener und Adapter
Eine Übersicht über die verschiedenen Event-Arten gibt folgende Tabelle:
Listener-Interface
Funktion
ActionListener
Erfassung allgemeiner
Aktionen
Erfassung von
Größenänderungen
von Komponenten
AdjustmentListener
Adapterklasse
Methoden
keine
actionPerformed
keine
adjustmentValueChanged
ComponentListener
Erfassung von
Komponentenaktionen
ComponentAdapter
ContainerListener
Erfassung von
Containeraktionen
Erfassung von
Fokusänderungen
Erfassung von
Zustandsänderungen
ContainerAdapter
KeyListener
Erfassung von
Tastaturaktionen
KeyAdapter
MouseListener
Erfassung von
Mausaktionen
MouseAdapter
MouseMotionListener
Erfassung von
Mausbewegungen
Erfassung von
Textänderungen
MouseMotionAdapter
FocusListener
ItemListener
TextListener
WindowListener
Erfassung von
Fensteraktionen
FocusAdapter
keine
componentHidden
componentMoved
componendResized
componendShown
componentAdded
componentRemoved
focusGained
focusLost
itemStateChanged
keyPressed
keyReleased
keyTyped
mouseClicked
mouseEntered
mouseExited
mousePressed
mouseReleased
mouseDragged
mouseMoved
keine
textValueChanged
WindowAdapter
windowOpend
windowClosing
windowClosed
windowActivated
windowDeactivated
windowIconfied
windowDeiconfied
Tabelle 3-1 Event-Verarbeitung
Christian Schneider
24
AWT - Detailbetrachtung
3.5
Ein einfaches Beispiel für Eventbehandlung
Hier nun ein einfaches Beispiel für Eventbehandlung. Es zeigt drei Knöpfe, die jeweils
unterschiedlich auf Klicks durch den Benutzer reagieren. Der mittlere Knopf erzeugt ein
Piepen, der linke Knopf deaktiviert den mittleren Knopf und der rechte Knopf aktiviert den
mittleren Knopf. In den Kommentaren sind Hinweise zur Funktionsweise des Applets:
Abbildung 3-2 ButtonDemo
import
import
import
import
java.awt.*;
java.awt.event.ActionListener;
java.awt.event.ActionEvent;
java.applet.Applet;
public class ButtonDemo
Button b1, b2,
static final String
static final String
static final String
// Import der benötigten Klassen
extends Applet // Eigene Klasse ButtonDemo
implements ActionListener {
b3;
DISABLE = "disable";
ENABLE = "enable";
BEEP = "beep";
//
//
//
//
Knöpfe
String
String
String
werden deklariert
Konstanten werden definiert
Konstanten werden definiert
Konstanten werden definiert
public void init() {
// Initialisierung des Applets
b1 = new Button();
// neuer Knopf b1 wird angelegt
b1.setLabel("BEEP Knopf deaktivieren"); // b1 wird beschriftet
b1.setActionCommand(DISABLE);
// bei Event "sendet" der Knopf
// "disable"
b2 = new Button("BEEP");
// neuer Knopf b2 wird angelegt
b2.setActionCommand(BEEP);
// bei einem Event "sendet" der Knopf
// "beep"
b3 = new Button("BEEP Knopf aktivieren");// neuer Knopf b3
b3.setEnabled(false);
// Knopf wird deaktiviert
b3.setActionCommand(ENABLE);
// bei Event "sendet" der Knopf
// "ENABLE"
b1.addActionListener(this);
// Lauscher für b1 registrieren
b2.addActionListener(this);
// Lauscher für b2 registrieren
b3.addActionListener(this);
// Lauscher für b3 registrieren
add(b1);
// b1 zum Applet hinzufügen
add(b2);
// b2 zum Applet hinzufügen
add(b3);
// b3 zum Applet hinzufügen
}
public void actionPerformed(ActionEvent e) {// Definition der Methode
String command = e.getActionCommand(); //Welches Event ist passiert?
if (command.equals(DISABLE)) { // "BEEP Knopf deaktivieren" geklickt
b2.setEnabled(false);
// b2 deaktivieren
b1.setEnabled(false);
// b1 deaktivieren
b3.setEnabled(true);
// b3 aktivieren
} else if (command.equals(ENABLE)) {//"BEEP Knopf aktivieren" geklickt
b2.setEnabled(true);
// b2 aktivieren
b1.setEnabled(true);
// b1 aktivieren
b3.setEnabled(false);
// b3 deaktivieren
} else
// Beep!!!
java.awt.Toolkit.getDefaultToolkit().beep();
}
}
Christian Schneider
25
AWT - Detailbetrachtung
4
Grafikausgabe
Da nicht nur Komponenten (also Knöpfe, Schiebebalken etc.) beim Design von grafischen
Benutzeroberflächen von Bedeutung sind, wird im Folgenden die Grafikausgabe mittels AWT
betrachtet. Das Hauptaugenmerk liegt hierbei bei der Klasse Graphics. Mit dieser stehen
unterschiedlichste Funktionen zur Verfügung, z.B. zum Zeichnen von Figuren oder die
Ausgabe von Text.
4.1
Graphics-Klasse
Im AWT stehen durch die Graphics-Klasse viele Grafikmöglichkeiten zur Verfügung. Mit ihr
können Linien, Formen, Text und Bilder auf dem Bildschirm ausgegeben werden. Die
Graphics-Klasse ist Teil des java.awt-Packages und wird mit der import Anweisung (import
java.awt.* oder import java.awt.Graphics) am Anfang der Quelldatei importiert.
Die Klasse Graphics ist die abstrakte Oberklasse aller Grafikkontexte, die es ermöglicht auf
prinzipiell allen Oberflächen zu zeichnen, d.h auf den Komponenten oder nicht dargestellten
Bildern (engl. off-screen images).
Falls nichts anderes angegeben wird, ändern die mit einem Grafikobjekt durchgeführten
Grafikoperationen nur die Bits, die innerhalb des Ausschnittbereichs (engl. clipping area) des
Grafikkontextes liegen. Alles Zeichnen und Schreiben erfolgt in der aktuellen Farbe, dem
aktuellen Zeichenmodus (engl. paint mode) und in der aktuellen Schrift.
4.2
Methoden allgemein
Grafikmethoden sind Methoden innerhalb der Graphics-Klasse, welche meistens innerhalb
der paint-Methode des Applets, der Komponente oder einer Zeichenfläche (Canvas, s.
2.4) ausgeführt werden. Auf die verschiedensten Zeichnungsfunktionen wird unter 4.5 noch
eingegangen.
Beispiel: Eine Linie zwischen den Koordinaten x1=30, y1=20 und x2=80, y2=100:
public void paint(Graphics g) {
g.drawLine(30,20,80,100);
}
Der paint-Methode wird hier ein Graphics-Objekt übergeben. Es ist nicht nötig, eine Instanz
dieses Objektes zu erzeugen, es steht vielmehr innerhalb von paint automatisch zur
Verfügung. Die folgende Abbildung 4-1 zeigt das Ergebnis dieser Grafikoperation:
Christian Schneider
26
AWT - Detailbetrachtung
X
(0,0)
Bereich, in dem gezeichnet wird.
(30,20)
drawLine(30,20,80,100)
(80,100)
(width-1, height-1)
Y
Abbildung 4-1 Zeichnen einer Linie und Koordinatensystem
4.3
Zeichengebiete
4.3.1
Koordinatensystem
Wie in Abbildung 4-1 angedeutet ist, hat eine jede Komponente ein eigenes
Koordinatensystem, das von (0,0) bis (width-1, height-1) reicht. Jede Einheit entspricht
einer Pixelgröße. Im Normalfall ist, wie in der Abbildung, der Ursprung, d.h. (0,0), in der
oberen linken Ecke zu finden. Die x-Werte wachsen zunehmend nach rechts, die y-Werte
nach unten. Mit der Funktion translate(int x, int y) kann man den Ursprung aber
auch umsetzen.
4.3.2
Clipping
Man kann das Zeichengebiet auch durch das sog. Clipping verkleinern.
clipRect(int x, int y, int width, int height)
Grafikoperationen außerhalb des so festgelegten Bereichs haben keine Auswirkung.
Zum Beispiel erlaubt g.clipRect(70, 50, 260, 100); das Zeichnen nur in einem
Bereich, der 260 Pixel breit und 100 Pixel hoch ist. Die linke obere Ecke dieses Bereiches ist
durch x=70, y=50 festgelegt.
Christian Schneider
27
AWT - Detailbetrachtung
4.4
Farbe
Farben sind in Java eigene Objekte und es gibt eine Vielzahl von Methoden, um sie zu
benutzen oder ändern.
Zum Beispiel setzt die Anweisung setBackground(Color.black) die Hintergrundfarbe einer
Komponente auf Schwarz. Color.black ist dabei eine statische Klassenvariable, die die Farbe
Schwarz definiert. Die meisten Grundfarben sind auf diese Weise direkt verfügbar
(Color.green, Color.blue usw.).
Natürlich kann auch jede beliebige andere Farbe erzeugt werden, z.B. mit
g.setColor(new Color(255,255,0). Dies erzeugt die Farbe Gelb nach dem RGBSystem. Auf dieses wird hier aber nicht explizit eingegangen.
4.5
Grafikfiguren
Grafikfiguren im AWT sind Linien, Rechtecke, Rechtecke mit runden Ecken, 3D-Rundecke,
Ovale, Kreisbögen und Polygone.
Abbildung 4-2 Grafikfiguren mit Methoden
In der Abbildung 4-2 sieht man den Satz von Grund-Zeichenfunktionen, den die die
Graphics-Klasse zur Verfügung stellt. Die einzelne Implementierung der jeweiligen Methoden
und deren Handhabung sollte man in der Java API und der Online-Dokumentation von Sun
nachschlagen, eine ausgiebige Behandlung würde nun zu weit führen. Auch in der
Methoden-Übersicht unter 4.6 erhält man Informationen zu den gängigsten Funktionen.
Christian Schneider
28
AWT - Detailbetrachtung
4.6
Übersicht über die Methoden der Graphics-Klasse
Hier die wichtigsten Methoden der Graphics-Klasse in der Übersicht:
Methode
Beschreibung
clearRect(int, int, int, int)
Füllt einen spezifizierten Bereich mit der
Hintergrundfarbe
drawArc(int, int, int, int, int, int)
Zeichnet einen Bogen ein
drawImage(Image, int, int, ImageObserver)
Zeichnet ein Bild an die angegebene Position
drawLine(int, int, int, int)
Zeichnet eine Linie ein
drawOval(int, int, int, int)
Zeichnet ein Oval ein
drawPolygon(int[], int[], int)
Zeichnet ein Polygon ein
drawPolyline(int[], int[], int)
Zeichnet einen Linienzug ein
drawRect(int, int, int, int)
Zeichnet ein Rechteck ein
drawRoundRect(int, int, int, int, int, int)
Zeichnet ein Rechteck mit abgerundeten Ecken
ein
drawString(String, int, int)
Gibt String an der angegebenen Koordinate aus
fillArc(), fillOval(), fillPolygon()...
Eine Reihe von Methoden zum Zeichnen
ausgefüllter Formen (vgl. draw...())
Liefert ein Shape-Objekt zurück, das den aktuellen
Clip-Bereich repräsentiert
getClip()
getColor()
Liefert die aktuelle Zeichenfarbe zurück
getFont()
Liefert die aktuell verwendete Schriftart zurück
setClip(Shape)
Definiert einen neuen Clipping-Bereich
setColor(Color)
Definiert die beim Zeichnen verwendete Farbe
setFont(Font)
Definiert die zu verwendende Schriftart
translate(int, int)
Verschiebung des Nullpunktes
Tabelle 4-1 Überblick über die Methoden der Graphics-Klasse
Christian Schneider
29
AWT - Detailbetrachtung
Literatur- und Quellenangabe
5
Als Informationsquellen wurden für diese Ausarbeitung verwendet:
6

Open Java,
Fischer/El Saddik, Springer-Verlag

Java – Programmierung interaktiver WWW-Seiten,
Doberenz/Druckenmüller, Hanser-Verlag

JavaTM API – Band 2: Das Window Toolkit und Applets,
Die offizielle Dokumentation von JavaSoft
Gosling/Yellin/Java-Team, Addison-Wesley-Verlag

graphic Java – Mastering the AWT 2nd edition
Geary

http://sun.java.com
Java-Online-Dokumentation von Sun

Jetzt lerne ich Java
Dirk Louis / Peter Müller, Verlag Markt und Technik
Anhang
Im Anhang befindet sich eine CD mit Dateien und Quelltexten zu den meisten Beispielen. Es
wurde darauf verzichtet, diese alle auszudrucken. Außerdem sind auf der CD ausführbare
Beispiel-Applets, die den Sachverhalt deutlich machen sollen. Man kann sie durch öffnen der
jeweiligen HTML-Files betrachten. Wenn dieses Dokument von CD geöffnet wurde, dann
kann man durch anklicken der Links (s.u.) zu den Beispielen gelangen.
Die folgenden Hyperlinks führen zu den Beispielen (auf CD):
ButtonDemo.html
ButtonDemo.java
Demo zu Knöpfen und Ereignisbehandlung
FontDemo.html
FontDemo.java
Demo der verschiedenen Grafikformen
GUIWindow.html
GUIWindow.java
Demo der verschiedenen Komponenten des AWT
Scrollbar.html
Scroll.java
Demo für einen Scrollbalken
Textfeld.html
Textfeld.java
Demo für Textfelder
Textbereich.html
Textbereich.java
Demo für Textbereiche
Textmarke.html
Textmarke.java
Demo für Textmarken (Label)
Christian Schneider
30