FHZ. mycar modell = DöSchwo leistung = 2 PS. Personenwagen modell leistung anzahlpersonen starten() beschleunigen() bremsen() anzahlpersonen = 5

Transkript

1 1 Einleitung Sie haben die Begriffe Klasse und Objekt bereits kennen gelernt. Sie wissen, dass eine Klasse eine Beschreibung für gleichartige Objekte ist. Sie definiert, welche Attribute und Operationen alle Objekte besitzen, die zu dieser Klasse gehören. Zum Beispiel können wir eine Klasse Personenwagen definieren. Die Klasse definiert die gemeinsamen Attribute und Operationen aller Autos. Anhand der Klasse Personenwagen können wir dann beliebig viele Autos, oder eben Personenwagen-Objekte, erzeugen. Im Klassendiagramm könnte das so aussehen: Personenwagen modell leistung anzahlpersonen starten() beschleunigen() bremsen() mycar modell = DöSchwo leistung = 2 PS anzahlpersonen = 5 othercar modell = Mercedes 500 leistung = 200 PS anzahlpersonen = 5 So weit, so gut. Was nun, wenn wir eine Klasse für Lastwagen schreiben sollen? Müssen wir dann nicht Attribute und Operationen, welche in der Klasse Personenwagen schon definiert sind, nochmals definieren? Zum Beispiel haben ja auch Lastwagen einen Motor mit einer Leistung. Dies ist ein Attribut, welches für alle Motorfahrzeuge gilt. Was uns fehlt, ist ein übergeordnetes, allgemeineres Konzept. Seite 1/31

2 2 Klassenhierarchien Die Lösung für unser Problem sieht folgendermassen aus: Wir definieren zuerst eine Klasse Motorfahrzeug. Diese enthält alle gemeinsamen Attribute und Operationen von Motorfahrzeugen. Im Klassendiagramm: Motorfahrzeug modell leistung starten() beschleunigen() bremsen() Mit Hilfe dieser Klasse können wir nun unsere bestehende Klasse Personenwagen sowie die neue Klasse Lastwagen auf einfachere Weise definieren: Wir sagen nur noch, welche zusätzlichen Attribute und Eigenschaften diese Klassen haben. Gleichzeitig legen wir fest, dass die Klassen auch über sämtliche Eigenschaften der Klasse Motorfahrzeug verfügen. Seite 2/31

3 Wieder in UML: Der Pfeil von der Klasse Personenwagen zur Klasse Motorfahrzeug symbolisiert, dass die Klasse Personenwagen neben ihren eigenen Attributen und Operationen auch über all jene der Klasse Motorfahrzeug verfügt. Man sagt, die Klasse Personenwagen erbt die Attribute und Operationen von der Klasse Motorfahrzeug. Man sagt auch, die Klasse Personenwagen ist von der Klasse Motorfahrzeug abgeleitet oder die Klasse Personenwagen erweitert die Klasse Motorfahrzeug. Motorfahrzeug ist die Superklasse und Personenwagen ist die Subklasse. Die drei Klassen bilden eine Klassenhierarchie. Geht man in der Hierarchie nach oben, so kommt man zu immer allgemeineren Klassen. Ein Personenwagen ist z.b. ein spezielles Motorfahrzeug; man spricht deshalb auch von einer is-a-beziehung. Geht man nach unten, findet man immer spezialisiertere Klassen. Seite 3/31

4 Aufgabe 1: a) Erweitern Sie obige Klassenhierarchie um folgende Elemente: - Eine Klasse für Motorräder - Eine Klasse für Cabriolets Zeichnen Sie ein paar Attribute und Operationen ein, welche typisch für die beiden neuen Klassen sind. b) Überlegen Sie sich, wie eine Klasse Fahrrad in die Klassenhierarchie integriert werden könnte. Zeichnen Sie ihren Vorschlag im Klassendiagramm ein. Seite 4/31

