vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbacknächstes Kapitel


Woche 1

Tag 11

Einfache Benutzeroberflächen für Applets

Durch die Popularität des Apple Macintosh und von Microsoft Windows erwarten die meisten Computerbenutzer heute, daß deren Software eine grafische Benutzeroberfläche bietet und mit der Maus bedient werden kann.

Diese Annehmlichkeiten der Software sind zwar benutzerfreundlich in vielen Sprachen, aber programmiererunfreundlich. Software für grafische Benutzeroberflächen zu schreiben, kann für einen neuen Entwickler eine größere Herausforderung sein.

Glücklicherweise hat Java diesen Prozeß mit dem Abstract Windowing Toolkit vereinfacht. Das Abstract Windowing Toolkit - AWT - besteht aus einer Reihe von Klassen, mit denen sich grafische Benutzeroberflächen erstellen und benutzen lassen.

Heute werden Sie das AWT zur Erstellung einer Benutzeroberfläche für ein Applet verwenden. Sie werden lediglich die Techniken von Java 1.02 verwenden, da dies die Standardversion der Sprache bei den Applet-Anwendern geblieben ist.

Morgen werden Sie lernen, wie Sie die einzelnen Komponenten auf einer Benutzerschnittstelle anordnen. An Tag 13 vervollständigen Sie eine Benutzerschnittstelle, indem Sie sie auf die Eingaben des Benutzers reagieren lassen.

Nachdem Sie gelernt haben, wie Sie Programme mit dem Abstract Windowing Toolkit erstellen, sind Sie bereit, Techniken von Java 1.2 für die Erstellung von Applikationen an den Tagen 20 und 21 zu verwenden.

Das Abstract Windowing Toolkit

Das Abstract Windowing Toolkit, auch AWT genannt, ist ein Satz von Klassen, der es Ihnen ermöglicht, eine grafische Benutzeroberfläche zu erstellen und Eingaben des Benutzers über die Maus und die Tastatur entgegenzunehmen.

Da Java eine plattformunabhängige Sprache ist, haben die Benutzerschnittstellen, die mit dem AWT entworfen werden, auf allen Systemen die gleiche Funktionalität und abgesehen von den Plattformeigenheiten die gleiche Erscheinung.


Eines werden Sie lernen, wenn Sie Java-Applets mit dem AWT erstellen, nämlich, daß manche Dinge nicht gänzlich konsistent über alle Plattformen hinweg sind. Die verschiedenen Java-Laufzeitumgebungen, die von Netscape, Microsoft und anderen Firmen für deren Browser erstellt wurden, sind sich nicht immer einig, wie eine AWT- Benutzerschnittstelle funktionieren sollte. Es ist sehr wichtig, daß Sie ein Applet mit einer Benutzerschnittstelle auf möglichst vielen Plattformen und in möglichst vielen Browsern testen.

In bezug auf das AWT besteht eine Benutzerschnittstelle aus drei Dingen:

Die Klassen des AWT befinden sich alle in dem Paket java.awt. Um alle diese Klassen in einem Programm verfügbar zu machen, können Sie die folgende Anweisung verwenden:

import java.awt.*;

Diese Anweisung importiert alle Komponenten, Container und Layout-Manager, die Sie für den Entwurf Ihrer Benutzerschnittstelle verwenden können. Sie können natürlich auch einzelne import-Anweisungen für die Klassen, die Sie in Ihrem Programm verwenden, einsetzen.

Die Klassen des AWT sind, wie alle anderen Teile der Java-Klassenbibliothek, in einer Vererbungshierarchie angeordnet. Wenn Sie lernen, wie Sie mit einer bestimmten Klasse umgehen, lernen Sie auch, wie Sie mit anderen Klassen umgehen, die von dieser Superklasse abgeleitet wurden.

Die Basiskomponenten der Benutzeroberfläche

Komponenten werden auf einer Benutzerschnittstelle angeordnet, indem Sie in einen Container eingefügt werden. Ein Container ist seinerseits eine Komponente, so daß er in einen anderen Container eingefügt werden kann. Sie werden diese Funktionalität nutzen, wenn Sie beginnen, mit Layout-Managern zu arbeiten, um eine Benutzerschnittstelle zu arrangieren.

Am einfachsten demonstriert man den Entwurf einer Benutzerschnittstelle mit einem Container, den Sie bereites die ganze Zeit verwenden - die Klasse Applet.

Einfügen von Applet-Komponenten

Eine Komponente wird über die folgenden zwei Schritte in einen Container eingefügt:

Da alle Applets Container sind, können Sie die add()-Methode eines Applets verwenden, um eine Komponente direkt in das Applet-Fenster einzufügen.

Jede Komponente einer AWT-Benutzerschnittstelle ist eine Klasse. Eine Komponente erzeugen Sie aus diesem Grund, indem Sie ein Objekt dieser Klasse erstellen.

Die Klasse Button repräsentiert anklickbare Schaltflächen in einer Benutzerschnittstelle. Sie können eine Schaltfläche erzeugen, indem Sie die Beschriftung der Schaltfläche deren Konstruktor als Parameter übergeben:

