Bisher haben Sie nur Java-Programme kennengelernt, die sehr einfache Aufgaben erledigt haben: Text und Farben anzeigen oder eine Animation oder Sounds abspielen. Sie wollen aber möglicherweise komplexere Programme entwickeln, die sich wie echte Anwendungen verhalten, mit Schaltflächen, Menüs, Textfeldern und anderen Elementen einer Benutzeroberfläche. In den beiden nächsten Lektionen werden Sie die Komponenten der Java- und der JavaBeans-Klassenbibliotheken kennenlernen. Diese Komponenten befinden sich in der Komponentenpalette. Sie können sie nutzen, um die unterschiedlichsten Benutzeroberflächen für Ihre Java-Programme zu entwickeln.
Heute lernen Sie die Funktionen des AWT (Abstract Window Toolkit) von Java kennen. Sie haben die Elemente dieses Toolkits die ganze Zeit über schon benutzt, wie Sie vielleicht aus den Klassen erkannten, die Sie importiert haben. Ein Großteil der Klassen, die Sie in den vorigen Lektionen importiert haben, sind Bestandteil des AWT und können genutzt werden, um eine vollständige Benutzeroberfläche anzulegen. Die Benutzeroberfläche von HotJava wurde mit Hilfe von AWT erzeugt.
Der AWT stellt die folgenden Dinge bereit:
Außerdem werden Sie hier erfahren, wie der Visual Designer und der Menü-Designer der IDE verwendet werden, um das Design Ihrer Benutzeroberfläche durch Drag&Drop zu realisieren, Eigenschaften zu setzen und Ausgangswerte für Ihre Benutzeroberfläche festzulegen.
Um das heutige Projekt zu erzeugen, wählen Sie Datei | Neues Projekt, geben in das Datei-Feld C:\JBUILDER\myprojects\UIDesign.jpr ein und klicken dann auf Fertigstellen. Um dem Projekt Listings hinzuzufügen, klicken Sie auf das Icon Dem Projekt hinzufügen, tragen den Dateinamen ein und geben dann den Code ein.
In der IDE des JBuilder können Sie unter Verwendung mehrerer Funktionen die Benutzeroberfläche Ihres Programms entwickeln. Unter anderem handelt es sich dabei um die Komponentenpalette (Hauptfenster), den Navigations-Bereich, den Kontextbaum (Struktur-Bereich), den Designer für die Benutzeroberfläche (Inhalts-Bereich) und den Komponenteninspektor. Alle diese Elemente bilden den Visual Designer, der aufgerufen wird, wenn Sie auf die Design-Registerkarte im AppBrowser klicken. Nachdem Sie den Visual Designer geladen haben, können Sie Komponenten hinzufügen, Eigenschaften setzen und Ereignis-Handler einfügen, die bestimmen, wie Ihr Programm mit dem Anwender kommuniziert.
Wählen Sie beispielsweise Datei | Neu, dann das Anwendungs-Icon und klicken Sie auf OK. Löschen Sie im ersten Dialog den Inhalt des Package-Feldes und geben Sie in das Klasse-Feld UITest ein. Klicken Sie auf die Schaltfläche Weiter. Geben Sie im zweiten Dialog in das Klasse-Feld MyFrame ein. Stellen Sie sicher, daß keines der Kontrollkästchen markiert ist, und klicken Sie auf die Schaltfläche Fertigstellen. Wenn die beiden Dateien erstellt wurden, klicken Sie im Navigations-Bereich des AppBrowsers auf den Knoten MyFrame.java und dann im Inhalts-Bereich auf die Design-Registerkarte.
Jetzt passieren mehrere Dinge. Im Struktur-Bereich erscheint die Meldung Designer öffnen..., die anschließend durch einen Kontextbaum für die Komponenten ersetzt wird. Der Inhalts-Bereich wird zum Designer und zeigt das Fenster für Ihre neue Benutzeroberfläche an. Außerdem wird ein neues Fenster angezeigt - der Komponenteninspektor mit der Eigenschaften-Seite. Abbildung 6.1 zeigt, wie die IDE in dieser Konfiguration aussieht.
Abbildung 6.1: Die IDE im Visual-Designer-Modus
Der Kontextbaum im Struktur-Bereich zeigt Ihnen alle Komponenten, aus denen sich Ihre Benutzeroberfläche zusammensetzt, und die Ebenen zeigen, welche Komponenten in welchen anderen Komponenten enthalten sind, sie demonstrieren die sogenannte Verschachtelung. Sie können ein Element im Kontextbaum anklicken, und es wird zur selektierten Komponente im Designer, und seine Attribute werden im Komponenteninspektor angezeigt. Der Kontextbaum zeigt alle Komponenten an (wie etwa den Frame, dargestellt als this), unterteilt in die Kategorien Benutzeroberfläche, Menü und Datenzugriff. (Einige Kategorien werden nur angezeigt, wenn das erforderlich ist. Beispielsweise erscheint der Knoten Andere, wenn Sie nicht-visuelle Komponenten, wie etwa Dialoge, in Ihre Benutzeroberfläche einfügen.)
Der Inhalts-Bereich, der jetzt als Designer dient, ermöglicht, weitere Komponenten hinzuzufügen, wie etwa Beschriftungen, Textfelder und andere grafische Elemente. Wenn Sie hier ein Element auswählen, wird der Knoten im Kontextbaum selektiert und seine Attribute werden im Inspektor angezeigt. Im Designer sehen Sie mehrere schwarze Kästchen an den Kanten. Dabei handelt es sich um Griffe, mit denen die Komponente manipuliert werden kann. Außerdem zeigen sie, welche Komponente gerade selektiert ist.
Der Komponenteninspektor besteht aus zwei Seiten: Eigenschaften und Ereignisse. Auf der Eigenschaften-Seite werden die Attribute der selektierten Komponente und ihre aktuellen Werte aufgelistet. Hier können Sie die Ausgangswerte für die Attribute setzen. Wenn es für die Attribute eine visuelle Darstellung gibt, wird diese im Designer der Benutzeroberfläche angezeigt. Wenn Sie beispielsweise die Schrift-Eigenschaft für eine Beschriftung ändern, sehen Sie den Effekt unmittelbar angezeigt. Die Ereignisse-Seite listet alle Ereignisse auf, die die Komponente kennt, und Sie erhalten Zugriff auf bereits existierenden Methoden zur Ereignisverarbeitung, die Ihre Komponente nutzen kann. Sie werden in den heutigen Beispielen zwar einige Methoden erzeugen, aber hauptsächlich werden Sie mit der Eigenschaften-Seite arbeiten (Ereignisse und wie Ereignismethoden in Ihren Code eingefügt werden, werden in Lektion 12 genauer beschrieben.) n
Nun wollen wir ein paar Änderungen an diesem Programm vornehmen, damit Sie sehen, wie der Visual Designer genutzt wird, um Komponenten einzufügen und Eigenschaften zu setzen, und wie Sie mit dem Menü-Designer Menüelemente einfügen und ändern. In diesem Programm fügen Sie ein Menü ein, eine Ereignismethode und ein Beschriftungsfeld, das Ihre Meldung anzegt.
Klicken Sie auf die AWT-Seite der Komponentenpalette, klicken Sie auf die Komponente java.awt.Label (mit dem großen A) und dann in die Mitte des Frames im Designer. Auf der Eigenschaften-Seite des Inspektors klicken Sie auf die rechte Spalte der text-Eigenschaft, geben Jemand zuhause? einund drücken die Eingabetaste. Jetzt klicken Sie auf die alignment-Eigenschaft im Inspektor, geben 1 ein und drücken die Eingabetaste. Wenn Sie fertig sind, sollte der Designer aussehen wie in Abbildung 6.2 gezeigt, mit den Griffen, die anzeigen, daß die Beschriftung die aktuell selektierte Komponente ist.
Abbildung 6.2: Der Designer mit einer Beschriftung
Jetzt klicken Sie auf die rechte Spalte der <name>-Eigenschaft, geben lblAnybodyHome ein und drücken die Eingabetaste.
Die <name>-Eigenschaft ist keine Standard-Java-Eigenschaft. JBuilder stellt Ihnen diese
Pseudo-Eigenschaft zur Verfügung, damit Sie den Namen der Komponente ändern können, ohne Ihren
Code durchsuchen und ihn dort jeweils ersetzen müssen. Wenn Sie diese Pseudo-Eigenschaft setzen, sucht
die IDE automatisch alle Vorkommen des alten Bezeichners in dem von JBuilder erzeugten Code, und
ersetzt sie durch den neuen Namen.
Beachten Sie, daß beim Drücken der Eingabetaste der Name der Beschriftung auch im Kontextbaum geändert wird.
Jetzt klicken Sie auf der AWT-Seite der Komponentenpalette auf die Komponente java.awt.MenuBar undd ann irgendwo in der Nähe von lblAnybodyHome im Designer. Die Komponente menuBar1 wird in den Kontextbaum eingefügt. Durch Doppelklick auf den neuen Knoten menuBar1 wird der Menü-Designer aufgerufen und statt des Designers im Inhalts-Bereich angezeigt (Abbildung 6.3).
Abbildung 6.3: Der Menü-Designer im Inhalts-Bereich des AppBrowsers
Wenn Sie in der Zwischenzeit etwas anderes getan haben, oder wenn Sie den Menü-Designer
versehentlich geschlossen haben, doppelklikken Sie einfach auf die Komponente menuBar1 im
Kontextbaum, um ihn wieder zu öffnen.
Bevor Sie Menüeinträge einfügen, geben Sie der Menü-Komponente einen anderen Namen, indem Sie auf die rechte Spalte der <name>-Eigenschaft klicken, myMenuBar eingeben und die Eingabetaste drücken. Um myMenuBar Ihr erstes Menüelement hinzuzufügen, klicken Sie im Menü-Designer auf den Platzhalter, geben Datei als ersten Eintrag ein und drücken die Eingabetaste. Beachten Sie, daß jetzt zwei weitere Platzhalter eingefügt werden, einer unterhalb des ersten Menüeintrags und ein weiterer rechts neben dem Eintrag. Beachten Sie außerdem, daß der Menü-Designer dem neuen Eintrag automatisch den Namen menu1 zugewiesen hat. Bevor Sie weitere Einträge erzeugen, geben Sie dieser Komponente den Namen menuBarFile.
Um das nächste Element einzufügen, klicken Sie auf den Platzhalter unterhalb des Datei-Eintrags, geben Hallo sagen ein und drücken die Eingabetaste. Geben Sie dem Element den Namen menuItemFileSayHello. Klicken Sie auf den Platzhalter unterhalb Hallo sagen, geben Sie Beenden ein, drücken Sie die Eingabetaste und geben Sie ihm den Namen menuItemFileExit.
Jetzt fügen wir ein weiteres Element in die Menüleiste ein, damit das Ganze vollständiger aussieht. Klicken Sie auf den Platzhalter rechts vom Menüeintrag Datei, geben Sie Hilfe ein, drücken Sie die Eingabetaste und geben Sie ihm den Namen menuBarHelp. Wenn Sie Fertig sind, klicken Sie im Menü-Designer auf Datei. Abbildung 6.4 zeigt, wie der AppBrowser jetzt aussieht.
Abbildung 6.4: Der Menü-Designer mit dem neuen Menü
Der Kontextbaum zeigt jetzt Ihre Menüstruktur, während der Menü-Designer die visuelle Darstellung präsentiert. Wenn Sie ein Element selektieren, entweder im Kontextbaum oder im Menü-Designer, werden seine Attribute im Inspektor angezeigt.
Diejenigen von Ihnen, die bereits Windows-Menüs erstellt haben, fragen sich vielleicht, warum hier
keine Abkürzungstasten verwendet werden. Der Grund dafür ist, daß das &-Zeichen, mit dem die
Abkürzungstasten auf Windows-Plattformen gekennzeichnet werden, auf anderen Plattformen nicht erkannt
wird, und dann als & in dem Menütitel erscheint. Weil diese Funktionalität plattformspezifisch ist, sollten Sie
in Java-Programmen keine Abkürzungstasten verwenden.
Jetzt erzeugen Sie einfache Ereignis-Hander für menuItemFileSayHello und menuItemFileExit, so daß sie irgend etwas sinnvolles machen, wenn der Anwender sie aufruft.
Ein Ereignis-Handler ist eine Methode, die auf ein Ereignis reagiert, etwa auf einen Mausklick
oder einen Tastencode. 
Abbildung 6.5: Der Inspektor mit dem Namen der neuen Methode
Doppelklicken Sie, nachdem dieser Methodenname erzeugt wurde. Dadurch kehrt der AppBrowser in den Projektbrowser-Modus zurück, der Information wird geschlossen und der Fokus geht in im Inhalts-Feld auf den Methodennamen. Gleichzeitig erzeugt JBuilder den Methodenrumpf auf der Quelltext-Seite des Inhalts-Bereichs und Sie können den entsprechenden Code eingeben. Fügen Sie die folgende Codezeile in die Methode ein:
lblAnybodyHome.setText("Hier bin ich!");
Der Inhalts-Bereich sollte jetzt aussehen wie in Abbildung 6.6 gezeigt.
Abbildung 6.6: Der Inhalts-Bereich mit dem Code der neuen Methode
Wenn der Anwender im Datei-Menü den Eintrag Hallo sagen wählt, ändert dieser Code den Text der Beschriftung in Hier bin ich!
Weil Menüeintrag-Knoten im Kontextbaum aufgelistet werden, müssen Sie den Menü-Designer nicht öffnen, um einen Ereignis-Handler für einen Menüeintrag zu erstellen. Sie müssen jedoch einen der Designer geöffnet haben, so daß der Inspektor zur Verfügung steht. Klicken Sie also auf die Design-Registerkarte, um in den Visual Designer-Modus zurückzukehren, und klicken Sie im Kontextbaum auf den Knoten menuItemFileExit, um seine Eigenschaften im Inspektor anzuzeigen.
Um einen Ereignis-Handler für den Menüeintrag Beenden zu erzeugen, klicken Sie auf die Ereignis-Seite des Inspektors und dann auf die rechte Spalte, um einen neuen Methodennamen zu erezugen. Dann doppelklicken Sie auf den Methodennamen, um in den Projektbrowser-Modus zurückzukehren. Fügen Sie die folgende Codezeile in die neue Methode menuItemFileExit_actionPerformed ein:
Um zwischen dem Visual Designer und dem Projektbrowser umzuschalten, klicken Sie einfach nur
auf die Registerkarten Design und Quelltext. Wenn Sie sich im Visual Designer befinden, können Sie auch
ganz einfach zwischen Menü-Designer und Oberflächen-Designer wechseln, indem Sie auf die jeweiligen
Knoten für Menü bzw. Benutzeroberflächenelemente doppelklicken.
Um die Benutzeroberfläche ein bißchen interessanter zu machen, fügen wir noch ein AWT-Steuerelement ein. Dieses Mal plazieren wir sie jedoch andres. Wechseln Sie wider in den Visual-Designer-Modus, indem Sie auf die Design-Registerkarte des Inhalts-Bereichs klicken. Klicken Sie auf der AWT-Seite der Komponentenpalette auf java.awt.Button und dann im Kontextbaum auf bevelPanel1, um dem Fenster die Schaltfläche hinzuzufügen. Klicken Sie auf die Eigenschaften-Seite des Inspektors und ändern Sie dann die <name>-Eigenschaft der neuen Schaltfläche auf btnWhereAreYou und ihre label-Eigenschaft auf Wo bist du? Drücken Sie die Eingabetaste, nachdem Sie die Eigenschaften gesetzt haben, damit diese beibehalten werden.
Sie wollen, daß die Schaltfläche Wo bist du? die Beschriftung ebenso ändert wie der Menüeintrag Hallo sagen. Statt jedoch einen neuen Ereignis-Handler zu erzeugen, können Sie den bereits existierenden wiederverwenden. Dazu klicken Sie auf die Ereignisse-Registerkarte und klicken in die Spalte rechts neben actionPerformed. Weil diese Komponente ein actionPerformed-Ereignis hat, ist sie kompatibel mit der die Sie bereits für den Menüeintrag Hallo sagen erzeugt haben. Damit die Schaltfläche den exisiterenden Ereignis-Handler benutzt, geben Sie einfach menuItemFileSayHello_actionPerformed in die Spalte neben actionPerformed ein und drücken die Eingabetaste. (Wenn Sie bereits geklickt und einen Methodennamen erzeugt haben, markieren Sie diesen und überschreiben ihn.) Wenn der Anwender die Schaltfläche Wo bist du? drückt, ändert sich die Beschriftung Jemand zuhause? in Hier bin ich!
Wählen Sie Datei | Projekt speichern und dann Datei | Alles speichern, dann sind Sie fertig. Beachten Sie, daß das Speichern in der Statusleiste des Hauptfensters von JBuilder dokumentiert wird. Jetzt können Sie den Knoten UITest.java im Navigations-Bereich anklicken und auf das Start-Icon in der Symbolleiste klicken, um Ihre neue Anwendung zu testen. Abbildung 6.7 zeigt, wie die Anwendung nach Anklicken der Schnittstelle Wo bist du? aussieht.
Abbildung 6.7: Die Ausführung der Anwendung UITest
Listing 6.1 zeigt, was die IDE für die Datei UITest.java erzeugt.
1: public class UITest {
2: boolean packFrame = false;
3:
4: // Anwendung erzeugen
5: public UITest() {
6: MyFrame frame = new MyFrame();
7: // Frames packen, die nützliche Infos über die bevorzugte Größe besitzen
// z.B. aus ihrem Layout
8: // Frames validieren, die eine voreingestellte Größe besitzen
9: if (packFrame)
10: frame.pack();
11: else
12: frame.validate();
13: frame.setVisible(true);
14: }
15:
16: //Main-Methode
17: static public void main(String[] args) {
18: new UITest();
19: }
20: }
Listing 6.2 zeigt die ganze MyFrame.java-Datei mit Ihren Methoden für die Ereignis-Verarbeitung.
1: import java.awt.*;
2: import java.awt.event.*;
3: import borland.jbcl.control.*;
4: import borland.jbcl.layout.*;
5:
6: public class MyFrame extends DecoratedFrame {
7: BorderLayout borderLayout1 = new BorderLayout();
8: XYLayout xYLayout2 = new XYLayout();
9: BevelPanel bevelPanel1 = new BevelPanel();
10: Label lblAnybodyHome = new Label();
11: MenuBar myMenuBar = new MenuBar();
12: Menu menuBarFile = new Menu();
13: MenuItem menuItemFileSayHello = new MenuItem();
14: MenuItem menuItemFileExit = new MenuItem();
15: Menu menuBarHelp = new Menu();
16: Button btnWhereAreYou = new Button();
17:
18: // Frame konstruieren
19: public MyFrame() {
20: try {
21: jbInit();
22: }
23: catch (Exception e) {
24: e.printStackTrace();
25: }
26: }
27:
28: // Initialisierung der Komponente
29: public void jbInit() throws Exception{
30: this.setLayout(borderLayout1);
31: this.setSize(new Dimension(400, 300));
32: this.setTitle("Frame Title");
33: lblAnybodyHome.setAlignment(1);
34: lblAnybodyHome.setText("Jemand zuhause?");
35: menuBarFile.setLabel("Datei");
36: menuItemFileSayHello.setLabel("Hallo sagen");
37: menuItemFileSayHello.addActionListener(new
[ccc]MyFrame_menuItemFileSayHello_actionAdapter(this));
38: menuItemFileExit.setLabel("Beenden");
39: menuItemFileExit.addActionListener(new
[ccc]MyFrame_menuItemFileExit_actionAdapter(this));
40: menuBarHelp.setLabel("Help");
41: btnWhereAreYou.setLabel("Wo bist du?");
42: btnWhereAreYou.addActionListener(new
[ccc]MyFrame_btnWhereAreYou_actionAdapter(this));
43: bevelPanel1.setLayout(xYLayout2);
44: this.add(bevelPanel1, BorderLayout.CENTER);
45: bevelPanel1.add(lblAnybodyHome, new XYConstraints(197, 133, -1, -1));
46: bevelPanel1.add(btnWhereAreYou, new XYConstraints(0, 0, -1, -1));
47: myMenuBar.add(menuBarFile);
48: myMenuBar.add(menuBarHelp);
49: menuBarFile.add(menuItemFileSayHello);
50: menuBarFile.add(menuItemFileExit);
51: this.setMenuBar(myMenuBar);
52: }
53:
54: void menuItemFileSayHello_actionPerformed(ActionEvent e) {
55: lblAnybodyHome.setText("Hier bin ich!");
56: }
57:
58: void menuItemFileExit_actionPerformed(ActionEvent e) {
59: System.exit(0);
60: }
61: }
62:
63: class MyFrame_menuItemFileSayHello_actionAdapter
[ccc]implements java.awt.event.ActionListener {
64: MyFrame adaptee;
65:
66: MyFrame_menuItemFileSayHello_actionAdapter(MyFrame adaptee) {
67: this.adaptee = adaptee;
68: }
69:
70: public void actionPerformed(ActionEvent e) {
71: adaptee.menuItemFileSayHello_actionPerformed(e);
72: }
73: }
74:
75: class MyFrame_menuItemFileExit_actionAdapter
[ccc]implements java.awt.event.ActionListener{
76: MyFrame adaptee;
77:
78: MyFrame_menuItemFileExit_actionAdapter(MyFrame adaptee) {
79: this.adaptee = adaptee;
80: }
81:
82: public void actionPerformed(ActionEvent e) {
83: adaptee.menuItemFileExit_actionPerformed(e);
84: }
85: }
86:
87: class MyFrame_btnWhereAreYou_actionAdapter
[ccc]implements java.awt.event.ActionListener {
88: MyFrame adaptee;
89:
90: MyFrame_btnWhereAreYou_actionAdapter(MyFrame adaptee) {
91: this.adaptee = adaptee;
92: }
93:
94: public void actionPerformed(ActionEvent e) {
95: adaptee.menuItemFileSayHello_actionPerformed(e);
96: }
97: }
In diesem beiden Listings wurde bis auf zwei Zeilen der gesamte Code durch Ihre Aktionen im
Visual Designer von der IDE erzeugt. Für die Zeilen 55 und 59 von Listing 6.2 haben Sie manuell Code
geschrieben, um die Ereignis-Handler anzuweisen, welche Aktionen ausgeführt werden sollen. Die anderen
115 Zeilen wurden entsprechend Ihrem visuellen Design automatisch für Sie erzeugt.
Der AWT ist der Abstract Window Toolkit von Java, der die im Paket java.awt definierten grafischen Elemente beinhaltet. Es handelt sich dabei um dasselbe Paket, das Sie schon in den letzten Lektionen immer importiert haben, um die Klassen Graphics, Color, Font und FontMetric nutzen zu können. Der AWT von Java sollte den Java-Programmierern eine Möglichkeit an die Hand geben, grafische Benutzeroberflächen zu erzeugen, bevor es JavaBeans (Komponenten) gab. Bevor es visuelle Entwicklungsumgebungen wie etwa den JBuilder gab, mußte man die AWT-Objekte instantiieren, ihre Eigenschaften setzen und Ereignis-Handler erzeugen, und zwar alles manuell im Quellcode.
Im JBuilder werden diese Objekte als Komponenten in der Komponentenpalette dargestellt, so daß sie einfach durch Drag&Drop in den Frame übernommen werden können. Sie müssen nicht wissen, auf welche Ereignisse eine Komponente reagieren kann - der Komponenteninspektor zeigt Ihnen das auf seiner Ereignisse-Seite. Sie müssen sich auch nicht alle Eigenschaften merken, die eine Komponente haben kann - der Komponenteninspektor zeigt sie Ihnen auf seiner Eigenschaften-Seite. Ein Großteil des Codes, den Sie für die Instantiierung von AWT-Objekten und die Zuordnung von Ereignis-Handlern schreiben müßten, wird automatisch für Sie erzeugt und im Quellcode plaziert. Sie sollten sich einen Überblick verschaffen, wie sich der AWT zusammensetzt, weil das die Grundlage für die anderen Komponenten in der Komponentenpalette ist.
Das Prinzip des AWT ist, daß sich ein Java-Fenster aus verschachtelten Komponenten zusammensetzt, beginnend beim äußersten Fenster bis hin zur kleinsten Komponente der Benutzeroberfläche. Komponenten können visuelle Komponenten sein, die eine Darstellung auf dem Bildschirm besitzen (wie etwa Fenster, Schaltflächen oder Felder), aber auch nicht-visuelle Komponenten, die erst beim Aufruf sichtbar werden (wie etwa Menüs oder Dialoge). Einige visuelle Komponenten sind Container, die andere visuelle Komponenten beinhalten.
Die AWT-Komponenten können in zwei Kategorien eingeteilt werden:
Die Klassen im Paket java.awt sind so organisiert, daß sie die abstrakte Struktur von Containern und einzelnen Komponenten der Benutzeroberfläche widerspiegeln. Abbildung 6.8 zeigt einen Teil der Klassenhierarchie der wichtigsten Klassen im AWT.
Abbildung 6.8: Ein Ausschnitt aus der AWT-Klassenhierarchie
Die Wurzel der meisten AWT-Komponenten ist die Klasse Component, die grundlegende Funktionen zur Anzeige und zur Ereignis-Verarbeitung bereitstellt. Die Klasse Container und viele der anderen Benutzeroberfläche-Komponenten erben von Component. Es entstehen Objekte, die anderen AWT-Komponenten enthalten können - insbesondere die Klassen Panel und Window. Beachten Sie, daß die Klasse java.applet.Applet zwar in einem eigenen Paket angelegt ist, aber auch von Panel erbt, so daß Ihre Applets Teil der Komponentenhierarchie im AWT-System sind.
Eine Anwendung mit grafischer Benutzeroberfläche, die Sie unter Verwendung des AWT schreiben, kann beliebig komplex werden, mit Dutzenden verschachtelter Container und Komponenten, die ineinander angelegt werden. Der AWT wurde so entwickelt, daß jede Komponente ihre Rolle im AWT-System spielen kann, ohne daß das Verhalten anderer Teile des Systems dupliziert oder verwaltet werden müßten.
In der IDE findet man die AWT-Komponenten auf der AWT-Seite der Komponentenpalette, wie in Abbildung 6.9 gezeigt.
Abbildung 6.9: Die AWT-Seite der Komponentenpalette
In den beiden nächsten Abschnitten lernen Sie die wichtigsten Kategorien von AWT-Komponenten kennen: Benutzeroberflächen-Komponenten und Container.
Die einfachste Form einer AWT-Komponente ist die grundlegende Benutzeroberfläche-Komponente. Sie können sie erzeugen und einem Applet hinzufügen, ohne irgend etwas über Container zu wissen - Ihr Applet ist ein AWT-Container und selbst in einem weiteren Container enthalten, dem Browser-Fenster. Weil ein Applet ein Container ist, können Sie AWT-Komponenten dort anlegen und beliebig verschachteln.
Die Prozedur zum Hinzufügen der Komponente in Ihr Benutzeroberflächen-Design ist immer dieselbe. Sie klicken einfach auf die gewünschte Komponente in der Komponentenpalette und dann auf den Designer, dort wo die Komponente erscheinen soll. Wenn Sie gleichzeitig die Größe der Komponente ändern wollen, klicken Sie und halten die linke Maustaste gedrückt, ziehen, bis der Umriß die gewünschte Größe hat, und lassen die Maustaste dann los. Wenn die Komponente jetzt noch nicht dort ist, wo Sie sie haben wollten, klicken Sie sie an (irgendwo, aber nicht an den Griffen) und ziehen sie an die gewünschte Position. Um die Größe der Komponente zu ändern, nachdem Sie sie positioniert haben, schieben Sie die Maus über einen der Griffe, bis der Cursor zu einem Pfeil mit zwei Spitzen wird, klicken und ziehen den Griff, bis die Komponente die gewünschte Größe hat.
In diesem Abschnitt lernen Sie Benutzeroberflächen-Komponenten kenne, ihre wichtigsten Eigenschaften, die Methoden, um diese Eigenschaftswerte zu ermitteln oder zu setzen, sowie die unterstützten Ereignisse.
In den folgenden Eigenschaftsbeschreibungen wird die Methode getXxxx() verwendet, um den
Eigenschaftswert zu ermitteln, und die Methode setXxxx(datentyp), um den Eigenschaftswert zu setzen.
Diese Methoden werden im allgemeinen zur Laufzeit eingesetzt, weil zur Entwurfzeit die Eigenschaften ganz
einfach im Inspektor gesetzt werden können. Sie können die Methoden in Ereignis-Handlern jedoch auch
zur Entwurfszeit verwenden, wie etwa die setText()-Methode des Menüeintrags Hallo sagen, früher in
diesem Kapitel.
Die Komponente java.awt.Button löst eine Aktion auf Ihrer Benutzeroberfläche aus, wenn sie angeklickt wird. Ein Rechen-Applet beispielsweise könnte Schaltflächen für jede Zahl und jeden Operator haben, oder ein Dialogfeld könnte OK- und Abbrechen-Schaltflächen haben. Button-Komponenten besitzen die folgenden wichtigen Elemente:
Abbildung 6.10 zeigt mehrere Schaltflächen, wie sie auf Ihrer Benutzeroberfläche erscheinen könnten.
Abbildung 6.10: Button-Komponenten
Die Komponente java.awt.Checkbox kann selektiert oder deselektiert werden, um Optionen bereitzustellen oder eine Auswahl zu kennzeichnen. Ein Kontrollkästchen kann zwei Statuszustände annehmen: an oder aus (oder markiert und unmarkiert, selektiert und deselektiert usw.). Anders als Schaltflächen lösen Kontrollkästchen normalerweise keine direkten oder unmittelbaren Aktionen auf der Benutzeroberfläche aus, sondern werden genutzt, um dem Anwender zu ermöglichen, optionale Funktionen auszuwählen, die für irgendeine zukünftige Aktion auf der Benutzeroberfläche berücksichtigt werden.
Kontrollkästchen können auf zweierlei Weise genutzt werden:
Kontrollkäschten haben die folgenden wichtigen Elemente:
Abbildung 6.11 zeigt zwei sich nicht ausschließende Kontrollkästchen, das eine markiert, das andere nicht markiert.
Abbildung 6.11: Nicht-exklusive Checkbox-Komponenten
In Java entsprechen Checkbox-Komponenten, die zur selben CheckboxGroup gehören,
Optionsfeldern in anderen Programmiersprachen. Sie werden jedoch nicht automatisch als Gruppe
angeordnet. Wenn Sie Kontrollkästchen erzeugen, die zu einer Gruppe gehören und als Optionsfelder
verwendet werden, brauchen Sie zunächst eine Container-Komponente, wie etwa ein Panel, um sie sichtbar
zu gruppieren. Anschließend plazieren Sie die Kontrollkästchen im Container, um dem Anwender zu zeigen,
daß sie zusammengehören.
Die Komponente java.awt.CheckboxGroup ist eine nicht-visuelle Komponente, mit der exklusive Kontrollkästchen zu Optionsfeldgruppen kombiniert werden. CheckBox-Komponenten, deren checkboxGroup-Eigenschaft auf dieselbe CheckboxGroup gesetzt ist, werden zu Elementen einer Gruppe von Optionsfeldern, von denen jeweils nur eines selektiert (state = true) sein kann.
CheckboxGroup-Komponente haben das folgende Element:
Für diese Komponente gibt es keine Ereignisse. Abbildung 6.12 zeigt drei exklusive Kontrollkästchen (Optionsfelder), deren zweites selektiert ist.
Abbildung 6.12: Exklusive Kontrollkästchen in einer CheckboxGroup
Wenn Sie Checkbox-Komponente in einer CheckboxGroup plazieren wollen, gehen Sie am
besten wie folgt vor:
Die Label-Komponente zeigt nicht-selektierbaren und nicht-veränderbaren Text an, der jedoch vom Programm aus zur Laufzeit geändert werden kann. Beschriftungen werden normalerweise in Kombination mit einer anderen Komponente genutzt, um deren Aufgabe zu beschreiben. Sie können auch verwendet werden, um Komponentengruppen zu identifizieren.
Label-Komponenten haben die folgenden Elemente:
Ein Beispiel für Label-Komponenten finden Sie in Abbildung 6.13 im nächsten Abschnitt.
Die Komponente java.awt.TextField ist ein editierbare Feld, das dem Anwender ermöglicht, eine Textzeile einzugeben. Außerdem kann damit eine Textzeile angezeigt werden.
Textfeld-Komponenten enthalten nur das editierbare Feld. In der Regel brauchen Sie eine
Label-Komponente, die beschreibt, was in dem Feld dargestellt wird.
Darüber hinaus können Sie die TextField-Komponente verwenden, um ein Textfeld anzulegen, das die darin eingegeben Zeichen verbirgt - beispielsweise für die Eingabe von Paßwörtern -, indem Sie seine echoChar-Eigenschaft setzen. Read-only-Felder werden erzeugt, indem die editable-Eigenschaft auf false gesetzt wird. TextField-Komponenten haben die folgenden Elemente:
Abbildung 6.13 zeigt zwei Textfeld-Komponenten, denen jeweils eine Label-Komponente beigeordnet ist, wie sie in einem Login-Dialog erscheinen könnten.
Abbildung 6.13: Ein Beispiel für Label- und TextField-Komponenten
Die List-Komponente zeigt eine Liste von Elementen an, aus denen Sie eines oder mehrere auswählen können. Wenn die Liste länger als das Listenfeld ist, wird automatisch eine Bildlaufleiste eingeführt. Sie können die Auswahl auf ein Element beschränken oder eine Mehrfachauswahl erlauben, indem Sie die multipleMode-Eigenschaft setzen.
List-Komponenten haben die folgenden Elemente:
Wenn die Elemente zu lang sind, um horizontal oder vertikal in das Listenfeld zu passen, werden automatisch Bildlaufleisten bereitgestellt. Abbildung 6.14 zeigt eine List-Komponente mit mehreren Elementen.
Abbildung 6.14: List-Komponente mit mehreren Elementen und Bildlaufleisten
Die Komponente java.awt.Choice kombiniert die Eigenschaften eines read-only-Textfelds und einer List-Komponente. Der List-Teil der Choice-Komponente wird angezeigt, wenn der Anwender auf den Dropdown-Pfeil rechts im TextField-Teil der Komponente klickt. Choice-Komponenten kombinieren die Elemente von TextField- und List-Komponenten.
Abbildung 6.15 zeigt eine Choice-Komponente in einer ausgeführten Anwendung, wenn sie zum ersten Mal angezeigt wird. Abbildung 6.16 zeigt dieselbe Komponente, wie sie aussieht, wenn die Liste aufgeklappt ist und das zweite Element selektiert wird.
Abbildung 6.15: Eine Choice-Komponente in einer ausgeführten Anwendung
Abbildung 6.16: Choice-Komponente mit aufgeklappter Liste und markiertem zweiten Element
Die Komponente java.awt.MenuBar ermöglicht Ihnen, ein hierarchisches Menüsystem anzuzeigen, das auch Untermenüs enthalten kann. Jedes neue Fenster auf Ihrer Benutzeroberfläche kann ein eigenes Menüsystem verwenden. Sie können Menüelemente aktivieren und deaktivieren, markierte Menüelemente bereitstellen, Trennlinien zur Gruppierung einfügen oder Kurzwahlen für Menüelemente einführen (z.B. Strg+C zum Kopieren). MenuBar-Komponenten sind zusammengesetzte Komponenten, die sich aus Menu-Komponenten (Menüleistenelemente) und MenuItem-Komponenten (Menübefehlselemente) bilden, mit den folgenden Elementen:
Ein Beispiel für eine MenuBar-Komponente mit Menu- und MenuItem-Komponenten finden Sie in Abbildung 6.4.
Die java.awt.PopupMenu-Komponente ermöglicht Ihnen, ein Kontextmenü auf Ihrer Benutzeroberfläche anzuzeigen. Die Methode show() gibt an, ob das PopupMenu auf einen Aufruf einer Methode zur Ereignisverarbeitung einer anderen Komponente hin angezeigt wird. Um beispielsweise popupMenu1 aufzurufen, wenn ein Anwender die Schatlfäche button1 angeklickt hat, würden Sie die folgende Codezeile in den Ereignis-Handler von actionPerformed für button1 aufnehmen:
popupMenu1.show(Frame1, 10, 30);
Damit wird popupMenu1 an den Koordinaten 10,30 angezeigt, relativ zum Ursprung von Frame1, wenn button1 angeklickt wird. Abbildung 6.17 zeigt ein Beispiel für ein PopupMenu im Menü-Designer.
Abbildung 6.17: PopupMenu-Komponente im Menü-Designer
Seine PopupMenuItem-Komponenten erben ihre Funktionalität von der MenuItem-Komponente von MenuBar.
Mit der Scrollbar-Komponente können Sie Schieberegler bereitstellen, um einen Wertebereich zu manipulieren. Schieberegler werden verwendet, um einen Wert zwischen einem maximalen und einem minimalen Wert auszuwählen. Um den aktuellen Wert von Scrollbar zu ändern, können Sie drei verschiedene Teile der Komponente verwenden (siehe Abbildung 6.18):
Abbildung 6.18: Zwei Scrollbar-Komponenten, horizontal und vertikal
Durch Auswahl eines dieser visuellen Elemente wird ein Wert geändert, ohne daß dazu irgendwelche Aktualisierungen vorgenommen oder Ereignisse verarbeitet werden müßten. Sie müssen nur die minimum- und maximum-Eigenschaften setzen, den Rest übernimmt Java. Scrollbar-Komponenten haben die folgenden Elemente:
Abbildung 6.18 zeigt einen horizontalen und einen vertikalen Schieberegler.
Die TestArea-Komponente ist ähnlich einem Textfeld, außer daß hier mehrere Textzeilen eingegeben werden können. Weil TextArea-Komponenten eine beliebige Höhe und Breite haben können, und weil sie standardmäßig Bildlaufleisten haben, können Sie hier einfacher mit größeren Texten zurechtkommen. TextArea-Komponenten haben die Eigenschaften und Methoden von TextField- und Scrollbar-Komponenten sowie die folgenden zusätzlichen Elemente:
Abbildung 6.19 zeigt ein Textfeld.
Abbildung 6.19: Eine TextArea-Komponente mit Text
Container sind Komponenten, in denen Sie andere Komponenten anlegen können. Die Komponenten Panel und ScrollPane auf der AWT-Seite sind Container, die beliebig tief verschachtelt werden können. Damit können Sie andere Benutzeroberflächen-Komponenten gruppieren und anordnen und Ihrer Oberfläche visuelle Tiefe verleihen. Außerdem ist es praktisch, daß Container, wenn andere Komponenten darin plaziert sind, als Gruppe verschoben werden können, indem einfach nur die Container-Komponente geschoben wird.
Die java.awt.Panel-Komponente zeigt ein Rechteck an, dessen Hintergrundfarbe Sie setzen können, und in dem Sie andere Komponenten ablegen können, auch andere Container-Komponenten. Panel-Komponenten haben das folgende Element:
Abbildung 6.20 zeigt, wie ein Dialog-Frame aussehen könnte, wobei eine Panel-Komponente Optionsfelder enthält.
Abbildung 6.20: Eine Panel-Komponente mit vier Checkbox-Komponenten
Die java.awt.ScrollPane-Komponente zeigt ein Rechteck mit horizontalem und vertikalem Schieberegler an, wenn diese benötigt werden. Hier handelt es sich um einen speziellen Container, der als scrollbarer »Ausblick« auf eine einzelne Kindkomponente bereitgestellt wird. ScrollPane hat die folgenden Elemente:
Abbildung 6.21 zeigt, wie ein Frame mit einer in einer ScrollPane-Komponente verschachtelten TextField aussehen könnte.
Abbildung 6.21: Eine ScrollPane-Komponente mit einer TextField-Komponente
Sie wissen jetzt schon, daß ein Panel Benutzeroberflächen-Komponenten oder andere Panel-Komponenten enthalten kann. Die Frage ist, wie diese Komponenten schließlich angeordnet und auf dem Bildschirm angezeigt werden.
In anderen fensterorientierten Systemen werden Benutzeroberflächen-Komponenten manchmal unter Verwendung fest vorgegebener Pixelkoordinaten angeordnet, so wie Sie in Grafikoperationen Quadrate und Kreise auf den Zeichenbereich eines Applets zeichnen. In Java kann das Fenster in vielen verschiedenen fensterorientierten Systemen und auf vielen unterschiedlichen Bildschirmen mit unterschiedlichen Schriften und unterschiedlichen Schriftgrößen angezeigt werden. Sie brauchen also eine flexiblere Methode, die Komponenten auf dem Bildschirm anzuordnen, so daß das auf allen Plattformen gleich gut aussieht. Dafür bietet Java die sogenannten Layout-Manager, die für die Ausrichtung der Komponenten auf dem Bildschirm sorgen.
Das Erscheinungsbild von Komponenten auf dem Bildschirm wird durch zwei Dinge festgelegt: die Reihenfolge, in der sie dem betreffenden Panel hinzugefügt wurden, und den Layout-Manager, den das Panel verwendet. Der Layout-Manager legt fest, wie der Bildschirm unterteilt wird und wie die Komponenten plaziert werden.
Beachten Sie, daß jede Panel-Komponente auf Ihrer Benutzeroberfläche einen eigenen Layout-Manager verwenden kann, der durch die layout-Eigenschaft bestimmt wird. Durch die Verschachtelung von Panels in Panels können Sie Ihre Benutzeroberfläche so einrichten, daß die Komponenten funktional angeordnet werden, und zwar auf eine Weise, die auf den unterschiedlichsten Plattformen und fensterorientierten Systemen ansprechend aussieht.
Der AWT stellt sieben Layout-Manager zur Verfügung, die in der Dropdown-Liste der layout-Eigenschaft angezeigt werden.
Nachdem das Layout festgelegt ist, können Sie anfangen, dem Panel Komponenten hinzuzufügen. Die Reihenfolge, in der die Komponenten eingefügt werden, ist häufig wichtig, abhängig davon, welchen Layout-Manager Sie verwenden. Im Visual Designer wird als erstes das Layout für jede Panel-Komponente aufgelistet. Die Einstellung der Layout-Eigenschaft für das Panel erzeugt nämlich die entsprechende Layout-Komponente, die wiederum eigene Eigenschaften aufweist.
In den folgenden Abschnitten werden die Layout-Manager in der Reihenfolge nach steigender Komplexität vorgestellt. Sie lernen die Eigenschaften und Methoden der einzelnen Layout-Manager kennen und wie sie die Komponenten in einem Panel anzeigen.
Das FlowLayout ist das grundlegendste Layout. Hier werden die Komponenten zeilenweise hintereinander in das Panel eingefügt. Wenn eine Komponente nicht mehr in die aktuelle Zeile paßt, wird sie in der nächsten Zeile eingefügt. FlowLayout bietet auch eine Ausrichtung für die einzelnen Zeilen. Standardmäßig werden die Zeilen zentriert.
Nachdem Sie die layout-Eigenschaft des Panels auf FlowLayout gesetzt haben,wird dem Kontextbaum unmittelbar unter der Panel-Komponente eine FlowLayout-Komponente hinzugefügt. Durch Auswahl dieser Komponente im Kontextbaum sehen Sie ihre Eigenschaften auf der Eigenschaften-Seite des Inspektors:
Abbildung 6.22 zeigt ein FlowLayout, so wie es häufig eingesetzt wird - ene einfache Zeile mit Schaltflächen, zentriert in einer Zeile.
Abbildung 6.22: FlowLayout für eine Zeile mit Schaltflächen
Das GridLayout bietet eine genauere Kontrolle über die Plazierung der Komponenten in einem Panel. Mit Hilfe von GridLayout unterteilen Sie das Panel in Zeilen und Spalten. Jede Komponente, die Sie einfügen, wird dann in einer solchen Rasterzelle plaziert, beginnend in der obersten Zeile und in jeder Zeile von links nach rechts. Hier ist es relevant, in welcher Reihenfolge die Komponenten eingefügt werden. Mit Hilfe von GridLayout und verschachtelten Rastern können Sie die Benutzeroberflächen-Komponenten genau dort plazieren, wo Sie sie haben wollen.
Wenn Sie die layout-Eigenschaft von Panel auf GridLayout setzen, zeigt die Auswahl der neuen GridLayout-Komponente im Kontextbaum die folgenden Eigenschaften an:
Abbildung 6.23 zeigt die fünf Schaltflächen in einem Panel mit dem Layout GridLayout und einer rows-Eigenschaft von 2.
Abbildung 6.23: GridLayout mit zwei Zeilen
Das BorderLayout ordnet die Komponenten im Panel nach einer geographischen Positoin an: Center, South, West, North und East. Nachdem Sie die layout-Eigenschaft des Panels auf BorderLayout gesetzt haben, wählen Sie die neue BorderLayout-Komponente im Kontextbaum, um seine Eigenschaften zu sehen:
Abbildung 6.24 zeigt ein BorderLayout der fünf Schaltflächen.
Abbildung 6.24: BorderLayout der fünf Schaltflächen
Der CardLayout-Manager ordnet seine Komponenten nicht wirklich sichtbar an. Statt dessen erzeugt er eine Diashow aus den Komponenten, die nacheinander im Panel angezeigt werden. Wenn Sie schon einmal das HyperCard-Programm verwendet haben, wissen Sie, wie das funktioniert.
Wenn Sie ein CardLayout erzeugen, werden in der Regel weitere Containter-Komponenten eingefügt - normalerweise Panel-Komponenten. Anschließend können Sie unterschiedliche Layouts für diese einzelnen »Karten« wählen, so daß jede ein ganz eigenes Aussehen besitzt. Wenn Sie dem Panel die Karten hinzufügen, können Sie ihnen einen Namen geben. Damit können Sie die in der CardLayout-Klasse definierten Methoden nutzen, um sich zwischen den verschiedenen Karten im Layout zu bewegen.
Nachdem Sie die layout-Eigenschaft des Panels auf CardLayout gesetzt haben, wählen Sie die neue CardLayout-Komponente im Kontextbaum, um die Eigenschaften anzuzeigen:
Das XYLayout ermöglicht Ihnen, die Komponenten genau nach ihren x,y-Koordinaten im Panel anzuordnen. Dies ist ein eigener Layout-Manager von JBuilder, mit dem Sie die Komponenten genau dort plazieren können, wo Sie sie brauchen, ohne beim Prototyping einen Layout-Manager verwenden zu müssen. Nachdem Sie festgelegt haben, wie das Panel schließlich aussehen soll, setzen Sie die layout-Eigenschaft des Panels auf eines der Standard-Java-Layouts, so daß es in allen anderen Plattformen ebenfalls angezeigt werden kann.
Abbildung 6.25 zeigt, wie Komponenten im XYLayout angordnet werden könnten.
Abbildung 6.25: Komponenten, angeordnet
Das PaneLayout ordnet die Komponenten an, indem es den Anzeigebereich für bereits existierende, selektierte Komponenten im Panel unterteilt. Wenn Sie beispielsweise einem Panel ein TextField hinzugefügt haben und die Layout-Eigenschaft auf PaneLayout setzen, könnte es wie in Abbildung 6.26 gezeigt aussehen.
Abbildung 6.26: Ein TextFeld in einem auf PaneLayout gesetzten Panel
Die Größe des Textfelds wird automatisch der Gesamtgröße des Anzeigebereichs angepaßt, so daß es wie ein übergroßes Textfeld aussieht. Jetzt fügen Sie ein zweites Textfeld ein und beobachten Sie, was passiert.
Fügen Sie nun noch ein drittes, viertes und fünftes Textfeld hinzu.
Das ScrollPane-Layout teilt einfach den Platz der aktuell selektierten Komponente mit der neu hinzugefügten Komponente.
Das GridBagLayout ist eine Variation des GridLayout, das GridBagConstraints verwendet. Die Anzahl der Constraint-Optionen, die für dieses Layout gesetzt werden können, machen dieses Layout sehr komplex, bieten aber auch die meiste Kontrolle.
Wenn Sie die layout-Eigenschaft des Panels auf GridBagLayout gesetzt haben, setzen Sie die constraints-Eigenschaft für die einzelnen Container im Panel. Wenn dieses Layout gilt, zeigt die constraints-Eigenschaft drei Punkte rechts neben dem Eigenschaftswert an. Wenn Sie diese Schaltfläche anklicken, wird der Constraints-Dialog für diese Kind-Komponente angezeigt (siehe Abbildung 6.27).
Abbildung 6.27: Der Constraints-Dialog für eine Schaltfläche, deren Panel das Layout GridBagLayout verwendet
In diesem Dialog können Sie viele Aspekte festlegen, wie eine Komponente im Panel positioniert wird:
Eine detaillierte Erklärung der Constraints für das GridBagLayout finden Sie in der Online-Hilfe.
Heute haben Sie den Visual Designer kennengelernt und erfahren, wie einfach es ist, mit Drag&Drop eine grafische Benutzeroberfläche anzulegen. Sie haben die Komponenten der AWT-Seite in der Komponentenpalette kennengelernt, ebenso wie ihre wichtigsten Eigenschaften, Methoden und Ereignisse. Die AWT-Komponenten bilden die Grundlage für die anderen Komponenten in der Palette. Morgen lernen Sie die komplexeren JavaBean-Komponenten kennen, die die JBCL (JavaBeans Component Library) von JBuilder bilden.
Der Workshop bietet zwei Möglichkeiten, zu überprüfen, was Sie in diesem Kapitel gelernt haben. Der Quiz-Teil stellt Ihnen Fragen, die Ihnen helfen sollen, Ihr Verständnis für den vorgestellten Stoff zu vertiefen. Die Antworten auf die Fragen finden Sie in Anhang A. Der Übungen-Teil ermöglicht Ihnen, Erfahrungen in der Anwendung der Dinge zu sammeln, die Sie hier kennengelernt haben. Versuchen Sie, diese Dinge durchzuarbeiten, bevor Sie mit der nächsten Lektion weitermachen.
F Sie haben viel über die Component- und Container-Klassen gesagt, aber scheinbar werden nur Panel-Komponenten als Container-Objekt erzeugt. Was soll ich mit den Component- und Container-Klassen?
A Diese Klassen bieten das Verhalten für generische AWT-Komponenten und Container. Sie müssen zwar nicht unbedingt Instanzen dieser Klassen erzeugen, aber Sie können Unterklassen davon anlegen, wenn Sie dem AWT ein Verhalten hinzufügen wollen, das die Standardklassen nicht bieten. Sobald Sie Ihr eigenen JavaBeans-Komponenten erzeugen, werden diese Klassen sehr wichtig für Sie werden.
F Kann ich eine Benutzeroberflächen-Komponente an einer bestimmten x,y-Position auf dem Bildschirm ablegen?
A Das ist mit Hilfe des XYLayout-Managers des JBuilder möglich, empfiehlt sich jedoch nur für das Prototyping Ihrer Benutzeroberfläche. Wenn Sie genau wissen, wie Ihre Benutzeroberfläche aussehen soll, wählen Sie den Standard-Manager, der Ihrem Layout am besten entspricht und realisieren es dort. Auf diese Weise können Sie sicher sein, daß Ihr Programm auf verschiedenen Plattformen gleich aussieht. Das ist bei fest codierten Layouts nicht immer möglich.
F Ich habe das AWT-Paket angesehen und das Unterpaket peer gefunden. Es gibt Verweise auf die peer-Klassen in der API-Dokumentation. Was sind Peers?
A Peers sind für die plattformspezifischen Teile des AWT verantwortlich. Wenn Sie beispielsweise ein AWT-Fenster erzeugen, verwenden Sie eine Instanz der Window-Klasse, die ein generisches Fensterverhalten bereitstellt, und außerdem verwenden Sie eine Instanz einer Klasse, die WindowPeer implementiert, und die das ganz spezielle Fenster für diese Plattform erzeugt - ein Motif-Fenster unter X Window, ein Macintosh-Fenster auf dem Mac oder ein MS-Windows-Fenster unter Windows 95. Diese peer-Klassen sorgen außerdem für die Kommunikation zwischen dem Fenstersystem und dem Java-Fenster. Durch Aufteilung des generischen Komponentenverhaltens (der AWT-Klassen) von der eigentlichen System-Implementierung und dem Erscheinungsbild (die peer-Klassen), können Sie sich darauf konzentrieren, das Verhalten Ihrer Java-Anwendung zu implementieren, und überlassen Java die plattformspezifischen Details.
