Programmierpraktikum Java SS 2005

Programmierpraktikum Java SS 2005
Mag.Thomas Hilpold Institut für Wirtschaftsinformatik Software Engineering JKU Linz Termin 8/9 (Ereignisse, AWT)

Ereignisorientierte Programmierung
Allgemeines Programmieren mit Ereignissen Ereignisse werden ausgelöst und an Interessenten weitergeleitet. Z.B. ActionEvent Mehrere Interessenten können sich für einen Ereignistyp bei einem Objekt das Ereignisse versendet anmelden z.B. Button Es gibt Objekte, die Ereignisse versenden und Objekte die Ereignisse empfangen. Ein wichtiges Beispiel zur ereignisorientierten Programmierung ist die Programmierung von grafischen Benutzerschnittstellen Üblicherweise bestimmt man als Programmierer nicht mehr den gesamten Kontrollfluß, sondern muß dynamisch auf verschiedene Ereignisse reagieren.

Grundidee (Beispiel) aButton actionPerformed(anActionEvent) aListener aSecondListener anActionEvent actionCommand=„readDate“ aThirdListener Ein Button-Objekt kann Action-Events erzeugen. Die Verteilung an Interessenten erfolgt durch Aufruf jeweils der gleichen Methode bei den Interessenten (Listeners) und Übergabe einer Referenz auf das Ereignisobjekt. Das Ereignisobjekt kann verschiedene Informationen enthalten.

Klassen und Schnittstellen (Beispiel) ActionEvent String actionCommand; getActionCommand():String <<interface>> ActionListener actionPerformed(ActionEvent e) Button addActionListener(ActionListener l) removeActionListener(ActionListener l) SomeClassA SomeClassB SomeClassC In unserem Beispiel unterstützt ein Button die Registrierung von Interessenten für ActionEvents (Methoden add/remove...). Diese müssen das Interface ActionListener implementieren (weitere Vereinbarungen sind nicht nötig, Klasse unerheblich). Der Button ist dafür verantwortlich ActionEvent-Objekte zu erzeugen (Ereignis tritt ein) und diese an alle zuvor (mittels addActionListener(l)) registrierten Listener zu verteilen.

Ablauf (Beispiel) Listeners werden am Button registriert (addXXXListener). Ereignisse können nun eintreten. Der Button wird ein ActionEvent-Objekt erzeugen und ev. zusätzliche Informationen dem Ereignisobjekt übergeben (beides kann typischerweise in einer Methode fireXXXEvent erfolgen). Bei jedem Listener wird actionPerformed(e) aufgerufen und dabei eine Referenz auf das Ereignisobjekt übergeben. Jeder Listener kann nun für sich entscheiden, was er aufgrund des aufgetretenen Ereignisses unternimmt.

Zusammenfassung Ereignisquellen können Ereignisse erzeugen und an angemeldete Ereignisempfänger weiterleiten. Ereignisempfänger registrieren sich bei Ereignisquellen und empfangen in der Folge Ereignisse. Ereignisquellen unterstützen die Registrierung von Emfängern über zwei Methoden: addXXXListener(XXXListener l), removeXXXListener(XXXListener l) Ereignisempfänger implementieren die XXXListener-Schnittstelle. Diese enthält eine oder mehrere Methoden, die typischerweise als einzigen Parameter das Ereignisobjekt enthalten. Ereignisse entstehen in einer Ereignisquelle und können an einen oder mehrere registrierte Empfänger weitergeleitet werden. Objekte können auch gleichzeitig Quelle und Empfänger von Ereignissen sein.

Zusammenfassung (2) Ereignisse stellen ein bedeutendes, sehr allgemeines Konzept in modernen Softwaresystemen dar Ereignisorientierte Programmierung findet man in vielen APIs und läßt sich vielseitig verwenden grafische Benutzerschnittstellen (MouseEvent, WindowEvent) allg. Zustandsänderungen (SpaceEvent, ValueChangeEvent) Komponentenmodelle (Eigenschaften und Ereignisse) Es entstehen Systeme mit einer Vielzahl von Ereignisquellen, Ereignistypen und Ereignisempfängern. Der Kontrollfluß in solchen Systemen ergibt sich aus dem Entstehen von Ereignissen und deren Behandlung.

Grafische Benutzerschnittstellen
Allgemeines eine Vielzahl heutiger Anwendungen verwendet grafische Benutzerschnittstellen zur Kommunikation mit dem Benutzer (im Gegensatz zu text-orientierten Benutzerschnittstellen) grafische Benutzerschnittstellen bestehen aus einer Menge an grafischen Benutzerschnittstellenkomponenten, die hierarchisch angeordnet sind. In Java sind grafische Benutzerschnittstellenkomponenten meist Ereignisquellen Die Ausführung von Programmen mit grafischer Benutzerschnittstelle ist meist durch das Entstehen und die Behandlung von Ereignissen maßgeblich gekennzeichnet Wesentliche Teile der Java-Klassenbibliothek dienen seit deren Bestehen der Erstellung grafischer Benutzerschnittstellen engl. graphical user interface (GUI)