Button panic = new Button("Panic!");

Diese Anweisung erstellt ein Button-Objekt, das mit dem Text "Panic!" beschriftet ist.

Nachdem Sie eine Komponente erstellt haben, stellt der Aufruf der add()-Methode eines Containers mit der Komponente als Argument die einfachste Möglichkeit dar, die Komponente in diesen Container einzufügen.

Da ein Applet ein Container ist, kann die folgende Anweisung in einem Applet verwendet werden, um das panic-Objekt in ein Applet-Fenster einzufügen:

add(panic);

Das Hinzufügen einer Komponente sorgt nicht unmittelbar dafür, daß diese angezeigt wird. Statt dessen erscheint sie erst, wenn die paint()-Methode ihres Containers aufgerufen wird. Dies erledigt Java hinter den Kulissen. Sie können allerdings den Aufruf von paint() in einem Applet erzwingen, indem Sie dessen repaint()-Methode aufrufen.

Wenn Sie eine Komponente in einen Container einfügen, geben Sie keine x,y-Koordinaten an, die festlegen, wo die Komponente plaziert werden soll. Die Plazierung der Komponenten übernimmt der Layout-Manager des Containers.


Morgen werden Sie mehr über Layout-Manager lernen. Das Standard-Layout für einen Container plaziert die einzelnen Komponenten in einer Zeile von links nach rechts, bis nicht mehr ausreichend Platz vorhanden ist. In diesem Fall wird in der nächsten Zeile mit der Plazierung der Komponenten fortgefahren. Dies wird als Flow Layout bezeichnet und von der Klasse FlowLayout umgesetzt.

Der beste Ort in einem Applet für die Erstellung von Komponenten ist die Methode init(). Dies soll ein Applet mit einer Schaltfläche in Listing 11.1 demonstrieren. Das Applet Slacker erzeugt ein Button-Objekt und fügt es in das Applet-Fenster ein. Die Schaltfläche wird angezeigt, sobald die paint()-Methode - geerbt von der Klasse Applet - aufgerufen wird.

Listing 11.1: Der komplette Quelltext von Slacker.java

 1: import java.awt.*;
 2:
 3: public class Slacker extends java.applet.Applet {
 4:     String note = "I am extremely tired and would prefer not " +
 5:         "to be clicked. Please interact somewhere else.";
 6:     Button tired = new Button(note);
 7:
 8:     public void init() {
 9:         add(tired);
10:     }
11: }

Testen Sie dieses Applet auf einer Seite mit dem folgenden <APPLET>-Tag:

<APPLET CODE="Slacker.class" WIDTH=550 HEIGHT=75>
</APPLET>

Abbildung 11.1 zeigt das Ergebnis im Applet-Viewer.


Abbildung 11.1:
Das Slacker-Applet

Labels

Die einfachste Komponente der Benutzeroberfläche ist ein Label, das mit der Label- Klasse erzeugt wird. Im wesentlichen ist ein Label ein String, der zur Beschriftung anderer Komponenten der Benutzeroberfläche verwendet wird. Labels sind nicht direkt durch den Benutzer editierbar.

Im Vergleich zu normalem Text (den Sie unter Verwendung von drawString() in der paint()-Methode zeichnen) weist ein Label folgende Vorteile auf:

Um ein Label zu erstellen, verwenden Sie einen der folgenden Konstruktoren:

Sie können die Schrift des Labels mit der Methode setFont() ändern, die Sie an Tag 9 kennengelernt haben. Diese Methode kann entweder für den Container des Labels (z.B. ein Applet), was dann alle Komponenten in diesem Container betrifft, oder nur für das Label selbst aufgerufen werden. Mit folgendem einfachen Code werden ein paar Labels in Helvetica Bold erstellt. Abbildung 12.3 zeigt, wie diese Labels auf dem Bildschirm aussehen.

Die Methode setText(String) eines Labels kann dafür verwendet werden, den Text eines Labels nach dessen Erstellung zu ändern. Der neue Text, der mit String übergeben wird, wird angezeigt, sobald die Komponente neu gezeichnet wird. Sie können auch die getText()-Methode verwenden, um den aktuellen Text des Labels zu ermitteln.

Listing 11.2 zeigt ein einfaches Applet, das ein paar Labels mit Helvetica Bold erstellt.

Listing 11.2: Der komplette Quelltext von Labels.java

 1: import java.awt.*;
 2:
 3: public class Labels extends java.applet.Applet {
 4:     Label lefty = new Label("Bleeding heart!");
 5:     Label center = new Label("Centrist!", Label.CENTER);
 6:     Label righty = new Label("Hardliner!", Label.RIGHT);
 7:     Font lf = new Font("Helvetica", Font.BOLD, 14);
 8:     GridLayout layout = new GridLayout(3,1);
 9:
10:     public void init() {
11:         setFont(lf);
12:         setLayout(layout);
13:         add(lefty);
14:         add(center);
15:         add(righty);
16:     }
17: }

Testen Sie dieses Applet auf einer Seite mit dem folgenden <APPLET>-Tag:

<APPLET CODE="Labels.class" WIDTH=150 HEIGHT=175>
</APPLET>

In Abbildung 11.2 sehen Sie die Ausgabe des Applets im Applet-Viewer. Dies ist ein gutes Tool für diesen Zweck, da Sie die Größe des Fensters verändern können. Dabei können Sie beobachten, wie die drei Labels neu ausgerichtet werden. Das Label »Hardliner!« klebt an der rechten Ecke des Applet-Fensters und das Label »Centrist!« bleibt zentriert.


Abbildung 11.2:
Das Labels-Applet

Die Zeilen 8 und 12 dieses Applets werden verwendet, um ein GridLayout-Objekt zu erstellen und dieses Objekt als Layout Manager für den Container zu verwenden. Dieser Layout-Manager wird später behandelt. Er wird hier allerdings benötigt, da Labels in dem Standard-Layout-Manager für Container - FlowLayout - nicht ausgerichtet werden. Hier werden auch die einzelnen Komponenten in einem Raster mit einer Spalte und drei Zeilen angeordnet.

Schaltflächen

Anklickbare Schaltflächen können mit der Button-Klasse erzeugt werden, wie Sie das bereits bei dem Slacker-Applet gesehen haben. Schaltflächen sind in einer Benutzerschnittstelle sehr nützlich, um Aktionen auszulösen. Die Schaltfläche Beenden könnte z.B. ein Programm beenden.

Um eine Schaltfläche zu erstellen, benutzen Sie einen der folgenden Konstruktoren:

Nachdem Sie ein Schaltflächenobjekt erstellt haben, können Sie den Wert für seine Beschriftung mit der getLabel()-Methode ermitteln und die Beschriftung mit der setLabel(String) -Methode setzen.

Listing 11.3 zeigt das VCR-Applet, das einige vertraute Kommandos auf Schaltflächen präsentiert.

Listing 11.3: Der komplette Quelltext von VCR.java

 1: import java.awt.*;
 2:
 3: public class VCR extends java.applet.Applet {
 4:     Button rewind = new Button("Rewind");
 5:     Button play = new Button("Play");
 6:     Button ff = new Button("Fast Forward");
 7:     Button stop = new Button("Stop");
 8:     Button eat = new Button("Eat Tape");
 9:
10: public void init() {
11:     add(rewind);
12:     add(play);
13:     add(ff);
14:     add(stop);
15:     add(eat);
16:     }
17: }

Testen Sie dieses Applet auf einer Seite mit dem folgenden <APPLET>-Tag:

<APPLET CODE="VCR.class" WIDTH=300 HEIGHT=60>
</APPLET>

Abbildung 11.3 zeigt dieses Applet im Applet-Viewer. Beachten Sie bitte, daß sich die Schaltfläche Eat Tape in einer neuen Zeile befindet, da in der vorangegangenen Zeile kein Platz mehr für sie war. Wenn Sie das Applet-Fenster 500 Pixel anstatt 300 Pixel breit gemacht hätten, würden alle fünf Schaltflächen in einer Zeile angeordnet werden.


Abbildung 11.3:
Das VCR-Applet

Kontrollfelder

Kontrollfelder sind beschriftete oder unbeschriftete Komponenten einer Benutzeroberfläche, die zwei Status haben: ein und aus (oder angekreuzt und nicht angekreuzt, gewählt und nicht gewählt, true und false usw.). Typischerweise werden diese Komponenten dazu verwendet, bestimmte Optionen in einem Programm zu wählen bzw. diese Auswahl aufzuheben, wie das z.B. bei Bildschirmschonern unter Windows mit dem Kontrollkästchen Kennwortschutz der Fall ist (siehe auch Abbildung 11.4).


Abbildung 11.4:
Ein Dialogfeld mit Kontrollkästchen

Kontrollkästchen schließen sich normalerweise nicht gegenseitig aus, d.h. wenn Sie z.B. fünf Kontrollkästchen in einem Container haben, können alle zur selben Zeit markiert oder nicht markiert sein.

Diese Komponente kann auch als Kontrollfeldgruppe organisiert werden. In dieser Form werden Kontrollkästchen auch als Optionsfelder bezeichnet. In einer solchen Gruppe kann immer nur ein Optionsfeld markiert sein.

Beide Arten von Kontrollfeldern werden mit der Klasse Checkbox erzeugt. Mit den folgenden Konstruktoren erzeugen Sie Kontrollfelder, die sich gegenseitig nicht ausschließen:

Nachdem Sie ein Checkbox-Objekt erzeugt haben, können Sie die Methode setState(boolean) verwenden, um den Status zu setzen. Wenn Sie true als Argument übergeben, wird das Kontrollfeld markiert. Übergeben Sie dagegen false, heben Sie die Markierung auf. Die Methode getState() gibt einen booleschen Wert zurück, der den aktuellen Status des Kontrollfeldes angibt.