5 3 Vererbung versus Aggregation Die Gefahr besteht, mit der Zeit zu sehr grossen und unübersichtlichen Klassenhierarchien zu kommen. Beispielsweise könnte man versucht sein, zwischen Motorfahrzeugen mit Elektroantrieb und solchen mit Verbrennungsmotor zu unterscheiden. Das würde aber zu einer Verdoppelung von Klassen führen, denn es gibt ja für beide Antriebsarten Personenwagen. Hier wäre vielmehr ein Aggregations-Beziehung (vgl. has-a- Beziehung) zwischen der Klasse Motorfahrzeug und einer Klasse Motor angezeigt. Die Klasse Motor könnte dann ihrerseits wieder abgeleitet werden. In UML: Motorfahrzeug Motor leistung Elektromotor Verbrennungsmotor Wichtig zu wissen ist, dass es nicht DAS Klassendiagramm für ein bestimmtes Problem gibt! Die möglichen Lösungen sind meist sehr vielfältig und Modellieren ist ein iterativer, d.h. sich wiederholender Prozess. Seite 5/31

6 4 Umsetzung in Java Wie man in Java eine Klasse definiert, das wissen Sie bereits. Neu für Sie ist, wie man in Java eine Klasse von einer anderen ableitet. Und eigentlich haben Sie auch das schon x-mal gemacht: class MyApplet extends Applet { Mit dem Schlüsselwort extends kann man definieren, von welcher Klasse eine neue Klasse abgeleitet sein soll. In UML: Seite 6/31

7 Das Motorfahrzeug-Beispiel würde demnach folgendermassen in Java umgesetzt: class Motorfahrzeug { public String modell; // Vorsicht mit public! public double leistung; public void starten() { class Personenwagen extends Motorfahrzeug { public int anzahlpersonen; // Vorsicht mit public! Seite 7/31

8 5 Zugriff auf Instanzvariablen und Methoden der Superklasse(n) 5.1 Schlüsselwort public Aus abgeleiteten Klassen kann grundsätzlich auf alle public- Elemente der Superklasse (und wiederum derer Superklasse etc.) zugegriffen werden, wie wenn diese in der eigenen Klasse definiert wären. Im obigen Beispiel kann also eine Methode in der Klasse Personenwagen auf die Instanzvariablen modell und leistung zugreifen, welche in Motorfahrzeug deklariert sind. Ebenso kann sie die Methode starten() direkt aufrufen: class Personenwagen extends Motorfahrzeug { public void demomethode() { leistung = ; starten(); Seite 8/31

9 5.2 Schlüsselwort private Hingegen kann aus einer abgeleiteten Klasse auf keine private- Elemente der Superklasse (weder Instanzvariablen noch Methoden) zugegriffen werden. Guter Programmierstil ist, Instanzvariablen möglichst als private zu deklarieren! Zugriffe auf die Instanzvariablen erfolgen dann ausschliesslich über entsprechende set- und get- Zugriffsmethoden, welche auch allfällige Integritätsbedingungen sicherstellen. Zudem kann so gegebenenfalls die interne Repräsentation einfach und lokal in der Klasse geändert werden. class Motorfahrzeug { private String modell; private double leistung; public void setleistung(double l) { if (l > 0.0) leistung = l; public void starten() { class Personenwagen extends Motorfahrzeug { public void demomethode() { setleistung(2000.0); starten(); Seite 9/31

10 5.3 Schlüsselwort protected Die Zugriffsregel für private-elemente kann zu einschränkend sein. Aus diesem Grund gibt es in Java das Schlüsselwort protected, welches erlaubt, Elemente einer Klasse für die abgeleiteten Klassen zugänglich zu machen, gegen "aussen" aber zu schützen. Fehlt ein Schlüsselwort private, protected oder public, so wird der Zugriff gemäss untenstehender Tabelle geregelt. Wie Sie sehen, wird dann der Zugriff relativ restriktiv gehandhabt. Zugriff von: eigener Klasse Klasse im gleichen Package Unterklasse aus anderem Package Nicht-Unterklasse aus anderem Package private ja nein nein nein - ja ja nein nein protected ja ja ja* nein public ja ja ja* ja* (*) Die Klasse muss dann natürlich importiert sein. Bemerkung: Ein Package fasst Klassen zusammen, die eng miteinander kooperieren oder die zumindest konzeptionell zusammengehören. Die Klassen müssen dazu auch im gleichen Verzeichnis gespeichert sein (siehe später). Seite 10/31

11 Aufgabe 2: Wir möchten eine Klassenhierarchie für Grafiken entwickeln (z.b. für ein Grafikprogramm). Eine Grafik soll aus Kreisen oder Rechtecken bestehen. Beides sind Figuren. Gesucht sind Klassen, welche die wesentlichen Informationen sowie die notwendigen Methoden gemäss folgender Beschreibung enthalten: Das Rechteck ist durch seine Breite und Höhe definiert, der Kreis durch seinen Radius. Kreis und Rechteck ist gemeinsam, dass sie sich an einem bestimmten Ort auf dem Bildschirm befinden. Dieser ist definiert durch die linke, obere Ecke des Rechtecks oder eines gedachten, den Kreis umgebenden Rechtecks. Beide haben eine Methode display(), um sich auf dem Bildschirm zu zeichnen, sowie einen Konstruktor, welcher die nötigen Parameter für eine vollständige Festlegung eines Kreis- bzw. eines Rechteck-Objekts aufweist. Schliesslich soll eine Methode moveto() zum Verschieben von Kreis- und Rechteck-Objekten an einen neuen Ort vorhanden sein. Die Methode hat als Parameter die Koordinaten des neuen Ortes. Zeichnen Sie ein Klassendiagramm und versuchen Sie, die beiden Klassen Rectangle und Circle sowie die übergeordnete Klasse Figure gemäss den obigen Angaben zu programmieren. Überlegen Sie sich, welche Instanzvariablen und Methoden in welche Klassen gehören. Die Regel heisst: Gemeinsame "Dinge" gehören in die Superklasse. Studieren Sie die Unterlagen noch nicht weiter, denn Sie wollen ja selber eine Lösung erarbeiten! Seite 11/31

12 Seite 12/31

13 Klassendiagramm in UML: Figure -xpos:int -ypos:int +Figure(x:int, y:int) +moveto(x:int, y:int):void +setxpos(x:int):void +setypos(y:int):void +getxpos():int +getypos():int Circle -radius:int Rectangle -width:int -height:int +Circle(x:int, y:int, r:int) +setradius(r:int):void +getradius():int +display(g:graphics):void +Rectangle(x:int, y:int, w:int, h:int) +setsize(w:int, h:int):void +getwidth():int +getheight():int +display(g:graphics):void Bemerkung: Obiges Klassendiagramm hält explizit Sichtbarkeit, Datentypen, formale Parameter sowie die Datentypen der Rückgabewerte fest. Die UML schreibt diese Vollständigkeit nicht vor. Entsprechend dem Kontext, in dem das Klassendiagramm verwendet wird, kann man teilweise oder ganz auf diese Präzisierungen verzichten. Seite 13/31

14 Java-Sourcecode: class Figure { private int xpos; private int ypos; public Figure(int x, int y) { xpos = x; ypos = y; public void moveto(int x, int y) { xpos = x; ypos = y; public void setxpos(int x) { xpos = x; public void setypos(int y) { ypos = y; public int getxpos() { return xpos; public int getypos() { return ypos; Seite 14/31

15 import java.awt.graphics; class Circle extends Figure { private int radius; public Circle (int x, int y, int r) { super(x, y); radius = r; public void setradius(int r) { radius = r; public int getradius() { return radius; public void display(graphics g) { g.drawoval(getxpos(), getypos(), 2*radius, 2*radius); Seite 15/31

16 import java.awt.graphics; class Rectangle extends Figure { private int width; private int height; public Rectangle(int x, int y, int w, int h){ super(x, y); width = w; height = h; public void setsize(int w, int h) { width = w; height = h; public int getwidth() { return width; public int getheight() { return height; public void display(graphics g) { g.drawrect(getxpos(), getypos(), width, height); Seite 16/31

17 Bemerkungen: Alle Instanzvariablen sind private deklariert. Zugriffe erfolgen ausschliesslich über set- und get-zugriffsmethoden. Jedes Rechteck-Objekt ist auch ein Figur-Objekt. Ebenso ist jedes Kreis-Objekt ein Figur-Objekt. Erstere sind Spezialisierungen von letzteren. Deshalb muss der Konstruktor Rectangle() in einem ersten Schritt ein Figur-Objekt konstruieren und darf erst in einem zweiten Schritt rechteckspezifische Belange berücksichtigen! Mit super (vgl. super(), super.variable, super.methode()) kann explizit Bezug auf die Oberklasse genommen werden. So ruft super(x, y) den entsprechenden Konstruktor der Oberklasse Figure auf. Besitzt die Oberklasse gar keinen explizit deklarierten Konstruktor, so ist ein super()-aufruf nicht zwingend notwendig. Es wird dann sozusagen ein leerer Default-Konstruktor aufgerufen. Besitzt die Oberklasse einen explizit deklarierten Konstruktor ohne Parameter, so ist ein super()-aufruf ebenfalls nicht zwingend erforderlich; er wird in diesem Fall automatisch aufgerufen. Aufgabe 3: Angenommen die Instanzvariablen xpos und ypos der Klasse Figure seien nur protected deklariert. Schreiben Sie für diesen Fall nochmals den Quellencode für die Klassen Rectangle und Circle. Seite 17/31

18 6 Anwendung der eigenen Grafik-Klassen Die Klassen, welche wir in der obigen Aufgabe entwickelt haben, können wir jetzt zum Beispiel in einem Applet einsetzen: import java.awt.*; import java.applet.applet; public class Figurlet extends Applet { private Rectangle myrectangle; private Circle mycircle; public void init() { myrectangle = new Rectangle(100,100,20,40); mycircle = new Circle(200,100,30); public void paint(graphics g) { myrectangle.display(g); mycircle.display(g); Seite 18/31

19 Schliesslich könnten wir in unserem Applet auch die moveto()- Methoden aufrufen (z.b. als Antwort auf ein Event): myrectangle.moveto(newx, newy); mycircle.moveto(newx, newy); Bemerkung: Beachtenswert ist, dass wir die Methode moveto() bei einem Rechteck- bzw. bei einem Kreis-Objekt aufrufen. Effektiv ist die Methode aber in der Klasse Figure definiert. Rechteck- und Kreis-Objekt sind aber gleichzeitig auch Figur-Objekte! Klassendiagramm in UML: Seite 19/31

20 7 Zuweisung von Objekten zu Referenzvariablen Ein Objekt einer bestimmten Klasse (vgl. Rectangle) darf man jederzeit einer anderen Referenzvariablen derselben Klasse zuweisen (vgl. rect2). Auch dürfen gleichzeitig mehrere Referenzvariablen ein und dasselbe Objekt referenzieren (vgl. rect2 und rect3). Der Spezialwert null für "kein Objekt" kann immer zugewiesen werden. Rectangle rect1 = new Rectangle(10,10,20,30); Rectangle rect2 = rect1; Rectangle rect3 = rect2; rect1 = null; Gemäss Vererbungshierarchie gilt, dass ein Rechteck-Objekt gleichzeitig auch ein Figur-Objekt ist. Deshalb ist es auch möglich, ein Rectangle-Objekt einer Figure-Referenzvariablen zuzuweisen. Rectangle rect = new Rectangle(10,10,20,30); Figure fig = rect; Allerdings sind wir jetzt bezüglich der Möglichkeiten eingeschränkt, welche wir mit fig haben! Wichtig zu wissen ist, dass ein Objekt seine Klassenzugehörigkeit und seine Interna IMMER beibehält, auch wenn es von einer Referenzvariablen einer Oberklasse referenziert wird. (Es findet also keine Umwandlung der internen Darstellung statt, wie das bei der Zuweisung von Werten elementarer Datentypen passieren kann.) Allerdings ändert sich die Betrachtungsweise des Objektes; man betrachtet das Objekt sozusagen durch die "Brille der Oberklasse": Seite 20/31

21 Über fig kann nur auf die public Methoden und Instanzvariablen der Klasse Figure zugegriffen werden, denn fig kann ein Rectangle-, Circle- oder Figure-Objekt referenzieren! Weiter ist ein Zugriff auf Methoden und Instanzvariablen von Oberklassen möglich, falls diese zugänglich sind. rect = fig; // => Compilerfehler!! rect = (Rectangle) fig; // => korrekt Weil fig auch ein Circle-Objekt referenzieren kann, ist die erste Zuweisung nicht erlaubt! Der Compiler wird mit einer Fehlermeldung reagieren, weil man eine "allgemeinere Referenz" einer "spezielleren Referenz" zuweisen will. Die zweite Zuweisung mit dem Cast ist hingegen korrekt. Der Cast ist sozusagen eine Zusicherung/ein Versprechen, dass fig ein Rectangle-Objekt referenziert und die Zuweisung demzufolge möglich ist. Stellt sich zur Laufzeit heraus, dass dem nicht so ist, wird ein Laufzeitfehler bzw. eine Exception die Folge sein! Seite 21/31

22 8 Überschreiben von Methoden und Polymorphismus In unserem Beispiel fällt auf, dass beide Klassen Rectangle und Circle je eine Methode display() haben. Von der Idee her machen beide Methoden dasselbe, sie zeichnen ihr Objekt. Eigentlich könnte man wünschen, dass jede Figur eine display()-methode hat. Wie die Methode eine Figur zeichnet, hängt dann von der konkreten Situation bzw. vom konkreten Objekt ab. Ist die Figur ein Rechteck wird ein Rechteck gezeichnet etc. Genau das kann Java: Wir definieren zusätzlich auch in der Klasse Figure eine Methode display(). Diese Methode wird genau dann aufgerufen, falls fig ein Figur-Objekt referenziert. Referenziert fig aber ein Objekt einer Unterklasse, z.b. ein Kreis-Objekt, so wird automatisch die korrespondierende Methode display() der Unterklasse Circle aktiviert. class Figure { public void display(graphics g) { g.drawstring("i'm a Figure.", xpos, ypos); Seite 22/31

23 class Circle extends Figure { public void display(graphics g) { g.drawoval(getxpos(), getypos(), 2*radius, 2*radius); class Rectangle extends Figure { public void display(graphics g) { g.drawrect(getxpos(), getypos(), width, height); Die Methode display() ist sowohl in der Klasse Figure wie auch in den Klassen Circle und Rectangle definiert. Die Methodenköpfe (Signaturen) müssen dabei absolut gleich sein! Man nennt dies Überschreiben einer Methode. Seite 23/31

24 Damit können wir nun in einer Anwendung folgendes tun: Figure fig1 = new Figure(10, 120); Figure fig2 = new Rectangle(10, 10, 20, 30); Figure fig3 = new Circle(10, 60, 40); public void paint(graphics g) { fig1.display(); fig2.display(); fig3.display(); fig1 bis fig3 sind drei Referenzvariablen für Figur-Objekte. Ihnen werden je ein Figure-, Rectangle- und Circle-Objekt zugewiesen. In der paint()-methode wird bei allen drei Referenzvariablen die display()-methode aufgerufen. Weil die Methode display() in den abgeleiteten Klassen überschrieben ist, geschieht folgendes: Es wird bei allen drei Aufrufen immer diejenige Variante von display() ausgeführt, welche zur Klasse bzw. zum Objekt gehört, das referenziert wird. fig1.display() => Text ausgeben fig2.display() => Rechteck zeichnen fig3.display() => Kreis zeichnen Dies ist ein sehr mächtiges Konzept und wird in der objektorientierten Programmierung oft angewendet. Es erlaubt, unabhängigen Code zu schreiben. Wenn eine neue Figur-Klasse, z.b. für Dreiecke, eingeführt wird, so sind die Änderungen am bestehenden Code minimal. Das Konzept segelt auch unter dem Begriff Polymorphismus oder frei übersetzt "Vielgestaltigkeit". Seite 24/31

25 Klassendiagramm in UML: Applet Figurlet has-a 3 Figure +moveto() +display() is-a is-a is-a Rectangle Circle +display() +display() 9 Abstrakte Klassen Ist die Sachlage so, dass Objekte der Klasse Figure keinen Sinn machen, so kann die Klasse als abstract deklariert werden. Es ist dann nicht mehr möglich, Objekte dieser Klasse zu instanzieren. Damit wird auch die Methode display() in der Klasse Figure nie mehr zur Ausführung gelangen. Trotzdem macht es Sinn, eine abstrakte Methode display() bzw. den entsprechenden Methodenkopf in der Klasse Figure zu deklarieren. Damit wird zum Ausdruck gebracht, dass sämtliche Figur-Objekte eine Methode display() besitzen, die allerdings in den Unterklassen noch implementiert werden müssen. Die abstrakte Klasse Figure garantiert damit ein bestimmtes Verhalten für sämtliche Figur-Objekte. Seite 25/31

26 Randbemerkung: Ein Interface bzw. eine Schnittstellenklasse ermöglicht Ähnliches, aber ohne Gebrauch der klassischen Vererbung (siehe später). Klassendiagramm in UML: Figure -xpos:int -ypos:int +Figure(x:int, y:int) +moveto(x:int, y:int):void +setxpos(x:int):void +setypos(y:int):void +getxpos():int +getypos():int +display(g:graphics):void Circle -radius:int Rectangle -width:int -height:int +Circle(x:int, y:int, r:int) +setradius(r:int):void +getradius():int +display(g:graphics):void +Rectangle(x:int, y:int, w:int, h:int) +setsize(w:int, h:int):void +getwidth():int +getheight():int +display(g:graphics):void Seite 26/31

27 abstract class Figure { public abstract void display(graphics g); class Circle extends Figure { public void display(graphics g) { g.drawoval(getxpos(), getypos(), radius, radius); class Rectangle extends Figure { public void display(graphics g) { g.drawrect(getxpos(), getypos(), width, height); Figure fig1 = new Rectangle(10, 10, 20, 30); Figure fig2 = new Circle(10, 60, 40); public void paint(graphics g) { fig1.display(); fig2.display(); Seite 27/31

28 10 Beispiel AWT Abstract: allgemeiner plattformunabhängiger Ansatz Window: Umgang mit Fenstersystemen Toolkit: sehr grosse Klassenbibliothek 10.1 Bildschirmausgabe in Windowsystemen "Nicht der Programmierer bestimmt, wann etwas auf dem Bildschirm dargestellt wird, sondern der User." Entsprechend bestimmt nicht das Programm, wann etwas auf dem Bildschirm dargestellt werden soll, sondern das Windowsystem. Konsequenzen: Das Programm muss zu jedem Zeitpunkt in der Lage sein, die komplette Bildschirmausgabe zu rekonstruieren. Das Programm muss das Windowsystem über neu anzuzeigende Bildschirminhalte informieren. Das Windowsystem ruft die paint()-methode eines Applets oder Programms auf, sobald das Applet gezeichnet werden soll. Das Applet oder Programm ruft seine repaint()-methode auf, sobald es wünscht, neu gezeichnet zu werden. Seite 28/31

29 10.2 Wichtige Klassen für das elementare Zeichnen Graphics: Stellt die eigentlichen Zeichenoperationen zur Verfügung. Graphics-Objekte dienen als eine Art "Zeichenblatt". Sie werden nicht selbst instanziert, sondern vom Ausgabegerät zur Verfügung gestellt (z.b. Bildschirm, Drucker). Zusätzlich speichert die Klasse den aktuellen Zustand des Gerätes (z.b. Zeichenfarbe, Font, Clipping-Region). Color: Farben Font: Schrifttypen Point: Punkt mit Koordinaten x, y Dimension: Grössenangabe mit width und height Rectangle: Rechteck Polygon: n-eck Image: abstrakte Klasse für Bitmap-Grafiken AWT-Klassenhierarchie (Ausschnitt 1): Object equals():boolean Graphics Color Font Point Dimension Rectangle Polygon Image drawline(): void getfont(): Font black: Color darker():color name:string size:int getname():string x:int y:int getx():double move():void height:int width:int equals():boolean setsize():void height:int width:int move():void resize():void npoints:int xpoint:int[] addpoint():void inside():boolean SCALE_FAST:int getheight():int Seite 29/31

30 10.3 Wichtige Klassen für GUIs Component: Das sind die Grundbausteine für ein GUI. Alles, was man sieht, ist ein Component! Die Klasse Component hat sehr viele Methoden. Im Zweifelsfalle hier eine Methode suchen! Canvas: Die einfachste Zeichenoberfläche (vgl. wie Applet ohne Funktionalität). Besitzt im Wesentlichen ein Graphics-Objekt. Container: Ein Behälter für Components. Die Anordnung der Bildelemente wird durch das Layout des Containers bestimmt. Typische Container sind Panel und Window. Ermöglicht eine hierarchische Gestaltung des GUI. Panel: Ein Objekt zum Zusammenfassen grösserer Sinneseinheiten in einem Fenster. Window: Ein einfaches Fenster-Objekt. Frame: Ein "richtiges" Fenster-Objekt. Hat einen Titelbalken, kann vom Benutzer verkleinert und vergrössert werden, kann ein Menü haben usw. (vgl. Java-Programme). Button: Druckknopf Checkbox: Ankreuzfeld Choice: Auswahlmenü (Pull-Down) List: Auswahlmenü Label: statischer Text Scrollbar: Schieberegler TextField: Texteingabe (einzeilig) TextArea: Texteingabefeld (mit mehreren Zeilen) Seite 30/31

31 AWT-Klassenhierarchie (Ausschnitt 2): Object equals():boolean Component paint():void repaint():void update():void Checkbox Choice Container Button Canvas List Label TextComponent Scrollbar getlabel():string setstate():void additme():void remove():void add():void remove():void paint():void setlayout():void getlabel():string setlabel():void paint():void getrows():int select():void CENTER:int settext():void gettext():string select():void VERTICAL:int getminimum():int getvalue():int Panel ScrollPane Window SCROLLBARS_ NEVER:int addnotify():void setlayout():void show():void toback():void Applet Dialog Frame init():void setmodal():void settitle():void setmenubar():voi d FileDialog LOAD:int READ:int getfile():string getmode():int Ein Container ist bekanntlich ein Behälter (vgl. Aggregat) für Components (sogenanntes Composite-Entwurfsmuster): 0..n Component paint():void repaint():void update():void Container Button Label Scrollbar add():void remove():void paint():void setlayout():void getlabel():string setlabel():void CENTER:int settext():void VERTICAL:int getminimum():int getvalue():int Panel addnotify():void Applet init():void Seite 31/31