Grafische Benutzerschnittstellen
engl. graphical user interface (GUI) Unterstützung in der Klassenbibliothek Java kennt zwei wesentliche Bibliotheken zur Erstellung von grafischen Benutzerschnittstellen: AWT (Abstract window toolkit) (seit Version 1.0, Änderung 1.1) SWING (seit Version 1.2 Teil der Klassenbibliothek) Beide unterscheiden sich signifikant. AWT enthält Abhängigkeiten zur Plattform und somit Beschränkungen in Funktionalität und Flexibilität AWT-Anwendungen haben auf unterschiedlichen Plattformen genau deren Look-and-Feel AWT eignet sich gut zur Erstellung von einfachen Anwendungen und sog. Applets, also Anwendungen, die in Web-Browsern ausführbar sind.

Abstract Window Toolkit
Übersicht Bibliothek von Benutzerschnittstellenkomponenten Button, List (!), Label, Menubar, ScrollPane, Canvas, Choice, ... Spezielle Benutzerschnittstellenkomponenten, die Behälter für andere sind (Container) Layout-Manager-Klassen zum automatischen Anordnen von Komponenten Ereignisklassen MouseEvent, ActionEvent, ItemEvent, ... Klassen zum Zeichnen von freier Grafik

Abstract Window Toolkit
Grundlegende Architektur von GUIs Frame MenuBar Panel (with Layoutmanager) Panel (with Layoutmanager) hierarchische Anordnung es gibt Components und Container Components liegen in Containers Ein Container kann einen Layoutmanager zugeordnet haben, der die Anordnung (x,y,w,h) der Components bestimmt Bei Components und Containers kann man sich für verschiedene Ereignisse als Listener anmelden (zB. MouseListener, ActionListener,... ) List Button

Benutzerschnittstellenkomponenten
Wesentliche Basisklassen In der Oberklasse Component sind gemeinsame Eigenschaften für alle GUI-Komponenten festgelegt. grafische Repräsentation Position (x,y), Breite und Höhe Kann verschiedene Events erzeugen (Mouse, Key,...) Die Klasse Container ist direkt von Component abgeleitet kann weitere Components enthalten ein LayoutManager kann gesetzt werden zusätzliches Event (ContainerEvent) Alle verfügbaren Komponenten befinden sich in java.awt

Hierarchie Oberklasse aller GUI-Komponenten

Übersicht (ohne Container) 4.Choice 7.TextField 1.Label 2.Button 3.Checkbox 8.TextArea 6.ScrollBar 5.List

1. java.awt.Label Einfache GUI-Komponente um einzeiligen Text darzustellen. Konstruktoren und Methoden Label() Label(String text) Label(String text, int alignment) getAlignment():int getText():String setAlignment(int a) setText(String text) Konstruktor mit Text Ausrichtung (RIGHT, CENTER, LEFT) Gibt Ausrichtung zurück Gibt Text zurück Setzt neue Ausrichtung Setzt neuen Text Ereignisse keine spezifischen Ereignisse außer diejenigen, die von Component geerbt wurden.

2. java.awt.Button Eine Schaltfläche, die gedrückt werden kann. Konstruktoren und Methoden Button() Button(String label) setLabel(String) getLabel():String setActionCommand(String ac) getActionCommand():String Konstruktor mit Text Setzt den am Button erscheinenden Text. Gibt den am Button sichtbaren Text zurück. Setzt Text, der dann mit dem ActionEvent mitgeschickt wird Ereignisse addActionListener(ActionListener l) removeActionListener(ActionListener l) //+ inherited from Component Registriert einen ActionListener Entfernt einen registrierten Listener

3. java.awt.Checkbox Checkbox zum anklicken. Checkboxes können Mitglied in einer CheckboxGroup sein und lassen sich dann nur exklusiv anklicken. in einer Checkboxgroup ist also maximal eine Checkbox angeklickt. Konstruktoren und Methoden Checkbox() Checkbox(String label) Checkbox(String label, boolean state) Checkbox(String label, boolean state, CheckboxGroup group) getLabel():String getCheckBoxGroup(): CheckboxGroup setState(boolean state) getState():boolean Konstruktor mit Text Setzt text und Zustand (checked ?) zusätzlich mit Angabe einer Group (exklusiv) setzt den Zustand (Darstellung ändert sich) gibt den gegenwärtigen Zustand zurück Ereignisse addItemListener(ItemListener l) removeItemListener(ItemListener l) //+ inherited from Component Registriert einen ItemListener Entfernt einen registrierten Listener ItemEvents werden ausgelöst, wenn sich der state verändert.