Fünf Kontrollfelder werden in Listing 11.4 erstellt. Dieses Applet ermöglicht es Ihnen, bis zu fünf Berühmtheiten zu wählen, die tschechischer Abstammung sind. Nur eines der Kontrollfelder ist anfänglich markiert - Model/Schauspielerin Paulina Porizkova.

Listing 11.4: Der komplette Quelltext von CheckACzech.java

 1: import java.awt.*;
 2:
 3: public class CheckACzech extends java.applet.Applet {
 4:     Checkbox c1 = new Checkbox("Milos Forman");
 5:     Checkbox c2 = new Checkbox("Paulina Porizkova");
 6:     Checkbox c3 = new Checkbox("Ivan Reitman");
 7:     Checkbox c4 = new Checkbox("Tom Stoppard");
 8:     Checkbox c5 = new Checkbox("Ivana Trump");
 9:
10:     public void init() {
11:         add(c1);
12:         c2.setState(true);
13:         add(c2);
14:         add(c3);
15:         add(c4);
16:         add(c5);
17:     }
18: }

In Abbildung 11.5 sehen Sie die Ausgabe des Applets, das mit dem folgenden <APPLET> -Tag in einer Webseite getestet werden kann:

<APPLET CODE="CheckACzech.class" WIDTH=150 HEIGHT=200>
</APPLET>


Abbildung 11.5:
Das CheckACzech-Applet

Um mehrere Kontrollfelder in eine Gruppe einzubringen, in der nur eines zur selben Zeit markiert sein kann, wird ein CheckboxGroup-Objekt mit einer Anweisung wie der folgenden erzeugt:

CheckboxGroup radio = new CheckboxGroup();

Das CheckboxGroup-Objekt überwacht alle Optionsfelder in seiner Gruppe. Sie verwenden dieses Objekt als Extra-Argument im Checkbox-Konstruktor.

Checkbox(String, CheckboxGroup, boolean) erzeugt ein Optionsfeld, das mit dem übergebenen String beschriftet ist. Das Optionsfeld wird dem CheckboxGroup-Objekt, das als Argument übergeben wurde, hinzugefügt. Als drittes Argument wird true übergeben, wenn das Optionsfeld markiert sein soll, ansonsten false.


Unter Java 1.2 wurde der Konstruktor Checkbox(String, CheckboxGroup, boolean) als deprecated ausgewiesen, d.h. es ist eine bessere Methode verfügbar. Wenn Sie kein Applet mit Java 1.02 schreiben, dann sollten Sie den Konstruktor Checkbox(String, boolean, CheckboxGroup) verwenden. Die Anwendung ist dieselbe, lediglich das zweite und das dritte Argument sind vertauscht.

Das folgende Beispiel erzeugt eine Gruppe mit zwei dazugehörigen Optionsfeldern:

CheckboxGroup betterDarrin = new CheckboxGroup();
Checkbox r1 = new Checkbox("Dick York", betterDarrin, true);
Checkbox r2 = new Checkbox("Dick Sargent", betterDarrin, false);

Das Objekt betterDarrin wird zur Gruppierung der Optionsfelder r1 und r2 verwendet. Das r1-Objekt, das die Beschriftung "Dick York" trägt, ist ausgewählt. Nur ein Mitglied der Gruppe kann zur selben Zeit ausgewählt sein. Aus diesem Grund ist es nicht möglich, daß das dritte Argument sowohl für r1 als auch für r2 true ist.

Wenn Sie versuchen, true auf mehr als ein Optionsfeld in einer Gruppe anzuwenden, wird nur das letzte markiert. In einer Gruppe muß keines der Optionsfelder markiert sein.

Listing 11.5 demonstriert eine Optionsfeld-Gruppe. Das Applet zeigt eine Gruppe mit Optionsfeldern für fünf Entertainer polnischer Abstammung und wählt einen davon aus - Krzysztof Kieslowski, der Regisseur von Blue, White und Red.

Listing 11.5: Der komplette Quelltext von PickAPole.java

 1: import java.awt.*;
 2:
 3: public class PickAPole extends java.applet.Applet {
 4:     CheckboxGroup p = new CheckboxGroup();
 5:     Checkbox p1 = new Checkbox("Samuel Goldwyn", p, false);
 6:     Checkbox p2 = new Checkbox("Krzysztof Kieslowski", p, true);
 7:     Checkbox p3 = new Checkbox("Klaus Kinski", p, false);
 8:     Checkbox p4 = new Checkbox("Joanna Pacula", p, false);
 9:     Checkbox p5 = new Checkbox("Roman Polanski", p, false);
10:
11:     public void init() {
12:         add(p1);
13:         add(p2);
14:         add(p3);
15:         add(p4);
16:         add(p5);
17:     }
18: }

Mit dem folgenden <APPLET>-Tag in einer Webseite kann das Applet getestet werden. Das Ergebnis sehen Sie in Abbildung 11.6:

<APPLET CODE="PickAPole.class" WIDTH=150 HEIGHT=200>
</APPLET>


Abbildung 11.6:
Das PickAPole-Applet

Mit der Methode setCurrent(Checkbox) können Sie in einer Optionsfeldgruppe das aktuell ausgewählte Optionsfeld festlegen. Außerdem gibt es die Methode getCurrent() , die das aktuell ausgewählte Optionsfeld zurückgibt.

