Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 15 Grafische Oberflächen mit Swing
|  | 15.1 Das Abstract Window Toolkit und Swing
|  |  | 15.1.1 Abstract Window Toolkit (AWT)
|  |  | 15.1.2 Java Foundation Classes
|  |  | 15.1.3 Was Swing von AWT unterscheidet
|  |  | 15.1.4 Die Klasse Toolkit
|  | 15.2 Fenster unter grafischen Oberflächen
|  |  | 15.2.1 Swing-Fenster darstellen
|  |  | 15.2.2 AWT-Fenster darstellen
|  |  | 15.2.3 Sichtbarkeit des Fensters
|  |  | 15.2.4 Größe und Position des Fensters verändern
|  |  | 15.2.5 Unterklassen der Fenster-Klassen bilden
|  |  | 15.2.6 Fenster- und Dialog-Dekoration
|  |  | 15.2.7 Dynamisches Layout während einer Größenänderung
|  | 15.3 Beschriftungen (JLabel)
|  |  | 15.3.1 Mehrzeiliger Text, HTML in der Darstellung
|  | 15.4 Icon und ImageIcon für Bilder auf Swing-Komponenten
|  |  | 15.4.1 Die Schnittstelle Icon
|  | 15.5 Es tut sich was – Ereignisse beim AWT
|  |  | 15.5.1 Die Klasse AWTEvent
|  |  | 15.5.2 Events auf verschiedenen Ebenen
|  |  | 15.5.3 Swings Ereignisquellen und Horcher (Listener)
|  |  | 15.5.4 Listener implementieren
|  |  | 15.5.5 Listener bei dem Ereignisauslöser anmelden/abmelden
|  |  | 15.5.6 Aufrufen der Listener im AWT-Event-Thread
|  |  | 15.5.7 Adapterklassen nutzen
|  |  | 15.5.8 Innere Mitgliedsklassen und innere anonyme Klassen
|  | 15.6 Schaltflächen
|  |  | 15.6.1 Normale Schaltflächen (JButton)
|  |  | 15.6.2 Der aufmerksame ActionListener
|  |  | 15.6.3 Basisklasse AbstractButton
|  |  | 15.6.4 Wechselknopf (JToggleButton)
|  | 15.7 Swing Action
|  |  | 15.7.1 javax.swing.Action
|  |  | 15.7.2 Eigenschaften der Action-Objekte
|  | 15.8 JComponent und Component als Basis aller Komponenten
|  |  | 15.8.1 Tooltips
|  |  | 15.8.2 Rahmen (Border)
|  |  | 15.8.3 Fokus und Navigation
|  |  | 15.8.4 Ereignisse jeder Komponente
|  |  | 15.8.5 Die Größe und Position einer Komponente
|  |  | 15.8.6 Komponenten-Ereignisse
|  |  | 15.8.7 Hinzufügen von Komponenten
|  |  | 15.8.8 UI-Delegate – der wahre Zeichner
|  |  | 15.8.9 Undurchsichtige (opak) Komponente
|  |  | 15.8.10 Properties und Listener für Änderungen
|  |  | 15.8.11 Swing-Beschriftungen eine andere Sprache geben
|  | 15.9 Container
|  |  | 15.9.1 Standardcontainer (JPanel)
|  |  | 15.9.2 Bereich mit automatischen Rollbalken (JScrollPane)
|  |  | 15.9.3 Reiter (JTabbedPane)
|  |  | 15.9.4 Teilung-Komponente (JSplitPane)
|  | 15.10 Alles Auslegungssache: die Layoutmanager
|  |  | 15.10.1 Übersicht über Layoutmanager
|  |  | 15.10.2 Zuweisen eines Layoutmanagers
|  |  | 15.10.3 Im Fluss mit FlowLayout
|  |  | 15.10.4 Mit BorderLayout in allen Himmelsrichtungen
|  |  | 15.10.5 Rasteranordnung mit GridLayout
|  |  | 15.10.6 Der GridBagLayout-Manager
|  |  | 15.10.7 Null-Layout
|  |  | 15.10.8 BoxLayout
|  |  | 15.10.9 Weitere Layoutmanager
|  | 15.11 Rollbalken und Schieberegler
|  |  | 15.11.1 Schieberegler (JSlider)
|  |  | 15.11.2 Rollbalken (JScrollBar)
|  | 15.12 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen
|  |  | 15.12.1 Kontrollfelder (JCheckBox)
|  |  | 15.12.2 ItemSelectable, ItemListener und das ItemEvent
|  |  | 15.12.3 Sich gegenseitig ausschließende Optionen (JRadioButton)
|  | 15.13 Fortschritte bei Operationen überwachen
|  |  | 15.13.1 Fortschrittsbalken (JProgressBar)
|  |  | 15.13.2 Dialog mit Fortschrittsanzeige (ProgressMonitor)
|  | 15.14 Menüs und Symbolleisten
|  |  | 15.14.1 Die Menüleisten und die Einträge
|  |  | 15.14.2 Menüeinträge definieren
|  |  | 15.14.3 Einträge durch Action-Objekte beschreiben
|  |  | 15.14.4 Mit der Tastatur: Mnemonics und Shortcut
|  |  | 15.14.5 Der Tastatur-Shortcut (Accelerator)
|  |  | 15.14.6 Tastenkürzel (Mnemonics)
|  |  | 15.14.7 Symbolleisten alias Toolbars
|  |  | 15.14.8 Popup-Menüs
|  |  | 15.14.9 System-Tray nutzen
|  | 15.15 Das Model-View-Controller-Konzept
|  | 15.16 Auswahlmenüs, Listen und Spinner
|  |  | 15.16.1 Auswahlmenü (JComboBox)
|  |  | 15.16.2 Zuordnung einer Taste mit einem Eintrag
|  |  | 15.16.3 Datumsauswahl
|  |  | 15.16.4 Listen (JList)
|  |  | 15.16.5 Drehfeld (JSpinner)
|  | 15.17 Texteingabefelder
|  |  | 15.17.1 Text in einer Eingabezeile
|  |  | 15.17.2 Die Oberklasse der Text-Komponenten (JTextComponent)
|  |  | 15.17.3 Geschützte Eingaben (JPasswordField)
|  |  | 15.17.4 Validierende Eingabefelder (JFormattedTextField)
|  |  | 15.17.5 Einfache mehrzeilige Textfelder (JTextArea)
|  |  | 15.17.6 Editor-Klasse (JEditorPane)
|  | 15.18 Tabellen (JTable)
|  |  | 15.18.1 Ein eigenes Tabellen-Model
|  |  | 15.18.2 Basisklasse für eigene Modelle (AbstractTableModel)
|  |  | 15.18.3 Vorgefertigtes Standard-Modell (DefaultTableModel)
|  |  | 15.18.4 Ein eigener Renderer für Tabellen
|  |  | 15.18.5 Zell-Editoren
|  |  | 15.18.6 Größe und Umrandung der Zellen
|  |  | 15.18.7 Spalteninformationen
|  |  | 15.18.8 Tabellenkopf von Swing-Tabellen
|  |  | 15.18.9 Selektionen einer Tabelle
|  |  | 15.18.10 Automatisches Sortieren und Filtern mit RowSorter
|  |  | 15.18.11 Ein professionelles Tabellenlayout mit JGrid
|  | 15.19 Bäume (JTree)
|  |  | 15.19.1 JTree und sein TreeModel und TreeNode
|  |  | 15.19.2 Selektionen bemerken
|  |  | 15.19.3 Das TreeModel von JTree
|  | 15.20 JRootPane, JLayeredPane und JDesktopPane
|  |  | 15.20.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane)
|  |  | 15.20.2 JLayeredPane
|  |  | 15.20.3 JDesktopPane und die Kinder JInternalFrame
|  | 15.21 Dialoge und Window-Objekte
|  |  | 15.21.1 JWindow und JDialog
|  |  | 15.21.2 Modal oder nicht-modal
|  |  | 15.21.3 Standarddialoge mit JOptionPane
|  |  | 15.21.4 Der Farbauswahldialog JColorChooser
|  |  | 15.21.5 Der Dateiauswahldialog
|  | 15.22 Flexibles Java-Look
|  |  | 15.22.1 L & F global setzen
|  |  | 15.22.2 UIManager
|  |  | 15.22.3 Verbessern des Aussehens unter Windows mit JGoodies Looks
|  | 15.23 Die Zwischenablage (Clipboard)
|  |  | 15.23.1 Clipboard-Objekte
|  |  | 15.23.2 Auf den Inhalt zugreifen mit Transferable
|  |  | 15.23.3 DataFlavor ist das Format der Daten in der Zwischenablage
|  |  | 15.23.4 Einfügungen in der Zwischenablage erkennen
|  |  | 15.23.5 Drag
|  | 15.24 Undo durchführen
|  | 15.25 AWT, Swing und die Threads
|  |  | 15.25.1 Ereignisschlange (EventQueue) und AWT-Event-Thread
|  |  | 15.25.2 Swing ist nicht Thread-sicher
|  |  | 15.25.3 Swing-Elemente mit invokeLater() und invokeAndWait() bedienen
|  |  | 15.25.4 SwingWorker
|  |  | 15.25.5 Eigene Ereignisse in die Queue setzen
|  |  | 15.25.6 Auf alle Ereignisse hören
|  | 15.26 Barrierefreiheit mit der Java Accessibility API
|  | 15.27 Benutzerinteraktionen automatisieren
|  |  | 15.27.1 Automatisch in die Tasten hauen
|  |  | 15.27.2 Mausoperationen
|  |  | 15.27.3 Methoden zur Zeitsteuerung
|  |  | 15.27.4 Screenshots
|  |  | 15.27.5 MouseInfo und PointerInfo
|  | 15.28 Zeitliches Ausführen mit dem javax.swing.Timer
|  | 15.29 Alternativen zu AWT und Swing
|  |  | 15.29.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor
|  |  | 15.29.2 SWT (Standard Widget Toolkit)
|  | 15.30 Zum Weiterlesen
## 15.15 Das Model-View-Controller-Konzept Entsinnen wir uns der Idee des Observer-Patterns: Ein Beobachter beobachtet den zu Beobachtenden. Konkreter: Es meldete sich ein Beobachter an und wurde bei jeder Änderung der Daten informiert. Übertragen auf grafische Benutzungsoberflächen würde dies bedeuten, dass unterschiedlichste Visualisierungen der Daten möglich wären. Diese Trennung heißt auch Document-View-Struktur. Für grafische Oberflächen lässt sich dieses Model zum Model-View-Controller (MVC) verfeinern. Die Idee wurde um 1978/79 ursprünglich von Professor Trygve Reenskaug am Xerox PARC entwickelt und fand zuerst in Smalltalk Eingang. Wie die drei Buchstaben von MVC andeuten, gibt es drei interagierende Objekte: Model. Repräsentiert den internen Zustand eines Objekts und speichert alle interessanten Geschäftsdaten. Ein Model bietet Methoden an, mit denen sich der aktuelle Zustand erfragen und ändern lässt. View. Stellt die Daten des Models in der View dar. Die View nutzt die Methoden des Models, um die Informationen auszulesen. Controller. Nach einer Interaktion mit der grafischen Oberfläche werden die Daten im Model aktualisiert und anschließend vom Viewer neu angezeigt. Diese Dreiteilung trennt alle Daten von der visuellen Repräsentation. Der große Vorteil besteht darin, dass sich alle drei Teile unterschiedlich entwickeln und einsetzen lassen. Die grafischen Komponenten können weiterentwickelt werden, und das Model ändert sich nicht. In Java ist dies besonders aufgrund des wechselnden Aussehens interessant, da dort zur Laufzeit eine neue View zu ihrem existierenden Model gelangt. #### Modifizierte MVC-Architektur für Swing Das MVC-Konzept trennt ganz klar die Bereiche ab, führt aber bei praktischer Realisierung zu zwei Problemen. Das erste betrifft die Entwickler der Komponenten. Meistens sind View und Controller eng verbunden, sodass ein zusätzlicher Schnittstellenaufwand für die Implementierung entsteht. Implementieren wir etwa eine Textkomponente, müsste sie sich um alle Eingaben kümmern und diese dann an die Darstellung weiterleiten. Das zweite sich daraus ergebende Problem ist der erhöhte Kommunikationsaufwand zwischen den Objekten. Wenn sich Ergebnisse in der Darstellung oder dem Model ergeben, führt die Benachrichtigung immer über den Controller. Demnach ist es sinnvoll, VC zu einer Komponente zu verschmelzen, um die komplexe Interaktion zwischen View und Controller zu vereinfachen. Genauso sind die Entwickler der JFC vorgegangen. In Swing findet sich keine Reinform des MVC-Models, sondern eine Verquickung von View und Controller. Durch diese Vereinfachung lassen sich die Benutzeroberflächen leichter programmieren, wobei wir nur wenig Flexibilität einbüßen. Das neue Model wird statt MVC auch Model View Presenter (MVP-Pattern) genannt. Betrachten wir das MVP-Konzept am Beispiel einer Tabellenkalkulation. Die Daten in einem Arbeitsblatt entsprechen den Daten, die unterschiedlich visualisiert werden können: klassisch in einem Tabellenblatt und modisch in einem Diagramm. Ein Model kann problemlos mehrere Sichten aufweisen. Eine Änderung der Daten im Tabellenblatt führt nun zu einer Änderung in den internen Daten, und umgekehrt führen diese zu einer Änderung des Diagramms. #### Die Klasse ComponentUI und Modelle In Java sind die View und der Controller durch ein Objekt ComponentUI repräsentiert. Da wir Aussehen und Verhalten von Java-Komponenten frei bestimmen können, gibt es demnach für alle konkreten Swing-Komponenten ein ComponentUI-Objekt, das die Darstellung und Benutzeraktionen übernimmt. Ein JList-Objekt verweist dann auf eine paint()-Methode im ComponentUI-Objekt, das die Darstellung wirklich vornehmen kann. Die Daten der Liste befinden sich im Model. #### Model-Klassen Wenn wir uns mit einigen Modellen beschäftigen, werden wir sehen, dass für manche Komponenten sehr unterschiedliche Modelle gefordert sind. Eine Schaltfläche visualisiert meistens eine Zeichenkette. Eine Tabelle repräsentiert aber nicht immer nur einfache Texte. Hier können die Daten durchaus eine komplexe Objektstruktur darstellen. Um diese visualisieren zu können, muss der Viewer diese Daten erst bekommen. Dafür wird ein spezielles Model implementiert, das die Daten für die Ansicht zur Verfügung stellt. Mit eigenen Modellen werden wir uns bei den Tabellen im Kapitel »Tabellen mit JTable« beispielhaft beschäftigen.
Model | Klasse, die dieses Model nutzt
ListModel | JList
ComboBoxModel | JComboBox
ButtonModel | JButton, JToggleButton, JCheckBox, JRadioButton, JMenu, JMenuItem, JCheckBoxMenuItem, JRadioButtonMenuItem
Document | JTextField, JPasswordField, JTextArea, JEditorPane, JTextPane
BoundedRangeModel | JProgressBar, JScrollBar, JSlider
SingleSelectionModel | JMenuBar, JPopupMenu, JTabbedPane
TableModel | JTable
TableColumnModel | JTable
TreeModel | JTree
TreeSelectionModel | JTree
### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de