3b. java.awt.CheckboxGroup CheckBoxGroup ist von Object abgeleitet, also keine klassische Benutzerschnittstellenkomponente. Sie ermöglichet aber in Zusammenhang mit der Klasse CheckBox exklusive Auswahl (Radiobuttons). Es kann jeweils nur eine Checkbox angewählt werden. Beispiel CheckBox a,b,c; CheckboxGroup cbg = new CheckBoxGroup(); a = new Checkbox("Checkbox A", cbg, false); b = new Checkbox("Checkbox B", cbg, false); c = new Checkbox("Checkbox C", cbg, true); // add them to a container Methoden getSelectedCheckBox(): CheckBox // returns the checkbox in the group, whose state is // true (may be null, if all are off) setSelectedCheckBox(CheckBox box) // turns the state of the given Box into true, all // others will be set to false.

4. java.awt.Choice Drop-Down Auswahlfeld (Pop-up Menu) zur Auswahl eines "Items". Items sind Strings. Konstruktoren und Methoden Choice() add(String item) addItem(String item) CheckboxGroup getItemCount():int getItem(int index):String getSelectedIndex():int getSelectedItem():String insert(String item, int index) select(int index) selectItem(String item) removeAll() remove(int index) ... fügt Item hinzu s.o. Anzahl der Items Gibt das Item an der Stelle index zurück Gibt den Index des gerade ausgewählten Items zurück Gibt das ausgewählte Item zurück Fügt ein Item an eine best. Stelle ein Setzt die Auswahl s.o. Entfernt alle Items Ereignisse Registriert einen ItemListener Entfernt einen registrierten Listener addItemListener(ItemListener l) removeItemListener(ItemListener l) //+ inherited from Component ItemEvents werden ausgelöst, wenn sich die Auswahl verändert.

5. java.awt.List Liste zur Auswahl eines oder mehrerer Items. (Kann angegeben werden) Konstruktoren und Methoden List() List(int rows) List(int rows, boolean multipleMode) add(String item) remove(int pos) getItem(int i):String isMultipleMode():boolean getSelectedItem():String getSelectedItems():String[] Konstruktor mit Anzahl der sichtbaren (!) Items Ein- oder Mehrfachauswahl (->Tasten Strg, Shift) fügt Item hinzu entfernt eines. Mehrfachauswahl? Ausgewähltes bei Einfachauswahl ...bei Mehrfachauswahl Ereignisse addItemListener(ItemListener l) removeItemListener(ItemListener l) addActionListener(ActionListener l) removeActionListener(ActionListener l) //+ inherited from Component Registriert einen ItemListener Entfernt einen registrierten Listener Registriert einen ActoinListener ItemEvents werden ausgelöst, wenn sich die Auswahl ändert. ActionEvents werden ausgelöst, wenn der Benutzer einen Doppelklick auf ein Item ausführt.

6. java.awt.Scrollbar Kann zur Auswahl von Zahlenwerten verwendet werden. Horizontal und vertikal möglich. Konstruktoren und Methoden ScrollBar() ScrollBar(int orientation) setMinimum(int i) setMaximum(int i) setValue(int i) setBlockIncrement(int increment) setUnitIncrement(int increment) ... //diverse getter Eine vertikale Scrollbar Vertikal oder horizontal (Konstanten !) Minimum (default = 0) Maximum (default = 100) Setzt den Wert. (Darstellung !) (def = 0) Setzt, wieviel sich der Wert verändern soll, wenn der Benutzer in die Fläche klickt oder Pg up/dn drückt. (10) Setzt, wieviel sich der Wert verändern soll, wenn der Benutzer Line up/dn betätigt oder auf die Pfeile klickt. ( default = 1) Ereignisse addAdjustmentListener(AdjustmentListener l) removeAdjustmentListener(AdjustmentListener l) //+ inherited from Component Registriert einen AdjustmentListener Entfernt einen registrierten Listener AdjustmentEvents werden ausgelöst, wenn sich der value verändert.

7. TextComponent java.awt.Component hier sind gemeinsame Eigenschaften und Methoden, Ereignisse festgelegt java.awt.TextComponent TextField TextArea AdjustmentEvents werden ausgelöst, wenn sich der value verändert.

7. java.awt.TextComponent TextComponent ist die Oberklasse von allen Komponenten die das Editieren und Auswählen von Text unterstützen. Sollte nicht instanziert werden. Methoden setText(String text) setEditable(boolean editable) setCaretPosition(int i) select(int start, int end) selectAll() getText() getSelectedText():String isEditable() //diverse weitere getter Setzt den Text Setzt, ob der Text vom Benutzer editiert werden kann Setzt die Postition des Cursors Markiert einen Teil des Textes als ausgewählten Text. Markiert den gesamten Text. gibt die momentane Auswahl zurück Ereignisse addTextListener(TextListener l) removeTextListener(TextListener l) //+ inherited from Component Registriert einen TextListener Entfernt einen registrierten Listener TextEvents werden ausgelöst, wenn sich der Text verändert.