Kombinationslistenfeld

Listenfelder, die mit der Klasse Choice erzeugt werden, sind Komponenten, die es ermöglichen, einen einzelnen Eintrag aus einem Listenfeld auszuwählen. Sie treffen diese Listenfelder oft in Formularen auf Webseiten an. Abbildung 11.7 zeigt ein Beispiel dieser Listenfelder, das von der Personal Bookshelf Website von Macmillan Publishing stammt.


Abbildung 11.7:
Ein Beispiel für Listenfelder


Der erste Schritt bei der Erstellung eines Listenfeldes ist die Erzeugung eines Choice- Objekts, das die Liste aufnimmt, wie das in der folgenden Anweisung gezeigt wird:

Choice gender = new Choice();

Einzelne Elemente werden dem Kombinationslistenfeld über die Methode addItem(String) des Objekts hinzugefügt. Die folgenden Anweisungen fügen zwei Einträge in das Kombinationslistenfeld gender ein:

gender.addItem("Male");
gender.addItem("Female");

Sie können auch, nachdem Sie das Kombinationslistenfeld in einen Container eingefügt haben, weitere Elemente der Liste hinzufügen.


Die Methode addItem(String) wurde in den Java-Versionen nach 1.02 verworfen. Verwenden Sie statt dessen die Methode add(String), wenn Sie Programme für eine der nachfolgenden Versionen entwerfen.

Nachdem Sie das Kombinationslistenfeld erstellt haben, wird es wie jede andere Komponente auch in einen Container eingefügt. Dafür verwenden Sie die add()-Methode des Containers mit dem Kombinationslistenfeld als Argument.

In Listing 11.6 sehen Sie ein Applet, das den Trend fortsetzt, mit Java internationale Entertainer zu erkennen. Das Applet SelectASpaniard erstellt ein Listenfeld mit Berühmtheiten spanischer Abstammung, in dem ein Eintrag ausgewählt werden kann.

Listing 11.6: Der komplette Quelltext von SelectASpaniard.java

 1: import java.awt.*;
 2:
 3: public class SelectASpaniard extends java.applet.Applet {
 4:     Choice span = new Choice();
 5:
 6:     public void init() {
 7:         span.addItem("Pedro Almodóvar");
 8:         span.addItem("Antonio Banderas");
 9:         span.addItem("Charo");
10:         span.addItem("Xavier Cugat");
11:         span.addItem("Julio Iglesias");
12:         add(span);
13:     }
14: }

Dieses Applet können Sie mit dem folgenden HTML-Tag testen. Das Ergebnis sehen Sie in Abbildung 11.8:

<APPLET CODE="SelectASpaniard.class" WIDTH=150 HEIGHT=200>
</APPLET>


Abbildung 11.8:
Das SelectASpaniard-Applet

Die Klasse Choice bietet einige Methoden, mit denen Sie ein Listenfeld kontrollieren können:

Textfelder

Früher in diesem Kapitel haben Sie Labels für Text verwendet, der vom Benutzer nicht verändert werden kann. Mit einem Textfeld erzeugen Sie eine Komponente für editierbaren Text. Textfelder werden mit der Klasse TextField erstellt.

Um ein Textfeld zur erstellen, benutzen Sie einen der folgenden Konstruktoren:

Das width-Attribut eines Textfeldes ist unter einem Layout-Manager relevant, der die Größe der Komponenten nicht verändert, wie das z.B. beim FlowLayout-Layout-Manager der Fall ist. Sie werden mehr Erfahrung hiermit bekommen, wenn Sie morgen mit Layout-Managern arbeiten.

Die folgende Anweisung erzeugt ein leeres Textfeld, das genügend Platz für 30 Zeichen bietet:

TextField name = new TextField(30);

Mit der folgenden Anweisung wird ein Textfeld namens name erzeugt, das den Text "Puddin N. Tane" enthält.

TextField name = new TextField("Puddin N. Tane", 30);

Sie können auch ein Textfeld erstellen, das die Zeichen, die eingetippt werden, mit allgemeinen Zeichen verbirgt. Diese Textfeldart wird häufig verwendet, um ein eingegebenes Paßwort vor neugierigen Augen zu verstecken.

Um das Zeichen festzulegen, mit dem die Zeichen in dem Textfeld verborgen werden sollen, wird in Java 1.02 die Methode setEchoCharacter(char) der Klasse TextField verwendet (in den Folgeversionen von Java sollte die Methode setEchoChar(char) verwendet werden). Wenn ein Literal benutzt wird, um das Zeichen festzulegen, sollte es in einfache Anführungszeichen eingeschlossen werden, wie z.B. '*'. Java interpretiert jedes Literal in doppelten Anführungszeichen als String-Objekt.