7a. java.awt.TextField Unterklasse von Textkomponent (Ist ein TextComponent). Unterstützt also das Editieren und die Auswahl von Text. Ein Textfield bearbeitet immer genau eine Zeile! Es wird meist zur Eingabe von Zahlen, Datum, einer Zeile verwendet. Konstruktoren und Methoden TextField() TextField(int columns) //geerbte von TextComponent setEchoChar(char echo) Anzahl der Spalten ->sind auch die wichtigsten Man kann ein Zeichen setzen, das anstelle der Eingabe des Benutzers angezeigt wird (Password). Ereignisse //+ geerbte von TextComponent (TextEvent) addActionListener(ActionListener l) removeActionListener(ActionListener l) Registriert einen TextListener Entfernt einen registrierten Listener ActionEvents werden ausgelöst, sobald der Benutzer die "Return"- Taste betätigt.

7b. java.awt.TextArea Unterklasse von Textkomponent (Ist ein TextComponent). Unterstützt also das Editieren und die Auswahl von Text. Ein Textfield kann mehrere Zeilen anzeigen und deren Bearbeitung zulassen. Konstruktoren und Methoden TextArea() TextArea(int rows, columns) TextArea(int r, c, String text) TextArea(int r,c, String t, int Scrollbarvis) TextArea(String text) //+ geerbte von TextComponent append(String text) getScrollbarVisibility():int replaceRange(String str, int start, int end) insert(String str, int pos) setColumns(int col) setRows(int rows) Immer mit zwei Scrollbars Anzahl der Spalten Sichtbarkeit der Scrollbars läßt sich bestimmen Immer mit 2 Scrollbars. fügt Text am Ende hinzu Welche Scrollbars sind gerade sichtbar. (Konstanten) Ersetzt einen Bereich durch den angegebenen String. Fügt eine Zeichenkette ein. Setzt die Anzahl der Spalten Setzt die Anzahl der Zeilen Ereignisse //+ geerbte von TextComponent (TextEvent) keine weiteren

Übersicht (ohne Container) 4.Choice 7.TextField 1.Label 2.Button 3.Checkbox 8.TextArea 6.ScrollBar 5.List

java.awt.Component Allgemeines ?????????
Component ist die abstrakte Oberklasse aller Benutzerschnittstellenkomponenten inkl. der Behälter (Container) (Außnahme: Menüs). Ein Component hat eine grafische Repräsentation und kann mit dem Benutzer interagieren. Die Oberklasse von Component ist Object. wichtige Methoden setBounds(int x, y, w, h) setLocation(int x, int y) setSize(int w, int h) setForeground(Color fg) setBackground(Color bg) setFont(Font f) setEnabled(boolean enabled) setVisible(boolean) getParent(): Container Position und Größe der Komponente setzen (Benötigt z.b. LayoutManager) Komponente zu neuem Ort bewegen Neue Größe Vordergrundfarbe (zB für Text) Hintergrundfarbe Setzt eine Schriftart, die für Text verwendet werden soll Legt fest, ob die Komponente mit dem Benutzer intergieren soll. Soll die Komponente am Bildschirm sichtbar sein? Jede Komponente kann den Container in dem Sie sich befindet zurückgeben (oder null)

java.awt.Component Ereignisse, für man sich bei allen Components anmelden kann addComponentListener(ComponentListener l) addFocusListener(FocusListener l) addHierarchyListener(HierarchyListener l) addKeyLIstener(KeyListener l) addMouseListener(MouseListener l) addMouseMotionListener(MouseMotionListener) // + diverse remove-Methoden Component was hidden, moved, resized, shown Texteingabe geht an diese Komponente Die Hierarchy hat sich verändert (z.B. neue Komponente) Tastendruck wurde an die Komponente geschickt. Maus-klicks Bewegung der Maus (viele Events, mit Position x,y) Diese Art von Ereignissen benötigt man eher selten. Häufiger werden diejenigen Ereignisse benötigt, die spezifische Benutzerschnittstellenkomponenten erzeugen. (Zb. wird man bei einem Textfield nur selten jeden Tastendruck abarbeiten wollen, sondern darauf warten, bis der Benutzer "Return drückt" (ActionEvent)).

Rückblick (1) Oberklasse aller GUI-Komponenten

Grundlegende Architektur von GUIs Frame MenuBar Panel (with Layoutmanager) Panel (with Layoutmanager) hierarchische Anordnung es gibt Components und Container Components liegen in Containers Ein Container kann einen Layoutmanager zugeordnet haben, der die Anordnung (x,y,w,h) der Components bestimmt Bei Components und Containers kann man sich für verschiedene Ereignisse als Listener anmelden (zB. MouseListener, ActionListener,... ) List Button

Behälter für GUI-Komponenten
Allgemeines Container benötigt man, um Benutzerschnittstellenkomponenten anzuordnen. Container sind selbst wieder Benutzerschnittstellenkomponenten und können daher wieder in anderen Containern enthalten sein (vgl. Datei/Verzeichnis). Benutzerschnittstellenkomponenten werden in solchen Containern angeordnet. Ihre Koordinaten beziehen sich jeweils auf den Container, in dem sie sich befinden. yC2 xC2 yB xB Container2 Container1

LayoutManager Jedem Container kann ein Layoutmanager zugeordnet werden. Dieser bestimmt dann Position und/oder Größe der im Container befindlichen Komponenten. Wenn sich die Größe des Containers ändert entscheidet dieser, ob und wie die Komponenten neu angeordnet werden. Benutzer ändert Größe. Ein LayoutManager könnte bestimmen, daß auch die Buttons größer werden müssen. Man kann (und es ist häufig auch zweckmäßig) auf Layout Manager verzichten und einfach feste Positionen (mit setBounds(x,y,w,h)) angeben. Diese würden bei einer Größenänderung des Containers allerdings nicht angepaßt.

Die gemeinsame Oberklasse java.awt.Container Container ist von Component abgeleitet. Ein Container hat ebenso Größe, Position und kann eine Vielzahl von Ereignissen erzeugen. Container enthalten Components, die wiederum Container sein können. So wird die die hierarchische Architektur von GUI-Anwendungen ermöglicht. Konstruktor und wichtige Methoden Container() add(Component c) remove(Component c) removeAll() getComponentCount():int setLayout(LayoutManager l) validate() validateTree() Wird hier nicht benötigt. Component hinzufügen Component entfernen Alle entfernen Anzahl der Components LayoutManager setzten (ev: null -> kein LM) Der Layoutmanager soll alle Components neu layoutieren wie oben, mit rekursivem Abstieg. Zusätzliche Ereignisse addContainerListener(ContainerListener l) Für Ereignisse beim Hinzufügen oder Entfernen von Components anmelden remove...

Hierarchie der Container-Klassen Container (Oberklasse, wird nur zu besonderen Zwecken direkt instanziert, definiert gemeinsame Funktionalität des Enthaltens weiterer Components) Panel (extends Container) (Einfacher Container, kein Anwendungsfenster, keine (!) über Container hinausgehende Funktionalität, wird zur Bildung der Hierarchie häufig verwendet) Window (...) (Basisfenster einer Anwendung ohne Titelleiste, ohne Rahmen, wie es z.B. bei Starten von JBuilder angezeigt wird; Windows enthalten keine Windows!) Frame (voll-funktionales Fenster einer Anwendung, besonders wichtig) Dialog (voll-funktionaler Dialog, meist abhängig von einem Fenster zB. Datei öffnen-Dialog)

java.awt.Window Definiert das grundlegende Verhalten von sog. Top-Level-Windows. Die jeweils den obersten Knoten einer Komponentenhierarchie bilden. Objekte der Klasse Window haben keinen Rahmen, keine Titelleiste und keine Menuleiste. (Solche Windows werden häufig beim Starten von Programmen angezeigt.) Konstruktor und wichtige Methoden Window(Windows parent) //Methoden von Container + show() isShowing() pack() dispose() hide() toBack() toFront() Wird hier nicht benötigt. Fenster sichtbar machen. (Erzeugte Fenster sind inital unsichbar) Prüft, ob das Fenster gerade sichtbar ist. Die Größe des Fensters wird so verändert, daß die enthaltene GUI- Hierarchie optimal reinpaßt. Fenster mit allen Ressourcen freigeben. Fenster unsichbar machen. Fenster in den Hintergrund legen. Fenster nach vorne. Ereignisse Anmeldung für Ereignisse bei open, close, resize des Window addWindowEventListener(WEL l) removeWindowsEventListener(l)

java.awt.Frame Ist ein Top-Level-Window mit Rahmen und Titel. Kann eine Menüleiste haben. Konstruktor und wichtige Methoden Frame() Frame(String title) //Methoden von Window + setResizeable(boolean res) setTitle(String title) setMenuBar(MenuBar mb) setIconImage(Image img) setState(int state) //diverse getter... mit Titel Setzt, ob der Benutzer die Größe des Frames ändern kann. Setzt den Titel. Setzt eine Menüleiste Setzt ein Bild für ikonifizierte Darstellung. Setzt, ob der Frame normal oder ikonifiziert dargestellt wird. (Konstanten Frame.ICONIFIED oder Frame.NORMAL) Keine zusätzlichen Ereignisse