Das folgende Beispiel erzeugt ein Textfeld und legt das Pfund-Zeichen (#) als Zeichen fest, das angezeigt wird, wenn Text in das Textfeld eingegeben wird:

TextField passkey = new TextField(16);
passkey.setEchoCharacter('#');

Das Applet in Listing 11.7 erzeugt einige Textfelder. Labels werden zur Kennzeichnung der einzelne Felder verwendet - normalerweise verwenden Sie Labels hierfür, anstatt einen erklärenden Text in das Textfeld einzufügen. Eines der Textfelder verwendet ein Zeichen, um den eingegebenen Text zu verbergen.

Listing 11.7: Der komplette Quelltext von OutOfSite.java

 1: import java.awt.*;
 2:
 3: public class OutOfSite extends java.applet.Applet {
 4:     Label siteLabel = new Label("Site Name: ");
 5:     TextField site = new TextField(25);
 6:     Label addressLabel = new Label("Site Address: ");
 7:     TextField address = new TextField(25);
 8:     Label passwordLabel = new Label("Admin Password: ");
 9:     TextField password = new TextField(25);
10:
11:     public void init() {
12:         add(siteLabel);
13:         add(site);
14:         add(addressLabel);
15:         add(address);
16:         add(passwordLabel);
17:         password.setEchoCharacter('*');
18:         add(password);
19:     }
20: }

Testen Sie dieses Applet auf einer Webseite mit dem folgenden <APPLET>-Tag:

<APPLET CODE="OutOfSite.class" WIDTH=350 HEIGHT=125>
</APPLET>

Da dieses Applet den Standard-Layout-Manager verwendet, entscheidet nur die Breite des Applet-Fensters darüber, ob die sechs Komponenten sich in verschiedenen Zeilen befinden. Je nach Plattform, die Sie verwenden, kann es sein, daß Sie die Breite des Applet-Fensters anpassen müssen, um eine mit Abbildung 11.9 vergleichbare Ausgabe zu erhalten. (Im nächsten Kapitel lernen Sie, wie Sie Layout-Manager verwenden, um dieses Problem zu vermeiden.)


Abbildung 11.9:
Das OutOfSite-Applet

Die Klasse TextField biete einige Methoden, mit denen sich Textfelder steuern lassen:

Mehrzeilige Textfelder

Mehrzeilige Textfelder (engl. Textareas), die mit der Klasse TextArea erzeugt werden, sind editierbare Textfelder, die mehr als nur eine Zeile Text verarbeiten können. Mehrzeilige Textfelder verfügen über horizontale und vertikale Bildlaufleisten, die es dem Benutzer ermöglichen, durch den Text zu scrollen, der sich in der Komponente befindet.

Um ein mehrzeiliges Textfeld zu erstellen, verwenden Sie einen der folgenden Konstruktoren:

Das Applet in Listing 11.8 zeigt ein mehrzeiliges Textfeld an, das beim Start des Programms mit einem String gefüllt wird.

Listing 11.8: Der komplette Quelltext von OutOfSite.java

 1: import java.awt.*;
 2:
 3: public class Virginia extends java.applet.Applet {
 4:     String letter = "Dear Editor:\n" +
 5:         "I am 8 years old.\n" +
 6:         "Some of my little friends say there is no Santa Claus." +
 7:             " Papa\n" +
 8:         "says, ''If you see it in The Sun it's so.'' Please tell" +
 9:             " me the truth,\n" +
10:         "is there a Santa Claus?\n\n" +
11:         "Virginia O'Hanlon\n" +
12:         "115 West 95th Street\n" +
13:         "New York";
14:     TextArea lt;
15:
16:     public void init() {
17:         lt = new TextArea(letter, 10, 50);
18:         add(lt);
19:         }
20: }

Testen Sie das Virginia-Applet auf einer Webseite mit dem folgenden <APPLET>-Tag:

<APPLET CODE="Virginia.class" WIDTH=450 HEIGHT=250>
</APPLET>

Die Darstellung des Applets im Applet-Viewer sehen Sie in Abbildung 11.10.


Abbildung 11.10:
Das Virginia-Applet

Sowohl einzeilige als auch mehrzeilige Textfelder werden von der Klasse TextComponent abgeleitet. Aus diesem Grund können viele der Verhaltensweisen von einzeiligen Textfeldern auch in mehrzeiligen Textfeldern verwendet werden. Die Methoden setText() , getText(), setEditable() und isEditable() stehen für mehrzeilige Textfelder ebenfalls zur Verfügung. Außerdem können Sie die folgenden Methoden verwenden:

Listenfelder

Listenfelder, die mit der Klasse List erstellt werden, ähneln den Kombinationslistenfeldern mit zwei wesentlichen Unterschieden:

Ein Listenfeld erstellen Sie, indem Sie ein Objekt der Klasse List erzeugen und anschließend der Liste einzelne Einträge hinzufügen. Die Klasse List besitzt die folgenden Konstruktoren:

Nachdem Sie ein List-Objekt erzeugt haben, verwenden Sie dessen addItem(String) -Methode, um Einträge in die Liste einzufügen. (Unter Java 1.2 wurde diese Methode durch die Methode add(String) ersetzt.)

Das folgende Beispiel erzeugt ein Listenfeld und fügt zwei Einträge ein:

List lackeys = new List();
lackeys.addItem("Rosencrantz");
lackeys.addItem("Guildenstern");

Nachdem eine Liste erzeugt und Einträge hinzugefügt wurden, sollte die Liste mit der add()-Methode in ihren Container eingefügt werden. In Listing 11.9 wird die Erstellung von einem Listenfeld mit sieben Einträgen gezeigt.

Listing 11.9: Der komplette Quelltext von Hamlet.java

 1: import java.awt.*;
 2:
 3: public class Hamlet extends java.applet.Applet {
 4:     List hm = new List(5, true);
 5:
 6:     public void init() {
 7:         hm.addItem("Hamlet");
 8:         hm.addItem("Claudius");
 9:         hm.addItem("Gertrude");
10:         hm.addItem("Polonius");
11:         hm.addItem("Horatio");
12:         hm.addItem("Laertes");
13:         hm.addItem("Ophelia");
14:         add(hm);
15:     }
16: }

Die Ausgabe des Applets sehen Sie in Abbildung 11.11. In der HTML-Seite wurde das folgende <APPLET>-Tag verwendet.

<APPLET CODE="Hamlet.class" WIDTH=200 HEIGHT=150>
</APPLET>


Abbildung 11.11:
Das Hamlet-Applet - Claudius, Polonius und Horatio sind ausgewählt

Listenfelder besitzen einige Methoden, die genauso funktionieren wie die entsprechenden Methoden bei Kombinationslistenfeldern: getItem(int), countItems(), getSelectedIndex() , getSelectedItem() und select(int). Auch hier wird countItems() in Java-1.2-Programmen durch getItemCount() ersetzt.

Da mehr als nur ein Element in einem Listenfeld ausgewählt werden kann, stehen noch die beiden folgenden Methoden zur Verfügung:

Bildlaufleisten

Bildlaufleisten sind Komponenten, die es ermöglichen, einen Wert auszuwählen, indem Sie ein kleines Kästchen zwischen zwei Pfeilen bewegen. Viele Komponenten haben integrierte Bildlaufleisten, darunter mehrzeilige Textfelder und Listenfelder. Listenfelder werden mit der Klasse Scrollbar erzeugt. Eine Bildlaufleiste kann entweder horizontal oder vertikal sein.

Bei der Erzeugung von Bildlaufleisten werden normalerweise der Minimal- und der Maximalwert des Wertebereiches, aus dem mit dieser Komponente Werte gewählt werden können, festgelegt.

Um eine Bildlaufleiste, zu erstellen, können Sie die folgenden Konstruktoren verwenden:

Sie können auch den dritten Konstruktor verwenden, der fünf Integer-Argumente erwartet: Scrollbar(int, int, int, int, int). Im folgenden werden die einzelnen Argumente der Reihe nach beschrieben:

Listing 11.10 zeigt ein einfaches Applet, das eine Bildlaufleiste anzeigt. Das GridLayout -Objekt wird zusammen mit der setLayout()-Methode des Applets verwendet, um ein Layout zu ermöglichen, in dem eine Bildlaufleiste ihren Container komplett ausfüllt. Über Layout-Manager lernen Sie morgen mehr.

Listing 11.10: Der komplette Quelltext von Slider.java

 1: import java.awt.*;
 2:
 3: public class Slider extends java.applet.Applet {
 4:     GridLayout gl = new GridLayout(1,1);
 5:     Scrollbar bar = new Scrollbar(Scrollbar.HORIZONTAL,
 6:     50,0,1,100);
 7:
 8:     public void init() {
 9:         setLayout(gl);
10:         add(bar);
11:     }
12: }

Unabhängig davon, welche Werte für die Breite und die Höhe des Applet-Fensters verwendet werden, füllt die Bildlaufleiste die gesamte Fläche aus. Abbildung 11.12 wurde mit dem folgenden Tag erzeugt:

<APPLET CODE="Slider.class" WIDTH=500 HEIGHT=20>
</APPLET>


Abbildung 11.12:
Das Slider-Applet

Die Klasse Scrollbar bietet diverse Methoden, mit denen sich die Werte einer Bildlaufleiste verwalten lassen:

Canvas

Ein Canvas (zu deutsch Leinwand) ist eine Komponente, die im wesentlichen zur Anzeige von Bildern und Animationen in einer Benutzeroberfläche dient. Sie können auch auf andere Komponenten zeichnen, wie Sie es bereits mit dem Applet-Fenster im Laufe dieses Buches getan haben. Ein Canvas stellt aber das einfachste Objekt für diese Aufgaben dar.

Um einen Canvas zu verwenden, müssen Sie eine Subklasse der Klasse Canvas erstellen. Diese Subklasse verarbeitet in ihrer paint()-Methode alle notwendigen Ausgaben.

Sobald Sie eine Canvas-Subklasse erzeugt haben, kann diese in einem Programm verwendet werden. Dazu rufen Sie deren Konstruktor auf und fügen das neue Canvas-Objekt in einen Container ein.

Dies wird in dem Applet Crosshair demonstriert (siehe Listing 11.11). Dieses Applet zeichnet ein Zielkreuz in die Mitte des Applet-Fensters. Außerdem verschiebt es den Mittelpunkt des Zielkreuzes bei einer Größenänderung des Fensters entsprechend.

Listing 11.11: Der komplette Quelltext von Crosshair.java

 1: import java.awt.*;
 2:
 3: public class Crosshair extends java.applet.Applet {
 4:     GridLayout gl = new GridLayout(1,1);
 5:     MyCanvas can = new MyCanvas();
 6:
 7:     public void init() {
 8:         setLayout(gl);
 9:         add(can);
10:     }
11:
12: }
13:
14: class MyCanvas extends java.awt.Canvas {
15:     public void paint(Graphics g) {
16:         int x = size().width / 2;
17:         int y = size().height / 2;
18:         g.setColor(Color.black);
19:         g.drawLine(x-10,y,x-2,y);
20:         g.drawLine(x+10,y,x+2,y);
21:         g.drawLine(x,y-10,x,y-2);
22:         g.drawLine(x,y+10,x,y+2);
23:     }
24: }

Das Applet kann mit einem Fenster beliebiger Größe getestet werden. Das folgende <APPLET>-Tag wurde verwendet, um die Ausgabe in Abbildung 11.13 zu erzeugen:

<APPLET CODE="Crosshair.class" WIDTH=100 HEIGHT=100>
</APPLET>


Abbildung 11.13:
Das Crosshair-Applet

In Listing 11.11 befinden sich zwei Klassen. Die erste, Crosshair, stellt das Applet selbst dar. Die zweite, in den Zeilen 14-24, ist die Klasse MyCanvas, die eine Subklasse der Klasse Canvas ist.

In der Klasse Crosshair passiert folgendes:

Die meiste Arbeit wird in diesem Projekt von der Hilfsklasse myCanvas erledigt. Hier passiert folgendes:

Zusammenfassung

Sie wissen nun, wie Sie eine Benutzerschnittstelle im Fenster eines Applets mit der Standardpalette der Sprache - den Komponenten des Abstract Windowing Toolkit - malen.

Dieses Toolkit beinhaltet Klassen für viele der Elemente, wie Schaltflächen, Bildlaufleisten, Listenfelder usw., die Sie in einem Programm erwarten. Diese Komponenten verwenden Sie, indem Sie eine Instanz von deren Klasse erzeugen und diese einem Container wie dem Applet-Fenster mit dessen add()-Methode hinzufügen.

Heute haben Sie einiges darüber gelernt, wie Sie Funktionalität schaffen, indem Sie Komponenten entwickeln und diese einem Programm hinzufügen.

Im Laufe der nächsten zwei Tage lernen Sie zwei weitere Dinge, die nötig sind, damit eine Benutzerschnittstelle verwendbar wird:

Fragen und Antworten

Frage:
Warum sollte ich bei all diesen verworfenen Methoden, die sich im Abstract Windowing Toolkit von Java 1.2 befinden, überhaupt noch Applets in Java 1.02 schreiben?

Antwort:
Im Idealfall sollten Sie nichts über frühere Versionen von Java lernen müssen, wenn Sie sich mit Java 1.2 beschäftigen. Allerdings sind die führenden Browser-Hersteller sehr langsam damit, die Unterstützung von Versionen der Sprache nach 1.02 einzuführen. Und wie es momentan beim Schreiben dieses Buches scheint, wird Microsoft Java 1.1 nie voll unterstützen, geschweige denn Java 1.2. Aus diesem Grund bleibt Java 1.02 der Standard bei der Programmierung von Applets. Sun arbeitet an einer Möglichkeit für Applet-Entwickler, deren eigene Laufzeitumgebung für ein Applet festzulegen. Dadurch würde es möglich werden, Java-1.2-Applets zu schreiben und dabei sicher zu sein, daß die Anwender mit einem Java-fähigen Browser dieses Applet auch ausführen können.

Frage:
Meine Java-Entwicklungsumgebung erlaubt es, die Benutzerschnittstelle eines Programms visuell zu erstellen - ich kann Schaltflächen und andere Komponenten per Drag&Drop einfügen und mit der Maus arrangieren. Muß ich den Umgang mit dem Abstract Windowing Toolkit trotzdem erlernen?

Antwort:
Wenn Sie mit den Ergebnissen, die Sie erhalten, zufrieden sind und in Ihre Fähigkeit vertrauen, diese Benutzerschnittstelle in einem funktionierenden Programm zu verwenden, dann ist das Abstract Windowing Toolkit keine Notwendigkeit. Allerdings ist es eines der Hauptprojekte dieses Buches, eine funktionierende grafische Benutzerschnittstelle mit dem AWT zu erstellen. Sie erhalten dadurch Fähigkeiten, die Ihnen in anderen Bereichen von Java nützen.



vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbacknächstes Kapitel


Ein Imprint des Markt&Technik Buch- und Software-Verlag GmbH.
Elektronische Fassung des Titels: Java 2 in 21 Tagen, ISBN: 3-8272-5578-3