java.awt.Dialog Ist ein Top-Level-Window mit Rahmen und Titel. Ikonifizieren und Wiederherstellen nicht möglich. Dialog kann modal sein (sperrt andere Windows der Anwendung). Ein Dialog wird häufig kurzfristig geöffnet, um Eingaben vom Benutzer einzulesen und anschließend wieder geschlossen. Konstruktor und wichtige Methoden Zur Konstruktion wird ein Frame oder Dialog benötigt. Modal gibt an, ob man während der Dialog geöffnet ist, die Interaktion mit anderen Windows unterbinden will. Setzt den Titel. Setzt, ob der Benutzer die Größe des Frames ändern kann. Macht den Dialog sichtbar. Schließt den Dialog und gibt alle Ressourcen frei. Dialog(Frame owner, boolean modal) Dialog(Dialog ownder, boolean modal) //Methoden von Window + setTitle(String title) setResizable(boolean isRes) show() dispose() Keine zusätzlichen Ereignisse

Grundlegende Architektur von GUIs Frame MenuBar Panel (with Layoutmanager) Panel (with Layoutmanager) Bisher: Benutzerschnittstellenkomponenten, Container Ein Container kann einen Layoutmanager zugeordnet haben, der die Anordnung (x,y,w,h) der Components bestimmt Bei Components und Containers kann man sich für verschiedene Ereignisse als Listener anmelden (zB. MouseListener, ActionListener,... ) List Button

Layout Management Grundidee Grundprinzip
Die Anordnung von Components in einem Container soll durch sog. LayoutManager-Objekte automatisch erfolgen. Diese reagieren auch auf Größenänderungen des Containers. Für jeden Container wird ein eigener LayoutManager gesetzt. Alternative: Manuelle Angabe von Position und Größe jeder Komponente relativ zum Container. (auch genannt: null-Layout) Grundprinzip aContainer.setLayout(new XXXLayout()); aContainer.add(component1); aContainer.add(component2); aContainer.add(otherContainer); //Layoutmanager bestimmt Positionen der Components im Container Alle Container haben auch ein Default-Layout.

Layout Management Klassen
FlowLayout Ordnet die Komponenten wie Wörter auf einer Seite an. (Zentriert, rechts- oder linksbündig) BorderLayout Unterstützt genau 5 Komponenten. Eine an jeder Seite und eine im Zentrum GridLayout Teilt den Container in Zeilen und Spalten. Alle Zellen sind gleich groß. GridBagLayout Sehr flexibel und kompliziert. Für jede Komponente können Einschränkungen definiert werden. CardLayout Zeigt jeweils nur eine Komponente, die den Container ausfüllt. Die anderen liegen quasi unsichtbar dahinter und man blättert bei Bedarf weiter (zB. Tabs)

Layout Management FlowLayout
f = new FlowLayout(); f.setAlignment(FlowLayout.CENTER, 20, 20) // Zentriert; horizontaler // und vertikaler Abstand = 20 container.setLayout(f); container.add(component1); container.add(component2); container.add(containerX);

Layout Management BorderLayout
container.setLayout(new BorderLayout()); container.add(component1, BorderLayout.NORTH); container.add(component2, BorderLayout.CENTER); container.add(containerX, BorderLayout.WEST); ...

Layout Management GridLayout
g = new GridLayout(rows, cols); //Zeilen und Spalten container.setLayout(g); container.add(component1); // Auffüllen von links oben zeilenweise // nach rechts unten container.add(component2); container.add(containerX);

Layout Management Weitere GridbagLayout CardLayout

Layout Management null-Layout Anwendung
Beim Arbeiten ohne LayoutManager muß man selbst für die Anordnung der Komponenten sorgen. Bei Größenänderungen erfolgt keine automatische Anpassung, wie bei Verwendung von Layout-Managern. Dennoch wird dies häufig verwendet. Anwendung container.setLayout(null); // explizit nötig, um default-layout zu umgehen component1.setBounds(10,10,100,100); // x, y, Breite, Höhe component2.setBounds(10,150,100,100); // x, y, Breite, Höhe container.add(component1); container.add(component2);

Zusammenfassung Bisher: Components 8 AWT-Componenten
Containers Panel, Frame, Dialog LayoutManagers für Container FlowLayout, BorderLayout, GridLayout (Grundlagen: Ereignisse) Damit haben wir die grundsätzlichen Voraussetzungen zum Aufbau von Benutzerschnittstellen.

Beispielanwendungen Grundsätzliche Vorgangsweise:
Komponenten erzeugen und Eigenschaften setzen Komponenten zu Container hinzufügen Anordnung der Komponenten im Container (LayoutManagement) Behandlung der Ereignisse der Komponenten

Beispiel 1 - FlowLayout Ohne Ereignisse
class MyFirstGUIApp extends Frame { FlowLayout myLayout = new FlowLayout(); Label label1 = new Label ("ein erstes Label"); Label label2 = new Label ("ein zweites Label"); Button button1 = new Button ("ein erster Button"); public MyFirstGUIApp() { setTitle("Eine erste GUI-Anwendung"); initGUI(); } private void initGUI() { myLayout.setAlignment(FlowLayout.CENTER); this.setLayout(myLayout); this.add(label1); this.add(label2); this.add(button1); } public static void main() { MyFirstGUIApp app = new MyFirstGUIApp(); app.show() } } Ohne Ereignisse

Beispiel 2 - GridLayout Ohne Ereignisse
public class MyGUIApp2 extends Frame { //create layout with hgap and vgap GridLayout myLayout = new GridLayout(5, 5, 2, 2); Label[] labels; public MyGUIApp2() { setTitle("Eine zweite GUI-Anwendung"); labels = new Label[25]; for (int i = 1; i <= 25; i++) { labels[i-1] = new Label("Label" + i); labels[i-1].setBackground(new Color(255,200, i * 10)); } initGUI(); private void initGUI() { this.setLayout(myLayout); for (int i = 0; i < labels.length; i++) { this.add(labels[i]); public static void main(String[] args) { MyGUIApp2 myGUIApp = new MyGUIApp2(); myGUIApp.pack(); // size of frame will be usefully set myGUIApp.show(); // the frame will show up

Beispiel 3 - NullLayout Ohne Ereignisse
public class MyGUIApp3 extends Frame { Label forenameLabel = new Label("Vorname:", Label.RIGHT); Label surnameLabel = new Label("Nachname:", Label.RIGHT); TextField forenameField = new TextField(30); TextField surnameField = new TextField(50); public MyGUIApp3() { setTitle("Eine dritte GUI-Anwendung"); initGUI(); } private void initGUI() { this.setLayout(null); this.setSize(300,300); forenameLabel.setBounds(10,50,100,25); surnameLabel.setBounds(0,100,100,25); forenameField.setBounds(120, 50, 100, 25); surnameField.setBounds(110, 100, 200, 25); surnameField.setEnabled(false); this.add(surnameField); this.add(forenameLabel); this.add(forenameField); this.add(surnameLabel); public static void main(String[] args) { MyGUIApp3 myGUIApp = new MyGUIApp3(); //myGUIApp.pack(); // size of frame will be usefully set myGUIApp.show(); // the frame will show up Ohne Ereignisse

Beispiele Zusammenfassung: Wir leiten von Frame ab. import java.awt.*
Beim Starten der Anwendung werden Initialisierungen durchgeführt, die Komponenten erzeugt, Eigenschaften der Komponenten gesetzt. Dem Container wird ein LayoutManager-Objekt zugeordnet. Die Components werden dem Container hinzugefügt. Abschließend wird frame.show() aufgerufen. Genau dann erscheint die Anwendung. Derjenige Thread, der die Initialisierungen durchgeführt hat ist beendet (Main Thread). Dennoch läuft die Anwendung (in einem anderen Thread (AWT-Event-Thread) weiter. Ereignisse treten innerhalb von AWT auch jetzt auf: resize, KeyEvents, ... Unsere Klasse ist jedoch bei keiner Component als Listener für Ereignisse registriert.

AWT-Ereignisse Allgemeines:
Benutzerschnittstellen können mehr oder weniger spezifische Ereignisse erzeugen Einerseits kann man sich bei jeder Komponente für eine Reihe von "Low- Level-Ereignissen anmelden (MouseEvent, KeyEvent, ...), andererseits ist es eine Stärke der Komponenten aussagekräftigere Events zu erzeugen ( ActionEvent, ItemEvent) Wir werden also vorwiegend spezifische Ereignisse der Komponenten nutzen. Für welche Ereignisse man sich bei welcher Komponente registrieren kann, wurde bereits bei den einzelnen Komponenten behandelt (Button, ...)

AWT-Ereignisse Ereignishierarchie: AWTEvent ActionEvent
AdjustmentEvent ComponentEvent ContainerEvent FocusEvent InputEvent KeyEvent MouseEvent PaintEvent WindowEvent ItemEvent TextEvent "Low-Level-Events"

AWT-Ereignisse Nutzung von Ereignissen (Variante 1: Listener)
In eigenen Klassen implementiert man die entsprechenden XXX-Listener Interfaces (extends Frame implements ActionListener) Anmeldung bei Komponenten für interessierende Events (list.addItemListener(this)) Ausprogrammieren der Ereignisbehandlung in den Methoden des Listener-Interface. Dabei nutzt man nach Möglichkeit die Informationen, die das jeweilige Ereignis bietet. Nach dem Starten des Programms werden die entprechenden Listener-Methoden mit Ereignissen als Parameter aufgerufen. Wichtig: Jedes Event-Objekt kann mit getSource():Object gefragt werden, in welcher Component es ursprünglich entstanden ist.

Beispiel E1 – Button & Label
public class MyGUIAppE1 extends Frame implements ActionListener { Label valueLabel = new Label("Nachname:", Label.RIGHT); Button increaseButton = new Button("Wert erhöhen"); int value = 0; public MyGUIAppE1() { setTitle("Eine erste GUI-Anwendung mit Ereignissen"); initGUI(); } private void initGUI() { this.setLayout(new FlowLayout(FlowLayout.CENTER)); this.add(valueLabel); this.add(increaseButton); //add listeners increaseButton.addActionListener(this); //interface ActionListener public void actionPerformed(ActionEvent e) { if (e.getSource()==increaseButton) { value++; valueLabel.setText("Der Wert beträgt jetzt: " + value); } else { System.err.println("Ereignis von unbekanntem Objekt empfangen"; public static void main(String[] args) { MyGUIAppE1 myGUIApp = new MyGUIAppE1(); myGUIApp.pack(); // size of frame will be usefully set myGUIApp.show(); // the frame will show up System.err.println("show doesn´t block."); ActionEvent

Beispiel E2 – Low-Level-Event
public class MyGUIAppE2 extends Frame implements MouseMotionListener { Label positionLabel = new Label("Mausposition:", Label.RIGHT); public MyGUIAppE2() { setTitle("Eine zweite GUI-Anwendung mit Ereignissen"); initGUI(); } private void initGUI() { this.setLayout(new FlowLayout(FlowLayout.CENTER)); setSize(300,300); this.add(positionLabel); //add listeners this.addMouseMotionListener(this); // interface MouseMotionListener public void mouseDragged(MouseEvent e){}; // not needed public void mouseMoved(MouseEvent e) { int x = e.getX(); int y = e.getY(); positionLabel.setText("Mausposition:" + x + ":" + y); public static void main(String[] args) { MyGUIAppE2 myGUIApp = new MyGUIAppE2(); myGUIApp.show(); // the frame will show up System.err.println("show doesn´t block."); MouseMotion

Beispiel E3 – Low-Level-Event
import java.awt.*; import java.awt.event.*; public class MyGUIAppE3 extends Frame implements WindowListener { public MyGUIAppE3() { setTitle("Eine dritte GUI-Anwendung mit Ereignissen"); initGUI(); } private void initGUI() { this.setLayout(new FlowLayout(FlowLayout.CENTER)); setSize(300,300); //add listeners this.addWindowListener(this); //interface WindowListener public void windowOpened(WindowEvent e){}; public void windowClosing(WindowEvent e){ this.dispose(); System.exit(0); }; public void windowClosed(WindowEvent e){}; public void windowIconified(WindowEvent e){}; public void windowDeiconified(WindowEvent e){}; public void windowActivated(WindowEvent e){}; public void windowDeactivated(WindowEvent e){}; public static void main(String[] args) { MyGUIAppE3 myGUIApp = new MyGUIAppE3(); myGUIApp.show(); // the frame will show up System.err.println("show doesn´t block."); WindowEvent

AWT-Ereignisse Nutzung von Ereignissen (Variante 2: Adapters)
Im vorigen Beispiel erkennt man, daß rel. viele Methoden implementiert werden müsse, obwohl man nur eine benötigt. Generell ist es häufig wünschenswert, daß ein eigenes Objekt die Ereignisbehandlung übernimmt Genau dazu dienen Adaptoren Man findet eine Reihe von Adapter-Klassen in java.awt.event; (zB. WindowAdapter) Dabei emfängt das Apapter-Objekt das Event. Adaptoren werden meist als Anonymous-class realisiert und können daher die Methoden der umgebenden Klasse aufrufen.

Beispiel E4 – Adaptoren WindowAdaptor import java.awt.*;
import java.awt.event.*; public class MyGUIAppE4 extends Frame { WindowAdapter windowAdapter = new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); System.exit(0); } }; public MyGUIAppE4() { setTitle("Eine vierte GUI-Anwendung mit Ereignissen"); initGUI(); private void initGUI() { this.setLayout(new FlowLayout(FlowLayout.CENTER)); setSize(300,300); //add listeners this.addWindowListener(windowAdapter); public static void main(String[] args) { MyGUIAppE4 myGUIApp = new MyGUIAppE4(); myGUIApp.show(); // the frame will show up System.err.println("show doesn´t block."); WindowAdaptor

Programmierpraktikum Java SS 2005

Ähnliche Präsentationen

Präsentation zum Thema: "Programmierpraktikum Java SS 2005"— Präsentation transkript:

Ähnliche Präsentationen

Über Projekt

Feedback

Anmelden

Anmeldung über soziales Netzwerk:

Programmierpraktikum Java SS 2005

Ähnliche Präsentationen

Präsentation zum Thema: "Programmierpraktikum Java SS 2005"— Präsentation transkript:

Ähnliche Präsentationen

Über Projekt

Feedback