<<
Guido Krger
Handbuch der
JavaProgrammierung
3. Auflage
HTML-Ausgabe 3.0 19982002 Guido Krger
Addison-Wesley, 2002, ISBN 3-82731949-8
Homepage: www.javabuch.de
Autor:
www.gkrueger.com
hjp3@gkrueger.com
Titel
<<
<
>
>>
API
Inhaltsverzeichnis
0
1
Vorwort
Tabellen
1 Was ist Java?
2 4 Datentypen
7 OOP I:
3
Grundlagen
11 Strings
15 Collections II
4
19 Byte-Streams
23 Grafikausgabe
27 Fenster
5
31 GUI-Dialoge
35 Swing:
6 Grundlagen
Versionen
Listings
2
Schnelleinstieg
5 Ausdrcke
8 OOP II:
Vererbung, ...
12 Exceptions
16 UtilityKlassen I
20 RandomAccess-I/O
24 Textausgabe
28 EventHandling
32 AWTDialogelemente
6 Anweisungen
9 OOP III: Interfaces 10 OOP IV: Diverses
13 Progr.14 Collections I
Strukturierung
17 Utility-Klassen II 18 CharacterStreams
21
22 Multithreading
Dateien/Verzeichnisse
25 Farben
26 Drucken
29 Low-Level-Events 30 Mens
33 Eigene
Dialogelemente
34
Bitmaps/Animationen
36 Swing:
37 Swing: Kompon. I 38 Swing: Kompon.
Container/Mens
II
40 Applets II
7 39 Applets I
41 Serialisierung
42 JDBC
46 RMI
8 45
Netzwerkprogramm.
49 Performance9 Tuning
Inhaltsverzeichnis
Abbildungen
Icons
3 Wie geht es weiter?
50
Hilfsprogramme
43 Reflection
44 Beans
47
48 Sound
Sicherheit/Kryptogr.
<
>
>>
Suchen
Hier steht das SuchApplet
Anleitung
<
>
>>
<
>
>>
<
>
>>
<
>
>>
Vorwort
Das Handbuch der Java-Programmierung ist der Nachfolger von Go To Java 2
und seiner im Sptsommer 2000 erschienenen zweiten Auflage. Somit verlt das
Buch die GoTo-Reihe, in die es, vor allem auf Grund des erneut gestiegenen
Umfangs, nicht mehr recht hineinpate. Dennoch ist das Handbuch der JavaProgrammierung nicht mehr und nicht weniger als die konsequente Fortfhrung
seiner erfolgreichen Vorgnger, die bis auf "Java 1.1 lernen" und "Symantec Visual
Cafe" zurckgefhrt werden knnen. Um diese Kontinuitt deutlich zu machen, haben
wir die Numerierung der Auflagen beibehalten und der aktuellen Auflage die
Nummer 3.0 zugeordnet.
Untersttzt durch die groe Zahl an Leserzuschriften und die Diskussion mit
Kollegen, Freunden und anderen Java-Enthusiasten wurde das Buch mit vielen
Erweiterungen und Ergnzungen versehen. Alle fr Java-Einsteiger und
Fortgeschrittene wichtigen Themen werden ausfhrlich behandelt. Der bewhrte
Aufbau wurde beibehalten, und das Buch kann sowohl als Lehr- wie auch als
Nachschlagewerk eingesetzt werden.
Das Handbuch der Java-Programmierung besteht aus 50 Kapiteln, die alle
wesentlichen Aspekte der Programmiersprache Java und seiner umfangreichen
Klassenbibliothek erlutern. Mit ber 170 Abbildungen, 80 Tabellen, 440
Beispielprogrammen und 600 Querverweisen ist es fr die Verwendung im Unterricht
und zum Selbststudium bestens geeignet.
Gegenber der zweiten Auflage wurden folgende Abschnitte neu aufgenommen:
Zudem wurde das Buch an die Version 1.4 des JDK angepat und viele kleine Fehler
aus der vorigen Auflage korrigiert. Die Linkliste wurde ebenso angepat wie die JavaHistorie, die Beschreibung der Standardpakete oder die Syntax der JDK-Werkzeuge.
Fr Anfnger wurden die Kapitel 2 und 3 erneut erweitert, es gibt detaillierte
Erklrungen zum Aufruf von Java-Programmen unter Windows, und Abschnitt 2.3.7
beschreibt hufig gemachte Fehler und wie man sie umgeht. Weitere Verbesserungen
gab es bei den Abschnitten ber die Swing-Komponenten, die jetzt auch die neuen 1.4Komponenten JFormattedTextField und JSpinner sowie animierte
Fortschrittsanzeigen umfassen und auf das neue Focus-Subsystem eingehen. Der
JDBC-Teil wurde um Hinweise zur Konfiguration von MS Access, InstantDB und
HSQLDB erweitert, und der ExperimentalWebServer beherrscht jetzt das
HEAD-Kommando und eignet sich fr den Betrieb von Java WebStart. Nicht zuletzt
gab es Verbesserungen bei der HTML-Ausgabe, die jetzt noch umfangreicher und
leichter zu bedienen ist.
Gegenber der ersten Auflage wurden in der zweiten die einleitenden Kapitel
vereinfacht, um Anfngern den Einstieg zu erleichtern. Zudem wurden
weiterfhrende Themen aufgenommen, um auch dem fortgeschrittenen Leser
gengend Lesestoff zu bieten.
Die wichtigsten nderungen der zweiten Auflage waren:
Die ersten Schritte werden ausfhrlicher erklrt, und das fr viele Anfnger zu
schwierige Kapitel 2 wurde entfernt
Es gibt eine Einfhrung in die objektorientierte Programmierung sowie ein
Kapitel ber objektorientiertes Design und Design-Patterns
Bei vielen Themenkomplexen werden in einer Einleitung zunchst die
wichtigsten fachlichen Grundlagen vermittelt, bevor auf die Umsetzung in
Java eingegangen wird (Objektorientierte Programmierung,
Netzwerkprogrammierung, SQL, Kryptographie etc.)
Viele neue Kapitel oder Abschnitte sind hinzugekommen, beispielsweise
Java Beans (Kapitel 44)
Sicherheit und Kryptographie (Kapitel 47)
Remote Methode Invocation (Kapitel 46)
Byte-Streams (Kapitel 19)
Beliebig genaue Arithmetik (Abschnitt 17.3)
Internationalisierung und Ressourcen-Management (Abschnitt 17.4)
Drucken und Zugriff auf serielle und parallele Schnittstelle (Kapitel 26)
Fortgeschrittene Applet-Programmierung (Kapitel 40)
Zudem gibt es eine komplette Einfhrung in die Swing-Programmierung, die
folgende Themen behandelt:
Grundlagen und Abgrenzung zwischen Swing und AWT (Kapitel 35)
Swing-Container und Mens (Kapitel 36)
Alle elementaren Swing-Komponenten (Kapitel 37)
Komplexe Komponenten und Panels, Tables und Trees (Kapitel 38)
Ebenso wie zu den Vorgngerversionen wurde auch zu diesem Buch eine HTMLAusgabe erstellt. Sie ist auf der beigefgten CD-ROM enthalten und stellt das
komplette Buch im Hypertext-Format dar. Mit ihren Navigationshilfen und der
groen Zahl an Querverweisen (es sind inkl. Index ber 20000) ist sie ausgezeichnet
als Referenz verwendbar. Daneben enthlt die CD-ROM die Beispiele aus dem Buch
sowie das Java Development Kit und weitere ntzliche Werkzeuge und Hilfsmittel.
Wie bisher kann die HTML-Ausgabe frei aus dem Internet geladen werden. Studenten
und Leser mit eingeschrnkten finanziellen Mglichkeiten knnen so Java lernen,
ohne das Buch kaufen zu mssen, oder knnen es vor dem Kauf eingehend studieren.
Auch Universitten und vergleichbare Einrichtungen werden die Mglichkeit zur
Installation einer gespiegelten Version erhalten, um das Buch effizient in der JavaAusbildung nutzen zu knnen.
Um weitere Informationen zum Handbuch der Java-Programmierung zu erhalten,
knnen Sie seine Homepage unter http://www.javabuch.de besuchen. Dort knnen Sie
auch die freie HTML-Ausgabe herunterladen, und Sie finden eine Liste aller
bekannten Fehler und Ungenauigkeiten. Teilen Sie mir Ihre Kritik und Anregungen
mit, oder schreiben Sie mir, wenn Sie Fehler gefunden haben. Natrlich knnen Sie
auch schreiben, da Ihnen das Buch gefallen hat! Verstndnisfragen zu einzelnen
Aspekten der Java-Programmierung kann ich aus Zeitgrnden leider nicht mehr
beantworten. Sie sind besser in einer der zahlreichen Java-Newsgroups aufgehoben
(siehe Abschnitt 3.2.2).
Wie die Vorversionen wurde auch die dritte Auflage vollstndig in SGML
geschrieben (der Mutter von HTML und XML). Alle Werkzeuge zum Erstellen der
verschiedenen Ausgaben wurden vom Autor selbst entwickelt und sind in Java
geschrieben. Die ohne zustzlichen Aufwand erstellbare HTML-Ausgabe kann bei
Fehlern oder Erweiterungen sehr schnell aktualisiert und unabhngig von den
Nachdruckzyklen der Papierversion gepflegt werden. Alle nderungen werden
versioniert, der Erstdruck des Buchs entspricht der HTML-Ausgabe 3.0.
Ich wnsche allen Lesern, da ihnen dieses Buch beim Erlernen und Anwenden von
Java ein unentbehrlicher Helfer sein wird und da sie nach seiner Lektre ber
umfassende Kenntnisse in der Java-Programmierung verfgen mgen.
Mein Dank gilt allen, die bei der Entstehung mitgewirkt haben. Besonders mchte ich
Kollegen und Bekannten danken, die sich der Mhe unterzogen haben, einzelne
Kapitel zu lesen, und mit ihren Hinweisen und Anregungen zu seiner jetzigen Form
beigetragen haben. Hier sind vor allem Ilona Brinkmeier, Holger Jdicke, Boris
Gruschko, Thomas Backens, Goetz Perry, Stefan Stark, Andi Mller, Jacques Nietsch
und Carsten Leutzinger zu nennen. Den vielen Lesern der Vorversionen, die Fehler
gefunden oder Anregungen gegeben haben, mchte ich ebenso danken wie Christiane
Auf und Christina Gibbs, die das Buch als Lektorinnen bei Addison-Wesley betreut
haben.
Wie immer geht ein besonderer Dank an Sabine, Jana und Jasmin, ohne deren
Untersttzung und Geduld auch dieses Buch nicht mglich gewesen wre.
Guido Krger, Februar 2002
<
>
>>
45.2 Standard-Port-Nummern
45.3 Liste wichtiger RFCs
47.1 Wichtige Permission-Klassen
49.1 Geschwindigkeit von Methodenaufrufen
49.2 Parameter von hprof
50.1 Optionen von javac
50.2 Optionen des Java-Interpreters
50.3 Optionen von appletviewer
50.4 Kommandos von jdb
50.5 Markierungen in Dokumentationskommentaren
50.6 Einige Optionen von javadoc
50.7 Kommandos von jar
50.8 Optionen von javap
50.9 Optionen von serialver
50.10 Optionen von jarsigner
50.11 Optionen von rmic
<
>
>>
<
>
>>
Tip
Warnung
<
>
>>
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 1
Was ist Java?
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 2
Schnelleinstieg
2 Schnelleinstieg
2.1 Installation des JDK
2.1.1 Hardware-Voraussetzungen
2.1.2 Installation
Installation des JDK
Installation der Dokumentation
Installation der Quelltexte
Deinstallation
2.2 Erste Gehversuche
2.2.1 Quelltext erstellen, bersetzen
und ausfhren
1. Vorbereitung
2. Erstellen des Quelltextes
3. bersetzen des Quelltextes
4. Ausfhren des erzeugten
Programms
5. Beenden des Programms
2.2.2 Die Beispielprogramme
Starten der Beispielprogramme
Zustzlich erforderliche Dateien
2.3 Tips fr eigene Experimente
2.3.1 Der Entwicklungszyklus in
Kurzform
2.3.2 Einfache Ausgaben
2.3.3 Einfache Eingaben
2.3.4 Formatierung der Quelltexte
2.3.5 Namenskonventionen
2.3.6 Aufruf von Java-Programmen
unter Windows
Erstellen einer Batchdatei
Erstellen einer Verknpfung auf
dem Desktop
Verwenden von javaw anstelle
von java
2.3.7 Troubleshooting
Was ist eine DOS-Box und wie
startet man sie?
java luft, javac aber nicht
Was sind eigentlich
Umgebungsvariablen?
Der Compiler javac arbeitet
nicht
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 3
Wie geht es weiter?
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 4
Datentypen
4 Datentypen
4.1 Lexikalische Elemente eines JavaProgramms
4.1.1 Eingabezeichen
4.1.2 Kommentare
4.1.3 Bezeichner
4.1.4 Weitere Unterschiede zu C
4.2 Primitive Datentypen
4.2.1 Der logische Typ
Literale
4.2.2 Der Zeichentyp
Literale
4.2.3 Die integralen Typen
Literale
4.2.4 Die Fliekommazahlen
Literale
4.3 Variablen
4.3.1 Grundeigenschaften
4.3.2 Deklaration von Variablen
4.3.3 Lebensdauer/Sichtbarkeit
4.4 Arrays
4.4.1 Deklaration und
Initialisierung
4.4.2 Zugriff auf ArrayElemente
4.4.3 Mehrdimensionale Arrays
4.5 Referenztypen
4.5.1 Beschreibung
4.5.2 Speichermanagement
4.6 Typkonvertierungen
4.6.1 Standardkonvertierungen
4.6.2 Vorzeichenlose Bytes
4.7 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 5
Ausdrcke
5 Ausdrcke
5.1 Eigenschaften von Ausdrcken
5.2 Arithmetische Operatoren
5.3 Relationale Operatoren
5.4 Logische Operatoren
5.5 Bitweise Operatoren
5.6 Zuweisungsoperatoren
5.7 Sonstige Operatoren
5.7.1 Weitere Operatoren fr primitive
Typen
Fragezeichenoperator
Type-Cast-Operator
5.7.2 Operatoren fr Objekte
String-Verkettung
Referenzgleichheit und ungleichheit
Der instanceof-Operator
Der new-Operator
Member-Zugriff
Methodenaufruf
Zugriff auf Array-Elemente
5.7.3 Welche Operatoren es nicht gibt
5.8 Operator-Vorrangregeln
5.9 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 6
Anweisungen
6 Anweisungen
6.1 Elementare Anweisungen
6.1.1 Die leere Anweisung
Syntax
Bedeutung
6.1.2 Der Block
Syntax
Bedeutung
6.1.3 Variablendeklarationen
Syntax
Bedeutung
6.1.4 Ausdrucksanweisungen
Syntax
Bedeutung
6.2 Verzweigungen
6.2.1 Die if-Anweisung
Syntax
Bedeutung
Dangling else
Bedingtes Kompilieren
6.2.2 Die switch-Anweisung
Syntax
Bedeutung
6.3 Schleifen
6.3.1 Die while-Schleife
Syntax
Bedeutung
6.3.2 Die do-Schleife
Syntax
Bedeutung
6.3.3 Die for-Schleife
Syntax
Bedeutung
break und continue
6.4 Sonstige Anweisungen
6.4.1 Die assert-Anweisung
Syntax
Bedeutung
An- und Abschalten der
Assertions
Anwendungen
Nebeneffekte
Kompatibilitt
6.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 7
OOP I: Grundlagen
7 OOP I: Grundlagen
7.1 Konzepte objektorientierter
Programmiersprachen
7.1.1 Einfhrung
7.1.2 Abstraktion
7.1.3 Kapselung
7.1.4 Wiederverwendung
7.1.5 Beziehungen
Generalisierung und Spezialisierung
Aggregation und Komposition
Verwendungs- und
Aufrufbeziehungen
7.1.6 Polymorphismus
7.1.7 Fazit
7.2 Klassen und Objekte in Java
7.2.1 Klassen
7.2.2 Objekte
7.3 Methoden
7.3.1 Definition
7.3.2 Aufruf
7.3.3 Parameter
7.3.4 Rckgabewert
7.3.5 berladen von Methoden
Die Signatur einer Methode
7.3.6 Konstruktoren
Default-Konstruktoren
Verkettung von Konstruktoren
Initialisierungsreihenfolge
7.3.7 Destruktoren
7.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Kapitel 8
OOP II: Vererbung, Polymorphismus und statische Elemente
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 9
OOP III: Interfaces
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 10
OOP IV: Verschiedenes
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 11
Strings
11 Strings
11.1 Grundlegende Eigenschaften
11.2 Methoden der Klasse String
11.2.1 Konstruktoren
11.2.2 Zeichenextraktion
11.2.3 Die Lnge der
Zeichenkette
11.2.4 Vergleichen von
Zeichenketten
11.2.5 Suchen in Zeichenketten
11.2.6 Ersetzen von
Zeichenketten
11.2.7 Konvertierungsfunktionen
11.3 Weitere Eigenschaften
11.3.1 Die Klasse String ist final
11.3.2 Was ist ein String fr den
Compiler?
String-Literale
String-Verkettung und Zuweisung
11.3.3 String-Objekte sind nicht
dynamisch
11.4 Die Klasse StringBuffer
11.4.1 Konstruktoren
11.4.2 Einfgen von Elementen
11.4.3 Lschen von Elementen
11.4.4 Verndern von Elementen
11.4.5 Lngeninformationen
11.4.6 Konvertierung in einen
String
11.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 12
Exceptions
12 Exceptions
12.1 Grundlagen und Begriffe
12.2 Behandlung von Exceptions
12.2.1 Die try-catch-Anweisung
12.2.2 Das Fehlerobjekt
12.2.3 Die Fehlerklassen von Java
12.2.4 Fortfahren nach Fehlern
12.2.5 Mehr als eine catch-Klausel
12.2.6 Die finally-Klausel
12.3 Weitergabe von Exceptions
12.3.1 Die catch-or-throw-Regel
12.3.2 Weitergabe einer Exception
Die Klasse
RuntimeException
12.3.3 Auslsen von Ausnahmen
12.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 13
Strukturierung von Java-Programmen
Archivs
Ausfhrbare jar-Archive
13.4.2 Einbinden von
Ressourcen-Dateien
13.5 Java Web Start
13.5.1 Einleitung und
Funktionsweise
13.5.2 Erstellen einer WebStartApplikation
Erzeugen der jar-Dateien
Anlegen der
Deskriptordatei
Die Anwendung auf dem
Web-Server installieren
Starten der Anwendung
13.5.3 Das jnlp-API
Services
Ein einfaches Beispiel
13.6 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 14
Collections I
14 Collections I
14.1 Grundlagen und Konzepte
14.2 Die Klasse Vector
14.2.1 Einfgen von
Elementen
14.2.2 Zugriff auf
Elemente
14.2.3 Der Vektor als
Iterator
14.3 Die Klasse Stack
14.4 Die Klasse Hashtable
14.4.1 Einfgen von
Elementen
14.4.2 Zugriff auf
Elemente
14.4.3 Hashtable als
Iterator
14.4.4 Die Klasse
Properties
14.5 Die Klasse BitSet
14.5.1 Elementweise
Operationen
14.5.2 Mengenorientierte
Operationen
14.6 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 15
Collections II
15 Collections II
15.1 Grundlagen und Konzepte
15.2 Die Collection des Typs List
15.2.1 Abstrakte
Eigenschaften
15.2.2 Implementierungen
15.3 Iteratoren
15.3.1 Das Interface
Iterator
15.3.2 Das Interface
ListIterator
15.4 Eine eigene Queue-Klasse
15.4.1 Anforderungen
15.4.2 Implementierung
15.5 Die Collection des Typs Set
15.5.1 Abstrakte
Eigenschaften
15.5.2 Implementierungen
15.6 Die Collection des Typs
Map
15.6.1 Abstrakte
Eigenschaften
15.6.2 Implementierungen
15.7 Sortierte Collections
15.7.1 Comparable und
Comparator
15.7.2 SortedSet und
TreeSet
15.7.3 SortedMap und
TreeMap
15.8 Die Klasse Collections
15.8.1 Sortieren und
Suchen
15.8.2 Synchronisieren
von Collections
15.8.3 Erzeugen
unvernderlicher
Collections
15.9 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 16
Utility-Klassen I
16 Utility-Klassen I
16.1 Die Klasse Random
16.1.1 Initialisierung des
Zufallszahlengenerators
16.1.2 Erzeugen von
Zufallszahlen
Gleichverteilte
Zufallszahlen
Normalverteilte
Zufallszahlen
16.2 Die Klassen Date, Calendar und
GregorianCalendar
16.2.1 Konstruktoren
16.2.2 Abfragen und Setzen von
Datumsbestandteilen
16.2.3 Vergleiche und Datums/Zeitarithmetik
16.2.4 Umwandlung zwischen
Date und Calendar
16.3 Die Klasse System
16.3.1 System-Properties
16.3.2 in, err und out
16.3.3 exit
16.3.4 gc
16.3.5 currentTimeMillis
16.3.6 arraycopy
16.4 Die Klasse RunTime
16.4.1 Grundlagen
16.4.2 Interaktion mit dem
externen Programm
16.5 Die Klasse Arrays
16.6 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 17
Utility-Klassen II
17 Utility-Klassen II
17.1 Die Klasse StringTokenizer
17.1.1 Anlegen eines StringTokenizers
17.1.2 Zugriff auf Tokens
17.2 Die Klasse Math
17.2.1 Winkelfunktionen
17.2.2 Minimum und Maximum
17.2.3 Arithmetik
17.2.4 Runden und Abschneiden
17.3 Die Klassen BigInteger und BigDecimal
17.3.1 Die Klasse BigInteger
17.3.2 Die Klasse BigDecimal
17.4 Internationalisierung und Lokalisierung
17.4.1 Die Klasse Locale
17.4.2 Zahlen formatieren
17.4.3 Datum und Uhrzeit formatieren
17.4.4 Laden von Ressourcen
Die Methode getBundle
Eigene Ressourcenklassen
erstellen
Die Verkettung von
ResourceBundles
Die Klasse
PropertyResourceBundle
17.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 18
Character-Streams
18 Character-Streams
18.1 Allgemeine Konzepte
18.2 Ausgabe-Streams
18.2.1 Die abstrakte Klasse Writer
18.2.2 Auswahl des Ausgabegertes
OutputStreamWriter und
FileWriter
StringWriter und
CharArrayWriter
18.2.3 Schachteln von AusgabeStreams
BufferedWriter
PrintWriter
FilterWriter
18.3 Eingabe-Streams
18.3.1 Die abstrakte Klasse Reader
18.3.2 Auswahl des Eingabegertes
InputStreamReader und
FileReader
StringReader und
CharArrayReader
18.3.3 Schachteln von EingabeStreams
BufferedReader
LineNumberReader
FilterReader und
PushbackReader
18.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 19
Byte-Streams
19 Byte-Streams
19.1 Architektur und Vergleich mit CharacterStreams
19.2 Ausgabe-Streams
19.2.1 Die Basisklasse OutputStream
19.2.2 Aus OutputStream direkt
abgeleitete Klassen
FileOutputStream
ByteArrayOutputStream
ObjectOutputStream
PipedOutputStream
19.2.3 Aus FilterOutputStream
abgeleitete Klassen
BufferedOutputStream
PrintStream
DataOutput und
DataOutputStream
Komprimieren von Dateien
Berechnung von Prfsummen
19.3 Eingabe-Streams
19.3.1 Die Basisklasse InputStream
19.3.2 Aus InputStream direkt abgeleitete
Klassen
FileInputStream
ByteArrayInputStream
ObjectInputStream
SequenceInputStream
PipedInputStream
19.3.3 Aus FilterInputStream abgeleitete
Klassen
BufferedInputStream
PushbackInputStream
DataInputStream und DataInput
CheckedInputStream
Entpacken von Dateien
19.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 20
Random-Access-I/O
20 Random-Access-I/O
20.1 Grundlegende
Operationen
20.2 Navigation in der Datei
20.2.1 Positionierung
des Dateizeigers
20.2.2 Die Lnge der
Datei
20.3 Lesezugriffe
20.4 Schreibzugriffe
20.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 21
Datei- und Verzeichnis-Handling
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 22
Multithreading
22 Multithreading
22.1 Grundlagen und Begriffe
22.2 Die Klasse Thread
22.2.1 Erzeugen eines neuen
Threads
22.2.2 Abbrechen eines Threads
22.2.3 Anhalten eines Threads
22.2.4 Weitere Methoden
sleep
isAlive
join
22.3 Das Interface Runnable
22.3.1 Implementieren von
Runnable
22.3.2 Multithreading durch
Wrapper-Klassen
22.4 Synchronisation
22.4.1 Synchronisationsprobleme
22.4.2 Monitore
Anwendung von
synchronized auf einen
Block von Anweisungen
Anwendung von
synchronized auf eine
Methode
22.4.3 wait und notify
22.4.4 PipedInputStream und
PipedOutputStream
22.5 Verwalten von Threads
22.5.1 Prioritt und Name
22.5.2 Thread-Gruppen
22.6 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 23
Grafikausgabe
23 Grafikausgabe
23.1 Das Abstract Windowing
Toolkit
23.1.1 Grundlegende
Eigenschaften
23.1.2 Von AWT nach
Swing
nderungen mit dem
JDK 1.1
Swing
23.2 Grundlagen der Grafikausgabe
23.2.1 Anlegen eines
Fensters
23.2.2 Die Methode paint
23.2.3 Das grafische
Koordinatensystem
23.2.4 Schlieen eines
Fensters
23.3 Elementare Grafikroutinen
23.3.1 Linie
23.3.2 Rechteck
23.3.3 Polygon
23.3.4 Kreis
23.3.5 Kreisbogen
23.4 Weiterfhrende Funktionen
23.4.1 Linien- oder
Fllmodus
23.4.2 Kopieren und Lschen
von Flchen
23.4.3 Die Clipping-Region
23.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 24
Textausgabe
24 Textausgabe
24.1 Ausgabefunktionen
24.2 Unterschiedliche Schriftarten
24.2.1 Font-Objekte
24.2.2 Standardschriftarten
24.3 Eigenschaften von
Schriftarten
24.3.1 Font-Informationen
24.3.2 Font-Metriken
24.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 25
Farben
25 Farben
25.1 Das JavaFarbmodell
25.2 Erzeugen von
Farben
25.3 Verwenden von
Farben
25.4 Systemfarben
25.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 26
Drucken
26 Drucken
26.1 Einleitung
26.2 Drucken mit dem JDK 1.1
26.2.1 Grundlagen
26.2.2 Seitenweise Ausgabe
26.2.3 Plazierung des Codes zur
Druckausgabe
26.3 Drucken seit dem JDK 1.2
26.3.1 berblick
26.3.2 Zusammenspiel der Klassen
Die Klasse PrinterJob
Die Klassen Paper und
PageFormat
Die Konfigurationsdialoge
Das Interface Printable
Das Interface Pageable und die
Klasse Book
26.3.3 Ausdrucken einer Textdatei
Die Hilfsklasse FilePrintHelper
Die Klasse SimpleFilePrinter
26.4 Zugriff auf serielle und parallele
Schnittstellen
26.4.1 Das Java Communications API
Installation
Prinzipielle Arbeitsweise
26.4.2 Ein einfaches Beispielprogramm
26.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
DOC
API
Kapitel 27
Fenster
Titel
<<
27 Fenster
27.1 Die verschiedenen
Fensterklassen
27.2 Aufrufen und Schlieen
eines Fensters
27.3 Visuelle Eigenschaften
27.4 Anzeigezustand
27.5 Fensterelemente
27.5.1 Der Fenstertitel
27.5.2 Das Icon des
Fensters
27.5.3 Der Mauscursor
27.5.4 Die Vorder- und
Hintergrundfarbe
27.5.5 Der StandardFont
27.6 Zusammenfassung
>
>>
DOC
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 28
Event-Handling
28 Event-Handling
28.1 Das Event-Handling im JDK 1.1
28.1.1 Grundlagen
28.1.2 Ereignistypen
28.1.3 Ereignisempfnger
28.1.4 Ereignisquellen
28.1.5 Adapterklassen
28.1.6 Zusammenfassung
Focus-Ereignisse
Key-Ereignisse
Mouse-Ereignisse
MouseMotionEreignisse
Component-Ereignisse
Container-Ereignisse
Window-Ereignisse
Action-Ereignisse
Adjustment-Ereignisse
Item-Ereignisse
Text-Ereignisse
28.2 Entwurfsmuster fr den
Nachrichtenverkehr
28.2.1 Variante 1:
Implementierung eines
EventListener-Interfaces
28.2.2 Variante 2: Lokale und
anonyme Klassen
Lokale Klassen
Anonyme Klassen
28.2.3 Variante 3: Trennung
von GUI- und
Anwendungscode
28.2.4 Variante 4: berlagern
der Event-Handler in den
Komponenten
28.2.5 Ausblick
28.3 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 29
Low-Level-Events
29 Low-Level-Events
29.1 Window-Events
29.2 ComponentEvents
29.3 Mouse-Events
29.4 MouseMotionEvents
29.5 Focus-Events
29.6 Key-Events
29.7 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 30
Mens
30 Mens
30.1 Grundlagen
30.2 Menleiste
30.3 Mens
30.4 Meneintrge
30.4.1 Einfache
Meneintrge
30.4.2 CheckboxMenuItem
30.4.3 Beschleunigertasten
30.4.4 Untermens
30.5 Action-Events
30.6 Kontextmens
30.7 Datenaustausch mit der
Zwischenablage
30.7.1 berblick
30.7.2 Kommunikation mit
der Zwischenablage
30.8 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 31
GUI-Dialoge
31 GUI-Dialoge
31.1 Erstellen eines Dialogs
31.1.1 Anlegen eines
Dialogfensters
31.1.2 Zuordnen eines
Layoutmanagers
31.1.3 Einfgen von
Dialogelementen
31.1.4 Anzeigen des
Dialogfensters
31.2 Die Layoutmanager
31.2.1 FlowLayout
31.2.2 GridLayout
Die Gre der
Komponenten
31.2.3 BorderLayout
31.2.4 GridBagLayout
31.2.5 NULL-Layout
31.2.6 Schachteln von
Layoutmanagern
31.3 Modale Dialoge
31.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 32
AWT-Dialogelemente
32 AWT-Dialogelemente
32.1 Rahmenprogramm
32.2 Label
32.3 Button
32.4 Checkbox
32.5 CheckboxGroup
32.6 TextField
32.7 TextArea
32.8 Choice
32.9 List
32.10 Scrollbar
32.11 ScrollPane
32.12
Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 33
Eigene Dialogelemente
33 Eigene Dialogelemente
33.1 Die Klasse Canvas
33.2 Entwicklung einer 7-SegmentAnzeige
33.2.1 Anforderungen
33.2.2 Bildschirmanzeige
33.2.3 Ereignisbehandlung
33.3 Einbinden der Komponente
33.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 34
Bitmaps und Animationen
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 35
Swing: Grundlagen
35 Swing: Grundlagen
35.1 Eigenschaften und Architektur von
Swing
35.1.1 Einleitung
35.1.2 Eigenschaften von Swing
Leichtgewichtige
Komponenten
Pluggable Look-and-Feel
Das Model-ViewController-Prinzip
Aber...
35.1.3 Wie geht es weiter?
35.2 Ein einfhrendes Beispiel
35.2.1 Das Beispielprogramm
35.2.2 Beschreibung des
Beispielprogramms
Die import-Anweisungen
JFrame
JPanel
JLabel
JTextField
Tooltips und
Umrandungen
JList und JScrollPane
JButton
Umschalten des Look-andFeel
35.3 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 36
Swing: Container und Mens
Registrieren von
Tastaturkommandos
36.3.2 JPanel und JLayeredPane
JPanel
JLayeredPane
36.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 37
Swing: Komponenten I
37 Swing: Komponenten I
37.1 Label und Textfelder
37.1.1 JLabel
37.1.2 JTextField
37.1.3 JPasswordField
37.1.4 JTextArea
37.1.5 JSpinner
37.2 Buttons
37.2.1 JButton
37.2.2 JCheckBox
37.2.3 JRadioButton
37.3 Listen und Comboboxen
37.3.1 JList
Selektieren von
Elementen
Den Listeninhalt
dynamisch verndern
Beispiel
37.3.2 JComboBox
37.4 Quasi-analoge Komponenten
37.4.1 JScrollBar
37.4.2 JSlider
37.4.3 JProgressBar
37.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 38
Swing: Komponenten II
38 Swing: Komponenten II
38.1 Spezielle Panels
38.1.1 JScrollPane
38.1.2 JSplitPane
38.1.3 JTabbedPane
38.2 JTable
38.2.1 Erzeugen von Tabellen
38.2.2 Konfiguration der Tabelle
38.2.3 Selektieren von Elementen
Selektionsmodi
Abfragen der Selektion
Verndern der Selektion
38.2.4 Zugriff auf den Inhalt der
Tabelle
Die Daten in der Tabelle
Editieren von
Tabellenelementen
38.2.5 Das Tabellenmodell
Beispiel
38.2.6 Das Spaltenmodell
38.2.7 Rendering der Zellen
38.2.8 Reaktion auf Ereignisse
38.3 JTree
38.3.1 Erzeugen eines Baums
38.3.2 Selektieren von Knoten
Konfiguration der
Selektionsmglichkeit
Abfragen der Selektion
Verndern der Selektion
38.3.3 ffnen und Schlieen der
Knoten
38.3.4 Verndern der Baumstruktur
38.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 39
Applets I
39 Applets I
39.1 Die Architektur eines Applets
39.1.1 Grundlagen
39.1.2 Die Klasse java.awt.Applet
39.1.3 Initialisierung und
Endebehandlung
Instanzierung des Applets
Initialisierung des Applets
Starten des Applets
Stoppen des Applets
Zerstren des Applets
39.1.4 Weitere Methoden der Klasse
Applet
Methoden zum
Nachrichtentransfer
showStatus
getParameterInfo
getAppletInfo
39.2 Einbinden eines Applets
39.2.1 Das APPLET-Tag
39.2.2 Die Parameter des AppletTags
39.2.3 Parameterbergabe an
Applets
39.3 Die Ausgabe von Sound
39.3.1 Soundausgabe in Applets
39.3.2 Soundausgabe in
Applikationen
39.4 Animation in Applets
39.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 40
Applets II
40 Applets II
40.1 Verweise auf andere Seiten
40.1.1 Die Klasse URL
40.1.2 Der Applet-Kontext
40.1.3 Die Methode
showDocument
40.2 Kommunikation zwischen
Applets
40.3 Umwandlung einer Applikation
in ein Applet
40.3.1 Die BeispielApplikation
40.3.2 Variante 1: Das
Programm als Popup-Fenster
40.3.3 Variante 2: Erstellen
eines gleichwertigen Applets
40.4 Das Java-Plugin
40.4.1 Funktionsweise
40.4.2 Verwendung des Plugins
Installation
Konvertierung der
HTML-Seiten
40.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
Kapitel 41
Serialisierung
Titel
<<
41 Serialisierung
41.1 Grundlagen
41.1.1 Begriffsbestimmung
41.1.2 Schreiben von
Objekten
41.1.3 Lesen von Objekten
41.2 Weitere Aspekte der
Serialisierung
41.2.1 Versionierung
41.2.2 Nicht-serialisierte
Membervariablen
41.2.3 Objektreferenzen
41.2.4 Serialisieren von
Collections
41.3 Anwendungen
41.3.1 Ein einfacher
Objektspeicher
41.3.2 Kopieren von
Objekten
41.4 Zusammenfassung
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 42
Datenbankzugriffe mit JDBC
42.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
DOC
API
Kapitel 43
Reflection
Titel
<<
43 Reflection
43.1 Einleitung
43.2 Die Klassen Object und
Class
43.2.1 Die Klasse
Object
43.2.2 Die Klasse
Class
43.3 Methoden- und
Konstruktorenaufrufe
43.3.1 Parameterlose
Methoden
43.3.2 Parametrisierte
Methoden
43.3.3 Parametrisierte
Konstruktoren
43.4 Zugriff auf
Membervariablen
43.5 Arrays
43.5.1 Erzeugen von
Arrays
43.5.2 Zugriff auf
Array-Elemente
43.6 Zusammenfassung
>
>>
DOC
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 44
Beans
44 Beans
44.1 Grundlagen und Begriffe
44.2 Entwurf einer einfachen Bean
44.2.1 Grundstzliche Architektur
44.2.2 Grafische Darstellung
44.2.3 Eigenschaften
Objekte als Eigenschaften
Indizierte Eigenschaften
44.2.4 Implementierung
44.2.5 Verwendung der Bean
44.3 Die Beanbox
44.3.1 Beschreibung und Installation
Installation des BDK
Die Aufrufscripte
44.3.2 Grundlagen der Bedienung
Bedienelemente
Einfgen und Modifizieren von
Beans
Events
44.3.3 Integration eigener Beans
Entwickeln und bersetzen der
Bean
Erzeugen einer Manifest-Datei
Erzeugen des jar-Archivs
Verwenden der eigenen Bean
44.3.4 Serialisierte Beans
Serialisieren von Beans mit der
Beanbox
Einbinden serialisierter Beans
44.4 Bean-Ereignisse
44.4.1 Bound Properties
44.4.2 Constrained Properties
44.4.3 Anwendungsbeispiel
44.5 Panel-Beans
44.6 BeanInfo-Klassen und Property-Editoren
44.6.1 BeanInfo-Klassen
getIcon
getPropertyDescriptors
getMethodDescriptors
Die Klasse LightBulbBeanInfo
44.6.2 Property-Editoren
LightBulbLightOnEditor1
LightBulbLightOnEditor2
LightBulbLightOnEditor3
44.7 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 45
Netzwerkprogrammierung
45 Netzwerkprogrammierung
45.1 Grundlagen der
Netzwerkprogrammierung
45.1.1 Was ist ein
Netzwerk?
45.1.2 Protokolle
45.1.3 Adressierung von
Daten
IP-Adressen
Domain-Namen
45.1.4 Ports und
Applikationen
45.1.5 Request for
Comments
45.1.6 Firewalls und
Proxys
45.2 Client-Sockets
45.2.1 Adressierung
45.2.2 Aufbau einer
einfachen SocketVerbindung
45.2.3 Lesen und
Schreiben von Daten
45.2.4 Zugriff auf einen
Web-Server
45.3 Server-Sockets
45.3.1 Die Klasse
ServerSocket
45.3.2 Verbindungen zu
mehreren Clients
45.3.3 Entwicklung eines
einfachen Web-Servers
45.4 Daten mit Hilfe der Klasse
URL lesen
45.5 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 46
Remote Method Invocation
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 47
Sicherheit und Kryptographie
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 48
Sound
48 Sound
48.1 Grundlagen und Konzepte
48.2 Gesampelter Sound
48.2.1 Was ist Sampling?
48.2.2 Das Sampling-API
Zugriff auf AudioDateien
Audio-Gerte beschaffen
Die Steuerelemente eines
Audio-Gerts
Der Clip
48.2.3 Abspielen einer SampleDatei
48.3 Midi
48.3.1 Was ist Midi?
48.3.2 Grundlegende Klassen
des Midi-APIs
48.3.3 Alle meine Entchen Erster Versuch
48.3.4 Alle meine Entchen mit
dem Sequenzer
48.3.5 Zugriff auf Midi-Dateien
Lesen und Abspielen
einer Midi-Datei
Abspeichern einer
Sequenz in einer MidiDatei
48.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Kapitel 49
Performance-Tuning
49 Performance-Tuning
49.1 Einleitung
49.2 Tuning-Tips
49.2.1 String und StringBuffer
String-Verkettung
Einfgen und Lschen in
Strings
Die Methode toString der
Klasse StringBuffer
Die Unvernderlichkeit von
String-Objekten
Durchlaufen von
Zeichenketten
49.2.2 Methodenaufrufe
49.2.3 Vektoren und Listen
49.2.4 Dateizugriffe
Schreiben von Streams
Lesen von Streams
RandomAccess-Dateien
49.2.5 Speicher-Optimierung
49.3 Einsatz eines Profilers
49.3.1 Grundlagen
49.3.2 Eine Beispielsitzung mit dem
Profiler
Erzeugen der ProfilingInformationen
Das CPU-Profile
Das Heap-Profile
Die optimierte Version des
Programms
49.3.3 Ausblick
49.4 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Kapitel 50
Hilfsprogramme des JDK
Index
>>
DOC
API
Skeletons
50.12.1 Aufruf
50.12.2 Beschreibung
50.12.3 Optionen
50.13 rmiregistry - Der RMINamensservice
50.13.1 Aufruf
50.13.2 Beschreibung
50.14 Zusammenfassung
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
50.14 Zusammenfassung
50.14 Zusammenfassung
<<
<
>
>>
API
-0-author
-c
-classpath
-client
-cp
-D
-d
-da
-debug
-depend
-deprecation
-disableassertions
-ea
-enableassertions
-g
-help
-J
-jar
-keepgenerated
-keypass
-keystore
-l
-nowarn
-O
-package
-private
-prof
-protected
-public
-s
[50.5.5]
[50.7.3]
[2.3.7.5] [13.4.1.1] [50.1.3] [50.2.3] [50.5.5]
[50.7.3] [50.12.3]
[50.2.2]
[2.3.7.5] [13.4.1.1] [50.2.3]
[50.2.3]
[13.4.1.2] [50.5.5] [50.12.3]
[6.4.1.3]
[50.3.3]
[50.1.3]
[50.1.3]
[6.4.1.3] [50.2.3]
[6.4.1.3]
[6.4.1.3] [50.2.3]
[50.1.3] [50.4.3] [50.12.3]
[50.2.3]
[49.3.2.4]
[13.4.1.3]
[50.12.3]
[50.11.3]
[50.11.3]
[50.7.3]
[50.1.3]
[50.1.3]
[50.5.5] [50.7.3]
[50.5.5] [50.7.3]
[49.3.2.4] [50.2.3]
[50.5.5] [50.7.3]
[50.5.5] [50.7.3]
[50.7.3]
[50.2.2]
[50.8.3]
[6.4.1.3]
[50.5.5]
[50.11.3]
[50.11.3]
[50.1.3]
[50.12.3]
[50.12.3]
[50.12.3]
[50.1.3] [50.2.3] [50.5.5]
[50.2.3]
[50.11.3]
[50.2.3] [50.5.5]
[50.2.2]
[49.3.2.1] [49.3.2.4] [50.2.2]
[50.2.2]
[49.2.5] [50.2.3]
[50.2.3]
[49.3.2.4]
[49.3.2.1] [49.3.2.4]
[13.2.4.1] [13.3.1] [13.3.2.1] [50.1.2] [20.3
(Format)]
.class-Notation fr Klassenobjekte [43.3.2]
.inc-Dateien
[23.3]
.java-Dateien
[2.2.1.2] [2.2.2.1] [13.2.4.1] [50.1.2]
.java.policy
[47.3.4.1]
.keystore
[47.1.6.1]
.TYPE-Objekte
[43.3.1]
[4.1.2]
/*
[4.1.2] [50.5.3]
/**
[4.1.2]
//
100 % Pure Java Initiative
[1.1]
2D-API
[24.1] [35.1.3]
7-Segment-Anzeige
[33.2]
[39.2.1]
<APPLET>
-server
-show
-source 1.4
-sourcepath
-storepass
-storetype
-target
-v1.1
-v1.2
-vcompat
-verbose
-verbosegc
-verify
-version
-Xclassic
-Xint
-Xmixed
-Xms
-Xmx
-Xprof
-Xrunhprof
.class-Dateien
[4.1.2] [50.5.3]
[50.1.3] [50.5.3]
[4.1.2] [50.5.3]
[4.1.2] [50.5.3]
[4.1.2] [50.5.3]
[4.1.2] [50.5.3]
[50.5.3]
[4.1.2] [50.5.3]
[49.3.2.3]
[49.3.2.3]
[40.1.3]
[40.1.3]
[40.1.3]
[40.1.3]
@author
@deprecated
@exception
@param
@return
@see
@since
@version
[C
[I
_blank
_parent
_self
_top
<
>
>>
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-AAbgeleitete Klasse
Abhngigkeiten zwischen den Quelldateien
Ableiten einer Klasse
Ableitungsbume
abs
absbottom
absmiddle
abstract
Abstract Windowing Toolkit
AbstractButton
AbstractList
AbstractMap
AbstractSet
AbstractSpinnerModel
AbstractTableModel
Abstrakte Factory
Abstrakte Klassen und Polymorphismus
Abstraktion
Accelerator-Taste
accept
Accessibility-API
acos
action
Action-Ereignisse
Action-Events
ActionEvent
ActionListener
actionPerformed
ACTION_EVENT_MASK
activeCaption
activeCaptionBorder
activeCaptionText
activeCount
Adapterklasse
[7.1.5.1]
[50.1.2]
[8.1.1]
[7.1.5.1]
[16.1.2.1] [17.2.4] [17.3.1]
[39.2.2]
[39.2.2]
[8.4.1] [9.1.2]
[1.2.3] [23.1.1]
[35.2.2.8] [37.2.1]
[15.1] [15.2.2]
[15.6.2]
[15.5.2]
[37.1.5]
[38.2.5.1]
[10.3.4.3]
[8.4]
[7.1.2]
[36.2.2.3]
[21.4.1] [45.3.1]
[35.1.3]
[17.2.1]
[28.1.1]
[28.1.6.8]
[30.5]
[28.1.2] [28.1.6.8] [30.5]
[32.3]
[28.1.6.8] [30.2] [30.5]
[32.3]
[28.1.6.8] [30.5] [32.3]
[28.2.4]
[25.4]
[25.4]
[25.4]
[22.5.2]
[28.1.1] [28.1.5]
javax.swing
java.util
java.util
java.util
javax.swing
javax.swing.table
java.awt.event
java.awt.event
add
addActionListener
addAdjustmentListener
addAll
addChangeListener
addColumnSelectionInterval
addComponentListener
addContainerListener
addElement
addFocusListener
addImage
addItem
addItemListener
Addition
addJMenuBar
addKeyListener
addListSelectionListener
addMouseListener
addMouseMotionListener
addPoint
addPropertyChangeListener
addRowSelectionInterval
addSelectionInterval
addSelectionPath
addSelectionPaths
addSeparator
addTab
addTableModelListener
addTextListener
addTreeSelectionListener
addVetoableChangeListener
addWindowListener
Adjustable
Adjustment-Ereignisse
AdjustmentEvent
AdjustmentListener
adjustmentValueChanged
ADJUSTMENT_EVENT_MASK
Adler32
after
Aggregation
aiff-Format
ALAW
Alexander, Christopher
Aliasing
ALIGN
ALL
AllPermission
ALT
ALTER TABLE
AM_PM
anchor
and
AND
andNot
Andreessen, Marc
Anhalten eines Threads
Animation
Anlegen eines Fensters
Anonyme Klassen
Anonyme lokale Klasse
ant
Anweisungen
Anweisungsobjekt
Anwendungsprotokolle
ANY
Apache-Server
API
[38.2.5]
[28.1.6.11] [32.6]
[38.3.2.2]
[44.4.2]
[23.2.4] [23.3] [28.1.6.7]
[29.1]
[32.10] [32.11]
[28.1.6.9] [32.10]
[28.1.2] [28.1.6.9] [32.10]
[28.1.6.9] [32.10]
[28.1.6.9] [32.10]
[28.2.4]
[19.3.3.4]
[16.2.3]
[7.1.5.2]
[1.2.3] [39.3.1] [48.2.2]
[48.2.3]
[10.3]
[49.2.1.4]
[39.2.2]
[42.4.7.3]
[47.3.4.2]
[39.2.2]
[42.4.7.1]
[16.2.2]
[31.2.4]
[14.5.2]
[42.4.7.3]
[14.5.2]
[1.1]
[22.2.3]
[34.2] [39.4 (in Applets)]
[23.2.1]
[28.2.2.2]
[15.4.2]
[13.3.2.2]
[6] [13.1.1]
[42.2.2]
[45.1.2]
[42.4.7.3]
[45.2.4]
[3.2.1]
java.awt
java.awt.event
java.awt.event
java.util.zip
java.security
java.applet
java.applet
java.lang
java.lang.reflect
java.lang
java.util
java.util
java.lang
java.lang
[17.2.1]
atan
ATM
[45.1.2]
Attribute
[7.1.3]
au-Dateien
[1.2.3]
au-Format
[39.3.1] [48.2.2]
[39.3.1]
AudioClip
[48.2.2]
AudioFileFormat
[48.2.2]
AudioFormat
[48.2.2.1]
AudioInputStream
[48.2.2]
AudioSystem
Aufruf einer Methode
[7.3.2]
Ausdrucksanweisungen
[6.1.4]
Ausdrcke
[1.2.1]
Ausfhrungszeitpunkt
[44.1]
Ausgabe von Sound
[39.3]
Ausgabe-Streams
[18.2]
Ausgaben, einfache
[2.3.2]
Auslsen einer Ausnahme
[12.1] [12.3.3]
Ausnahmen
[12]
Auswertungsreihenfolge
[5.1]
Auto-Commit-Modus
[42.4.3]
Automatisches Speichermanagement
[1.2.1]
[38.2.2]
AUTO_RESIZE_ALL_COLUMNS
[38.2.2]
AUTO_RESIZE_LAST_COLUMN
[38.2.2]
AUTO_RESIZE_NEXT_COLUMN
[38.2.2]
AUTO_RESIZE_OFF
AUTO_RESIZE_SUBSEQUENT_COLUMNS[38.2.2]
[19.3.1]
available
AWT
[1.2.3] [23.1.1]
[28.1.2] [28.2.4]
AWTEvent
[47.3.4.2]
AWTPermission
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
java.applet
javax.sound.sampled
javax.sound.sampled
javax.sound.sampled
javax.sound.sampled
java.awt
java.awt
-BBaratz, Alan
baseline
BasicService
Basisklasse
BDK
Bean Development Kit
Bean-Customizer
Beanbox
BeanInfo
BeanInfo-Klasse
Beans
Bedingtes Kompilieren
before
Behandeln einer Ausnahme
Beschleunigertasten
BETWEEN
BevelBorder
Bezeichner
BigDecimal
BigInteger
Bildschirmflackern reduzieren
binarySearch
bind
Bindungsregeln
binre Suche
Bitmap laden und anzeigen
BitmapComponent
BitSet
Bitweise Operatoren
black
Blobs
[1.1]
[39.2.2]
[13.5.3.1]
[7.1.5.1]
[44.3.1]
[44.3.1]
[44.6.2]
[44.3]
[44.6.1]
[44.6.1]
[44.1]
[6.2.1.4]
[16.2.3]
[12.1]
[30.4.3] [36.2.2.3]
[42.4.7.3]
[36.3.1.1]
[4.1.3]
[17.3]
[17.3]
[34.2.4]
[15.8.1] [16.5]
[46.2.4.2]
[5.1]
[15.8.1]
[34.1.1]
[34.1.2]
[14.5]
[5.5]
[25.2]
[42.1]
javax.jnlp
java.beans
javax.swing.border
java.math
java.math
java.util
Block
BLOCK_DECREMENT
BLOCK_INCREMENT
blue
bmp-Format
BOLD
Book
boolean
[6.1.2] [13.1.2]
[32.10]
[32.10]
[25.2]
[34.1.1]
[24.2.1]
[26.3.2.5]
[4.2] [4.2.1] [4.6.1]
[6.2.1.2] [10.2.1]
[10.2.1]
Boolean
[43.3.1]
Boolean.TYPE
[48.2.2.3]
BooleanControl
[10.2.1.2]
booleanValue
Bootstrap Classes
[13.2.2.2]
Bootstrap Loader
[44.2.2]
[35.2.2.6]
Border
[35.2.2.6] [36.1.2]
BorderFactory
[31.2.3]
BorderLayout
Borland
[1.1]
[31.2.4]
BOTH
[39.2.2]
bottom
[36.2.3.2]
BOTTOM
Bound Properties
[44.4.1]
BPM
[48.3.4]
[1.2.1] [12.2.6] [6.2.2.2
break
(in switch-Anweisung)]
[6.3.3.3 (in Schleifen)]
Breite eines Zeichens
[24.3.2]
BufferedInputStream [19.3.3.1] [49.2.4.2]
BufferedOutputStream [19.2.3.1] [49.2.4.1]
[2.3.3] [18.3.2]
BufferedReader
[18.3.3.1]
[18.2.2] [18.2.3]
BufferedWriter
[49.2.4.1]
[36.3.1.4]
BUFFERED_OPTION
Bug Parade
[1.3.1.5] [3.2.2.2]
[32.3]
Button
java.awt.print
java.lang
javax.sound.sampled
javax.swing.border
javax.swing
java.awt
java.io
java.io
java.io
java.io
java.awt
[36.2.3.3] [37.2.3]
ButtonGroup
[37.2.3]
ButtonModel
[10.2.1]
Byte
[4.2] [4.2.3] [10.2.1]
byte
Byte-Streams
[18.1]
[43.3.1]
Byte.TYPE
ByteArrayInputStream [19.3.2.2] [41.3.2]
ByteArrayOutputStream[19.2.2.2] [41.3.2]
Bytecode
[13.3.1]
Bytecode-Verifier
[47.2.1]
ByteToCharConverter [18.3.2.1] [49.2.4.2]
<
>
>>
java.io
java.io
javax.swing
javax.swing
java.lang
Titel
<<
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-CCA
Cafe
CAFEBABE
Calendar
call by reference
call by value
Call-Level-Interface
Callback-Methoden
cancel
CancelButton
canRead
Canvas
canWrite
capacity
Card API
CardLayout
CaretListener
case
catch
catch-or-throw-Regel
ceil
CENTER
Certificate
Certification Authority
CGI-Script
ChangeEvent
ChangeListener
[47.1.7]
[1.1]
[20.3]
[16.2] [16.2.4]
java.util
[7.3.3] [10.2.2]
[7.3.3]
[42.1.1]
[13.1.7]
[26.3.2.1]
[37.2.1]
[13.5.3.2] [21.3]
[32.11] [33.1] [34.1.2]java.awt
[13.5.3.2] [21.3]
[11.4.5]
[1.1]
[31.1.2]
java.awt
[37.1.2]
javax.swing.event
[6.2.2.2]
[12.2.1]
[12.3.1]
[17.2.4]
[31.1.3] [31.2.1
(FlowLayout)] [31.2.4
(GridBagConstraints)]
[32.2 (Label)]
[36.2.3.2
(SwingConstants)]
[47.1.6.2]
java.security.cert
[47.1.7]
[40.1.1]
[37.4.2] [38.1.3]
javax.swing.event
[37.4.2] [38.1.3]
javax.swing.event
char
Character
Character-Streams
Character.TYPE
CharArrayReader
CharArrayWriter
charAt
CharToByteConverter
charValue
charWidth
CHAR_UNDEFINED
Checkbox
CheckboxGroup
CheckboxMenuItem
CheckedInputStream
CheckedOutputStream
checkRead
Checksum
Choice
class
Class
ClassCastException
classes.zip
Classloader
ClassNotFoundException
CLASSPATH
clear
clearRect
clearSelection
Client-Hotspot
Client-Server-Beziehung
java.lang
java.io
java.io
java.awt
java.awt
java.awt
java.util.zip
java.util.zip
java.util.zip
java.awt
java.lang
java.lang
java.lang
[48.2.2]
javax.sound.sampled
[30.7.1]
java.awt.datatransfer
[30.7.2]
java.awt.datatransfer
[13.5.3.1]
javax.jnlp
[23.4.3]
[23.4.3]
[4.5.1] [7.3.3] [8.1.2]
[9.4.2] [41.3.2]
[41.3.2]
Cloneable
java.lang
java.lang
CloneNotSupportedException[9.4.2]
[18.2.1 (Writer)]
close
[18.3.1 (Reader)]
[19.2.1
(OutputStream)] [20.1
(RandomAccessFile)]
[42.2.1 (Connection)]
[48.2.2.4 (Line)]
[48.3.3 (MidiDevice)]
Cluster
[42.3.8]
[39.2.1]
CODE
[39.2.2]
CODEBASE
Coding Conventions
[2.3.5]
[38.3.3]
collapsePath
[15.1]
Collection
java.util
Collection-API
[1.1] [1.2.4] [15]
[15.8]
Collections
java.util
[25.2]
java.awt
Color
[38.2.8]
columnAtPoint
com.sun.image.codec.jpeg [13.2.2]
Comboboxen
[32.8]
[42.4.3]
commit
[26.4.1.2]
CommPort
javax.comm
[26.4.1.2]
javax.comm
CommPortIdentifier
Community Source Licence
[1.1]
[3.2.2.1]
comp.lang.java
Comparable
[9.2]
[9.2] [15.7.1]
Comparable
java.lang
[15.7.1] [16.5]
java.util
Comparator
[15.7.1]
compare
[9.2] [11.2.4] [15.7.1]
compareTo
Clip
Clipboard
ClipboardOwner
ClipboardService
Clipping-Region
clipRect
clone
Compiler
Component
Component-Ereignisse
Component-Events
ComponentAdapter
componentAdded
ComponentEvent
[50.1]
[27.1]
[28.1.6.5]
[29.2]
[28.1.5]
[28.1.6.6]
[28.1.2] [28.1.6.5]
[29.2]
[28.1.6.5] [29.2]
componentHidden
[28.1.6.5] [29.2]
ComponentListener
[28.1.6.5] [29.2]
componentMoved
[28.1.6.6]
componentRemoved
[28.1.6.5] [29.2]
componentResized
[28.1.6.5] [29.2]
componentShown
[36.3.1.3]
ComponentUI
[28.2.4] [33.2.3]
COMPONENT_EVENT_MASK
[33.2.3]
COMPONENT_SHOWN
Composite-Pattern
[10.3.7]
[36.3.1.1]
CompoundBorder
[48.2.2.3]
CompoundControl
[22.4.4]
connect
[42.2.1]
Connection
Constrained Properties
[44.4.2]
Constraints-Objekt
[31.1.3]
[43.3.3]
Constructor
[27.1] [31.1.2]
Container
Container-Ereignisse
[28.1.6.6]
[28.1.5]
ContainerAdapter
[28.1.6.6]
ContainerEvent
[28.1.6.6]
ContainerListener
[14.4.2] [15.1]
contains
[15.1]
containsAll
[14.4.2] [15.6.1]
containsKey
[15.6.1]
containsValue
Content Handler Factories
[45.4]
ContentPane
[35.2.2.2] [36.1.1.1]
CONTIGUOUS_TREE_SELECTION [38.3.2.1]
[1.2.1] [6.3.3.3]
continue
[12.2.6]
java.awt
java.awt.event
java.awt.event
java.awt.event
javax.swing.plaf
javax.swing.border
javax.sound.sampled
java.sql
java.lang.reflect
java.awt
java.awt.event
java.awt.event
java.awt.event
[25.4]
[48.2.2] [48.2.2.3]
[48.2.2.3]
[25.4]
[25.4]
[25.4]
[25.4]
[25.4]
[39.3.1]
[23.4.2]
[1.2.4] [13.2.1.2]
[46.1.2]
[17.2.1]
[24.2.1]
[24.2.1]
[19.3.3.4]
[42.4.7.1]
[42.4.7.1]
[36.1.2]
[36.1.2]
[27.5.3]
[36.3.1.1]
[36.1.2]
[13.4.2] [34.1.1]
[34.2.4.3]
[36.3.1.1]
[21.5.2]
[42.2.2]
[21.5.1]
[36.3.1.2]
[48.3.4]
[27.5.3]
[16.3.5]
[27.5.3]
[25.2]
[47.1.2.1]
control
Control
Control.Type
controlDkShadow
controlHighlight
controlLtHighlight
controlShadow
controlText
CoolEdit
copyArea
CORBA
cos
Courier
Courier New
CRC32
CREATE INDEX
CREATE TABLE
createBevelBorder
createCompoundBorder
createCustomCursor
createEmptyBorder
createEtchedBorder
createImage
createLineBorder
createNewFile
createStatement
createTempFile
createToolTip
createTrack
CROSSHAIR_CURSOR
currentTimeMillis
Cursor
cyan
Csarische Verschlsselung
Titel
<<
>
>>
java.awt
javax.sound.sampled
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-DDangling else
darkGray
Data Definition Language
DatabaseMetaData
DataFlavor
DataFlavors
DatagramPacket
DatagramSocket
DataInput
DataInputStream
DataLine
DataLine.Info
DataOutput
DataOutputStream
Date
DateFormat
Datei- und Verzeichnis-Handling
Dateiformate
[6.2.1.3]
[25.2]
[42.2.4]
[42.3.3]
[30.7.2]
[30.7.1]
[45.1.2]
[45.1.2]
[19.3.3.3]
[19.2.3.3] [19.3.3.3]
[48.2.2]
[48.2.3]
[19.2.3.3]
[19.2.3.3]
[16.2] [16.2.4] [16.2.4
(java.sql)]
[17.4.3]
[21]
[1.2.3 (aiff)] [1.2.3 (wav)]
[2.2.1.2 (java)] [13.3.2.1
(class)] [34.1.1 (gif)]
[34.1.1 (jpeg)] [39.3.1
(au)] [39.3.1 (aiff)] [39.3.1
(wav)] [39.3.1 (Midi)]
[50.6 (jar)]
[42]
[4.2] [5.1]
[4] [4.2 (Primitive)] [4.5
(Referenz-)]
[16.2.3]
[16.2]
[45.2.2]
[16.2.2]
[16.2.2]
[16.2.2]
[16.2.2]
[48.2.2.3]
[35.1.2.1] [36.3.1.4]
java.sql
java.awt.datatransfer
java.net
java.net
java.io
java.io
javax.sound.sampled
java.io
java.io
java.util
java.text
Debugger
DebugGraphics
DecimalFormat
deep copy
default
DEFAULT
Default-Implementierung
Default-Konstruktor
Default-Paket
DefaultButton
DefaultDesktopManager
DefaultListModel
DefaultMutableTreeNode
defaultPage
defaultReadObject
DefaultTableCellRenderer
DefaultTableColumnModel
DefaultTreeModel
DefaultTreeSelectionModel
DEFAULT_CURSOR
Definite Assignment
DeflaterOutputStream
Deklaration von Variablen
Dekrement-Operator
Delegate
Delegate-Pattern
Delegation
Delegation Based Event Handling
Delegator
delete
DELETE FROM
deleteCharAt
deleteOnExit
deleteShortCut
delItem
Denial-of-Service-Attacken
[50.4]
[36.3.1.4]
javax.swing
[17.4.2]
java.text
[9.4.2] [41.3.2]
[6.2.2.2]
[17.4.3]
[9.5.1]
[7.3.6.1] [8.1.4.2]
[13.2.4.2]
[37.2.1]
[36.1.6.1]
javax.swing
[37.3.1.2]
javax.swing
[38.3.1]
javax.swing.tree
[26.3.2.2]
[44.2.4]
[38.2.7]
javax.swing.table
[38.2.6]
javax.swing.table
[38.3.1] [38.3.4]
javax.swing.tree
[38.3.2.1]
javax.swing.tree
[27.5.3]
[4.2] [5.1]
[19.2.3.4]
java.util.zip
[4.3.2] [6.1.3]
[4.3.1]
[10.3.6]
[10.3.6] [15.8.2]
[9.5.2] [10.3.6]
[10.3.9] [23.1.2.1] [28.1.1]
[10.3.6]
[11.4.3 (StringBuffer)]
[20.1 (File)] [21.4.2 (File)]
[49.2.1.2 (StringBuffer)]
[42.2.4] [42.4.7.2]
[11.4.3]
[21.5.2]
[30.4.3]
[32.9]
[13.5.3.1]
dispose
DISPOSE_ON_CLOSE
divide
Division
DNS
DNS-Konfiguration
do
Doclets
doClick
Document
DocumentListener
Dokumentation des JDK
Dokumentationsgenerator
Dokumentationskommentare
Domain Name System
Doppelpufferung
Double
double
Double.TYPE
doubleValue
DownloadService
DO_NOTHING_ON_CLOSE
Dr. Dobb's Journal
Drag-and-Drop API
drawArc
drawBytes
drawChars
drawImage
drawLine
drawOval
drawPolygon
drawPolyline
drawRect
drawRoundRect
drawString
DriverManager
DROP INDEX
DROP TABLE
Drop-Down-Listboxen
Drucken
DSA
DST_OFFSET
Duff's Device
[26.2.2] [27.2]
[36.1.6.2]
[17.3.1]
[5.2]
[45.1.3.2]
[50.4.3]
[1.2.1] [6.3.2] [6.3.3.3]
[50.5.5]
[37.2.1]
[37.1.2]
[37.1.2]
[2.1.2.2] [3.2.1]
[50.5]
[4.1.2] [50.5.3]
[45.1.3.2]
[34.2.4.3]
[4.2.4.1] [10.2.1]
[4.2] [4.2.4] [10.2.1]
[43.3.1] [43.3.2]
[10.2.1.2]
[13.5.3.1]
[36.1.6.2]
[3.2.2.4]
[1.1] [35.1.3]
[23.3.5]
[24.1]
[24.1]
[34.1.1] [34.2.4.3]
[23.3.1]
[23.3.4]
[23.3.3]
[23.3.3]
[23.3.2]
[23.3.2]
[24.1]
[42.2.1]
[42.4.7.1]
[42.4.7.1]
[32.8]
[26]
[47.1.5]
[16.2.2]
[6.2.2.2]
javax.swing.text
javax.swing.event
java.lang
javax.jnlp
java.sql
Dynamische Datenstrukturen
Dynamische Methodensuche
Dynamisches Binden
Dynamisches Laden von Klassen
Dmon
Titel
<<
Inhalt Suchen
<
>
[4.2] [13.1.4]
[8.1.3.1]
[8.1.3.1]
[43.2.2]
[22.2.1]
Index
DOC
>>
API
-EEAST
ECHO-Service
editCellAt
Eiffel
Eigenzertifikat
Einerkomplement
Einfache Vererbung
Eingabe-Streams
Eingaben, einfache
Einschrnkende
Konvertierungen
Einweg-Hashfunktion
Einzeilige Kommentare
elementAt
elements
else
EMBED
Embedded SQL
empty
EmptyBorder
EmptyStackException
enableEvents
end
Ende des Programms
endsWith
Entry
entrySet
Entschlsseln
[31.1.3] [31.2.4
(GridBagConstraints)]
[36.2.3.2
(SwingConstants)]
[45.2.3]
[38.2.4.2]
[6.4.1.4]
[47.1.6.1]
[5.5]
[8.1]
[18.3]
[2.3.3]
[4.6.1]
[47.1.3]
[4.1.2]
[14.2.2]
[14.2.3] [14.4.3]
[2.3.4] [6.2.1.3]
[40.4.1]
[42.1.1]
[14.3]
[36.3.1.1]
javax.swing.border
[14.3]
java.util
[28.2.4] [30.6] [33.2.3]
[26.2.2]
[22.2.1]
[11.2.4]
[15.6.1]
[15.6.1]
[47.1.1]
Entwicklungszyklus
Entwurfsmuster
EnumControl
enumerate
Enumeration
equals
equalsIgnoreCase
ERA
Ereignisempfnger
Ereignisquellen
Ereignistypen
Ergebnistyp eines Ausdrucks
err
erreichbare Anweisungen
Error
ERROR_MESSAGE
Ersetzen von Zeichenketten
Erste Gehversuche
Erstellen eigener Pakete
Erweiternde Konvertierungen
Escape-Kommandos
Escape-Sequenzen
ESQL
EtchedBorder
Ethernet
Event
Event Sources
EventListener
EventListener
EventObject
Exception
Exceptions
[2.3.1] [13.3]
[10.3]
[48.2.2.3]
[22.5.2]
[1.2.4] [14.2.3]
[15.3.1]
[4.5.1] [8.1.2] [5.7.2.2
(String)] [11.2.4
(String)] [14.4
(Schlsselvergleich)]
[11.2.4]
[16.2.2]
[28.1.1] [28.1.3]
[28.1.1] [28.1.4]
[28.1.2]
[5.2]
[16.3.2]
[6.2.1.4]
[12.2.3]
[36.1.4.1]
[11.2.6]
[2.2]
[13.2.4]
[4.6.1]
[42.4.2]
[4.2.2.1]
[42.1.1]
[36.3.1.1]
[45.1.2]
[28.1.2]
[28.1.1]
[28.1.1]
[28.1.1] [28.1.3]
[28.1.2] [44.4.1]
[12.2.3]
[1.2.1] [12]
javax.sound.sampled
java.util
java.lang
javax.swing.border
java.awt
java.util
java.util
java.lang
exec
executeQuery
executeUpdate
EXISTS
exists
exit
exitValue
EXKLUSIV-ODER-Operator
exp
expandCapacity
expandPath
ExperimentalWebServer
Exponentialfunktion
extends
Extension Framework
Externalizable
[16.4.1]
[42.2.2] [42.2.3]
[42.2.2] [42.2.4]
[42.4.7.3]
[21.3]
[16.3.3]
[16.4.2]
[5.4]
[17.2.3]
[49.3.2.2]
[38.3.3]
[45.3.3]
[17.2.3]
[8.1.1]
[1.1]
[41.2.1]
<
>
>>
java.io
-FFactory
[10.3.4.1 (-Methode)]
[10.3.4.2 (-Klasse)]
Factory-Pattern
[10.3.4]
[4.1.3] [4.2] [4.2.1.1]
false
FDDI
[45.1.2]
Fehlerobjekt
[12.2.2]
Fensterklassen
[27.1]
Fenstertitel
[27.5.1]
[43.4]
Field
[17.4.3]
FieldPosition
[18.2.2.1] [21.1]
File
[16.3.1] [18.1]
file.separator
[13.5.3.2]
FileContents
[18.2.2.1]
FileDescriptor
[27.1]
FileDialog
[19.3.2.1] [41.1.3]
FileInputStream
[21.4.1]
FilenameFilter
FileNotFoundException[18.3.2.1] [19.3.2.1]
[20.1]
[13.5.3.1] [13.5.3.2]
FileOpenService
[19.2.2.1] [41.1.2]
FileOutputStream
[49.2.4.1]
[47.3.4.2]
FilePermission
[18.3.2]
FileReader
[13.5.3.1]
FileSaveService
[18.2.2] [18.2.2.1]
FileWriter
[16.5] [31.2.4]
fill
[23.4.1]
fillArc
[23.4.1]
fillOval
[23.4.1]
fillPolygon
[23.4.1]
fillRect
java.lang.reflect
java.text
java.io
javax.jnlp
java.io
java.awt
java.io
java.io
java.io
javax.jnlp
java.io
java.io
java.io
javax.jnlp
java.io
fillRoundRect
FilterInputStream
FilterOutputStream
FilterReader
FilterWriter
final
finalize
finally
Fingerprint
firePropertyChange
Firewall
first
First Person, Inc.
firstElement
FLASH_OPTION
Fliekommazahlen
float
Float
Float.TYPE
FloatControl
FloatControl.TYPE
floatValue
floor
FlowLayout
flush
[23.4.1]
[19.3.3]
java.io
[19.2.3]
java.io
[18.3.2] [18.3.3.3]
java.io
[18.2.2] [18.2.3]
java.io
[18.2.3.3]
[8.1.1] [8.1.3.1] [8.2.2.6]
[8.3.2] [49.2.2]
[7.3.7]
[12.2.6]
[47.1.3.3]
[44.4.1]
[45.1.6]
[15.7.2]
[1.1]
[14.2.2]
[36.3.1.4]
[4.2.4]
[4.2] [4.2.4] [10.2.1]
[4.2.4.1] [10.2.1]
java.lang
[43.3.1]
[48.2.2.3]
javax.sound.sampled
[48.2.2.3]
[10.2.1.2]
[17.2.4]
[31.2.1]
java.awt
[18.2.1 (Writer)]
[18.2.3.1
(BufferedWriter)]
[19.2.1 (OutputStream)]
[19.2.3.1
(BufferedOutputStream)]
[36.3.1.9]
[28.1.6.1]
[29.5]
[28.1.5]
java.awt.event
[28.1.6.1]
java.awt.event
[28.1.6.1] [29.5]
[28.1.6.1]
java.awt.event
[28.1.6.1] [29.5]
[33.2.3]
[33.2.3]
[33.2.3]
[33.2.3]
[24.2.1]
java.awt
[24.3.1]
[24.3.2]
[24.2.1]
[24.3.2]
java.awt
[1.2.1] [6.3.3.2] [6.3.3.3]
[6.3.3]
[17.4.2] [17.4.3]
[17.4.2 (Zahlen-)]
[17.4.3 (Datum-/Uhrzeit)]
[43.2.2] [43.3.2]
[5.7.1.1]
[23.2.1] [24.3.1] [27.1] java.awt
[31.1.1]
[1.2.1]
[17.4.3]
[29.6]
[9.4.3 (mit Interfaces)]
[43.3.2 (mit Reflection)]
[23.4.1]
focusGained
FocusListener
focusLost
FOCUS_EVENT_MASK
FOCUS_GAINED
FOCUS_LOST
Fokus-Subsystem
Font
Font-Informationen
Font-Metriken
font.properties
FontMetrics
for
for-Schleife
format
Formatierung
forName
Fragezeichenoperator
Frame
friend
FULL
Funktionstasten
Funktionszeiger
Fllmodus
<
>
>>
Titel
<<
>
>>
API
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-GGamelan
Gamma, Erich
Garbage Collector
gc
gcd
Gebundene Eigenschaften
Generizitt
Gesampelter Sound
Geschachtelte Schleifen
get
GET
getAbsolutePath
getActionCommand
getAddress
getAdjustable
getAdjustmentType
getAnchorSelectionIndex
getApplet
getAppletContext
getAppletInfo
getApplets
getAscent
getAsText
getAudioClip
getAudioFileFormat
getAudioInputStream
[1.1]
[10.3]
[4.5.2] [16.3.4]
[16.3.4] [49.2.5]
[17.3.1]
[44.4.1]
[9.2]
[48.2]
[6.3.3.3]
[14.4.2 (Hashtable)]
[14.5.1 (BitSet)]
[15.6.1 (Map)] [16.2.2
(Calendar)] [43.4
(Field)] [43.5.2
(Array)]
[45.2.4] [45.3.3]
[21.2]
[30.5] [32.3] [32.6]
[45.2.1]
[32.10]
[32.10]
[37.3.1.1]
[40.1.2] [40.2]
[40.1.2]
[39.1.4.4]
[40.1.2] [40.2]
[24.3.2]
[44.6.2.1]
[39.3.1]
[48.2.2.1]
[48.2.2.1]
getAvailableFontFamilyNames
getBestCursorSize
getBlockIncrement
getBlue
getBoolean
getBounds
getBuffer
getBundle
getByName
getByte
getBytes
getCaretPosition
getCertificate
getChar
getChars
getCheckboxGroup
getChecksum
getChildAt
getChildCount
getClass
getClickCount
getClip
getClipBounds
getCodeBase
getColor
getColumnClass
getColumnCount
getColumnModel
getColumnName
getColumns
getColumnType
getComponent
getComponentAt
getComponentCount
getComponents
getConnection
[24.2.2]
[27.5.3]
[32.10] [37.4.1]
[25.2]
[42.2.3] [43.5.2]
[23.4.3] [27.3]
[18.2.2.2]
[17.4.4.1]
[45.2.1]
[42.2.3] [43.5.2]
[42.2.3]
[32.6] [37.1.2]
[47.1.6.2]
[43.5.2]
[49.2.1.5]
[32.5]
[19.2.3.5] [19.3.3.4]
[38.3.1]
[38.3.1]
[22.4.2.1] [43.2.2]
[29.3]
[23.4.3]
[23.4.3]
[39.3.1]
[25.3]
[38.2.5]
[38.2.4.1] [38.2.5]
[42.4.1]
[38.2.8]
[38.2.5] [42.4.1]
[32.6]
[42.4.1]
[29.2] [31.1.3]
[38.1.3]
[31.1.3]
[31.1.3]
[42.2.1]
getConstructor
getConstructors
getContent
getContentPane
getContents
getControl
getControls
getCopies
getCountry
getCurrent
getCustomEditor
getDate
getDateInstance
getDateTimeInstance
getDeclaredField
getDeclaredFields
getDeclaredMethods
getDefault
getDefaultRenderer
getDefaultToolkit
getDescent
getDocument
getDocumentBase
getDouble
getEchoCharacter
getEditingColumn
getEditingRow
getElements
getEnabled
getErrorCode
getErrorStream
getFamily
getField
getFields
getFilePointer
getFloat
[43.3.3]
[43.3.3]
[45.4]
[35.2.2.2] [36.1.1.1]
[30.7.2]
[48.2.2.3]
[48.2.2.3]
[26.3.2.1]
[17.4.1]
[32.5]
[44.6.2.3]
[42.2.3]
[17.4.3]
[17.4.3]
[43.4]
[43.4]
[43.3.1]
[16.2.2] [17.4.1]
[38.2.7]
[24.2.2]
[24.3.2]
[37.1.2]
[39.3.1]
[42.2.3] [43.4]
[43.5.2]
[32.7]
[38.2.4.2]
[38.2.4.2]
[37.2.3]
[36.2.2.3]
[42.2.5]
[16.4.2]
[24.3.1]
[43.4]
[43.4]
[20.2.1]
[42.2.3] [43.5.2]
getFont
getFontList
getFontMetrics
getGlassPane
getGraphics
getGreen
getHAdjustable
getHeight
getHorizontalAlignment
getHorizontalTextPosition
getHostAddress
getHostName
getIcon
getID
getImage
getImageableHeight
getImageableWidth
getImageableX
getImageableY
getInputStream
getInsets
getInstance
getInt
getItem
getItemCount
getItemSelectable
getJobName
getKey
getKeyChar
[24.2.1]
[24.2.2]
[24.3.2]
[36.1.1.1]
[26.2.1] [34.2.4.3]
[25.2]
[32.11]
[24.3.2] [26.3.2.2]
[34.1.2]
[37.1.1] [37.2.1]
[37.1.1] [37.2.1]
[45.2.1]
[45.2.1]
[44.6.1.1]
[28.1.2] [29.1]
[34.1.1]
[26.3.2.2]
[26.3.2.2]
[26.3.2.2]
[26.3.2.2]
[13.5.3.2
(FileContents)] [16.4.2
(Process)] [26.4.1.2
(CommPort)] [45.2.2
(Socket)]
[23.2.3] [24.1]
[47.1.4]
[42.2.3 (ResultSet)]
[43.4 (Field)] [43.5.2
(Array)]
[30.3] [32.8]
[30.3] [32.8]
[32.4] [32.8]
[26.3.2.1]
[15.6.1]
[28.1.2] [29.6]
[33.2.3]
getKeyCode
getKeys
getKeyStroke
getLabel
getLanguage
getLastPathComponent
getLayeredPane
getLeading
getLeadSelectionIndex
getLeadSelectionPath
getLeadSelectionRow
getLength
getLine
getLineCount
getLineEndOffset
getLineNumber
getLineOfOffset
getLineStartOffset
getLineWrap
getLocalGraphicsEnvironment
getLocalHost
getLocation
getLong
getMajorTickSpacing
getMaximum
getMaximumCursorColors
getMaximumSize
getMaxReceivers
getMenu
getMessage
getMetaData
getMethod
getMethodDescriptors
getMethods
getMicrosecondPosition
getMidiDevice
[28.2.1] [29.6]
[17.4.4.2]
[36.2.2.3]
[30.4.1] [32.3] [32.4]
[17.4.1]
[38.3.2.2]
[36.1.1.1]
[24.3.2]
[37.3.1.1]
[38.3.2.2]
[38.3.2.2]
[13.5.3.2] [43.5.2]
[48.2.2.2]
[37.1.4]
[37.1.4]
[18.3.3.2]
[37.1.4]
[37.1.4]
[37.1.4]
[24.2.2]
[45.2.1]
[27.3] [31.3]
[42.2.3] [43.5.2]
[37.4.2]
[32.10] [37.4.1]
[48.2.2.3]
[27.5.3]
[33.2.2] [36.3.1.7]
[48.3.3]
[30.2]
[12.2.2]
[42.3.3] [42.4.1]
[43.3.2]
[44.6.1.3]
[43.3.1]
[48.3.3]
[48.3.3]
getMidiDeviceInfo
getMidiFileTypes
getMinimum
getMinimumSize
getMinorTickSpacing
getMixer
getMixerInfo
getMnemonic
getModel
getModifiers
getName
getNewLeadSelectionPath
getNewValue
getNextException
getNumberInstance
getNumberOfPages
getObject
getOldLeadSelectionPath
getOldValue
getOrientation
getOutputStream
getPageDimension
getPageFormat
getPageResolution
[48.3.3]
[48.3.5.2]
[32.10] [37.4.1]
[48.2.2.3]
[33.2.2] [36.3.1.7]
[37.4.2]
[48.2.2.2]
[48.2.2.2]
[36.2.2.3] [37.2.1]
[37.3.1.2]
[28.1.2] [43.3.1]
[43.3.3]
[13.5.3.2
(FileContents)] [21.2
(File)] [22.5.1
(Thread)] [26.4.1.2
(CommPortIdentifier)]
[30.7.2 (Clipboard)]
[43.3.1 (Method)]
[43.3.3 (Constructor)]
[38.3.2.2]
[44.4.1]
[42.2.5]
[17.4.2]
[26.3.2.5]
[17.4.4.2]
[38.3.2.2]
[44.4.1]
[26.3.2.2]
[13.5.3.2
(FileContents)] [16.4.2
(Process)] [26.4.1.2
(CommPort)] [45.2.2
(Socket)]
[26.2.2]
[26.3.2.5]
[26.2.2]
getPaper
getParameter
getParameterInfo
getParameterTypes
getParent
getPath
getPathToRoot
getPoint
getPortIdentifier
getPortIdentifiers
getPortType
getPosition
getPreferredSize
getPrintable
getPrinterJob
getPrintJob
getPriority
getProperties
getProperty
getPropertyDescriptors
getPropertyName
getPublicKey
getReceiver
getRed
getResource
getResourceAsStream
getRootPane
getRowCount
getRuntime
getScreenResolution
getScreenSize
getScrollPosition
getSelectedColumn
getSelectedColumns
getSelectedComponent
[26.3.2.2]
[39.2.3]
[39.1.4.3]
[43.3.1] [43.3.3]
[21.2] [22.5.2]
[38.3.1]
[21.2] [38.3.2.2]
[38.3.4]
[28.1.2]
[26.4.1.2]
[26.4.1.2]
[26.4.1.2]
[29.3]
[32.11] [33.2.2]
[36.3.1.7]
[26.3.2.5]
[26.3.2.1]
[26.2.1]
[22.5.1]
[16.3.1]
[14.4.4] [16.3.1]
[44.6.1.2]
[44.4.1]
[47.1.6.2]
[48.3.3]
[25.2]
[44.2.2]
[13.4.2]
[36.1.1.1]
[38.2.4.1] [38.2.5]
[16.4.1]
[26.2.2]
[27.3]
[32.11]
[38.2.3.2]
[38.2.3.2]
[38.1.3]
getSelectedIndex
getSelectedIndexes
getSelectedIndices
getSelectedItem
getSelectedItems
getSelectedRow
getSelectedRows
getSelectedText
getSelectedValue
getSelectedValues
getSelection
getSelectionEnd
getSelectionMode
getSelectionModel
getSelectionPath
getSelectionPaths
getSelectionRows
getSelectionStart
getSequence
getSequencer
getShort
getSize
getSource
getSQLState
getState
getString
getStringArray
getStyle
getSuperClass
getSynthesizer
[32.8 (Choice)]
[37.3.1.1 (JList)]
[37.3.2 (JComboBox)]
[38.1.3
(JTabbedPane)]
[32.9]
[37.3.1.1]
[32.8] [37.3.2]
[32.9]
[38.2.3.2]
[38.2.3.2]
[32.6] [37.1.2]
[37.3.1.1]
[37.3.1.1]
[37.2.3]
[32.6] [37.1.2]
[37.3.1.1]
[38.2.8] [38.3.2.1]
[38.3.2.2]
[38.3.2.2]
[38.3.2.2]
[32.6] [37.1.2]
[48.3.5.1]
[48.3.4]
[42.2.3] [43.5.2]
[24.1] [24.3.1] [27.3]
[28.1.2] [29.1] [32.6]
[42.2.5]
[36.2.3.3] [27.4
(Frame)] [30.4.2
(CheckboxMenuItem)]
[32.4 (Checkbox)]
[17.4.4.2] [42.2.3]
[17.4.4.2]
[24.3.1]
[43.4]
[48.3.3]
[30.7.2]
getSystemClipboard
[38.1.3]
getTabCount
getTableCellRendererComponent[38.2.7]
[42.4.1]
getTableName
[38.1.3]
getTabPlacement
[37.1.4]
getTabSize
[44.6.2.2]
getTags
getter-Methoden
[44.2.3]
[32.2] [32.6] [37.1.2]
getText
[22.5.2]
getThreadGroup
[16.2.4] [42.2.3]
getTime
[17.4.3]
getTimeInstance
[42.2.3]
getTimestamp
[27.5.1]
getTitle
[34.1.1]
getToolkit
[36.3.1.2]
getToolTipText
[42.4.3]
getTransactionIsolation
[30.7.2]
getTransferData
[30.7.2]
getTransferDataFlavors
[43.4]
getType
[42.4.4]
getTypeInfo
[32.10] [37.4.1]
getUnitIncrement
[26.3.2.1]
getUserName
[38.3.1]
getUserObject
[32.11]
getVAdjustable
[48.2.2.3] [15.6.1
getValue
(Map)] [32.10
(Scrollbar)] [32.10
(AdjustmentEvent)]
[37.4.1 (JScrollBar)]
[37.4.3
(JProgressBar)]
[44.6.2.1
(PropertyEditor)]
[38.2.4.1] [38.2.5]
getValueAt
[37.4.2]
getValueIsAdjusting
[37.4.1]
getValueIsAdjusting()
getVariant
getVerticalAlignment
getViewportSize
getVisibleAmount
getWhen
getWidth
getWindow
getWrapStyleWord
getX
getY
gif-Format
gk.util
GlassPane
Gleichheits-Operator
Globale Funktionen
GoF - Gang of Four
GoldWave
Gosling, James
Grafikkontext
Graphical User Interface
Graphics
Graphics2D
GraphicsEnvironment
gray
green
Green-OS
Green-Projekt
GregorianCalendar
GridBagConstraints
GridBagLayout
gridheight
GridLayout
gridwidth
gridx
gridy
GROUP BY
[17.4.1]
[37.1.1] [37.2.1]
[32.11]
[32.10] [37.4.1]
[29.3]
[26.3.2.2] [34.1.2]
[29.1]
[37.1.4]
[29.3]
[29.3]
[34.1.1]
[42.3.2] [13.2.3
(installieren)]
[36.1.1.1]
[5.3]
[7.3.1]
[10.3]
[39.3.1]
[1.1]
[23.2.2]
[44.1]
[23.2.2]
[26.3.2.4]
[24.2.2]
[25.2]
[25.2]
[1.1]
[1.1]
[16.2]
[31.2.4]
[31.2.4]
[31.2.4]
[31.2.2]
[31.2.4]
[31.2.4]
[31.2.4]
[42.4.7.3]
java.awt
java.awt
java.awt
java.util
java.awt
java.awt
java.awt
Grundlinie
Grer-Operator
Grergleich-Operator
GUI-Designer
GZIPInputStream
GZIPOutputStream
Titel
<<
[24.3.2]
[5.3]
[5.3]
[44.1]
[19.3.3.5]
[19.2.3.4]
>
>>
API
java.util.zip
java.util.zip
-H[28.1.1]
[17.4.4.2]
[2.1.1]
[38.3.3]
[14.4] [15.6.2]
[8.1.2] [15.1] [47.1.3]
[15.5.2] [15.6.2]
[15.5.2]
[1.2.4] [14.4] [15.6.2]
[1.2.4] [14.2.3]
[17.1.2]
[15.3.1]
[15.3.2]
[42.4.7.3]
[45.3.3]
[15.7.2]
[35.1.2.1]
[39.2.1]
[10.3]
[24.2.1]
[36.1.6.2]
[31.2.3]
[22.2.1]
[27.5]
[31.2.4
(GridBagConstraints)]
[32.10 (Scrollbar)]
[36.2.3.2
(SwingConstants)]
[38.1.1]
HORIZONTAL_SCROLLBAR_ALWAYS
HORIZONTAL_SCROLLBAR_AS_NEEDED[38.1.1]
handleEvent
handleGetObject
Hardware-Voraussetzungen
hasBeenExpanded
Hash-Funktion
hashCode
HashMap
HashSet
Hashtable
hasMoreElements
hasMoreTokens
hasNext
hasPrevious
HAVING
HEAD
headSet
Heavyweight Components
HEIGHT
Helm, Richard
Helvetica
HIDE_ON_CLOSE
Himmelsrichtungen
Hintergrund-Thread
Hintergrundfarbe
HORIZONTAL
java.util
java.util
java.util
HORIZONTAL_SCROLLBAR_NEVER
HORIZONTAL_SPLIT
Host-ID
Host-Namen
Host-Variablen
hosts
HotJava
HotJava Views
HotSpot
HOUR
HOUR_OF_DAY
hprof
HSPACE
HSQLDB
HTML-Adresse
HTML-Ausgabe des Buchs
HTML-Dokument
HTMLConverter
http
Hybride Kryptosysteme
Hypersonic SQL
Hhe einer Zeile
<
>
>>
[38.1.1]
[38.1.2]
[45.1.3.1]
[40.1.1]
[42.1.1]
[50.4.3]
[1.1]
[1.1]
[1.1] [50.2.2]
[16.2.2]
[16.2.2]
[49.3.1]
[39.2.2]
[42.3.1]
[40.1.1]
[3.2.3]
[39.2.1]
[40.4.2.2]
[40.1.1]
[47.1.5]
[42.3.3.1]
[24.3.2]
-II18N
[17.4]
IAB
[45.1.5]
IBM
[1.1]
ICMP
[45.1.2]
Icon
[27.5]
[36.2.3.2]
Icon
[27.4]
ICONIFIED
[44.6.1.1]
ICON_COLOR_16x16
[44.6.1.1]
ICON_COLOR_32x32
[44.6.1.1]
ICON_MONO_16x16
[44.6.1.1]
ICON_MONO_32x32
[1.2.1] [6.2] [6.2.1.2]
if
if-Anweisung
[6.2.1]
[6.2]
if-else
IIOP
[46.1.2]
[6.4.1.4] [15.2.1]
IllegalArgumentException
IllegalThreadStateException[16.4.2]
[34.1.1]
Image
[36.2.3.2]
ImageIcon
[34.1.1]
ImageObserver
immutable
[10.2.2] [15.5.1]
Immutable-Pattern
[10.3.2]
Implementierung eines Interfaces
[9.1.2]
[9.1.2]
implements
[2.3.3] [13.2.1]
import
[13.2.1.1]
Import von java.lang
[13.2.1.1]
[42.4.7.3]
IN
[16.3.2]
in
[25.4]
inactiveCaption
[25.4]
inactiveCaptionBorder
javax.swing
java.lang
java.lang
java.awt
javax.swing
java.awt.image
inactiveCaptionText
indexOf
IndexOutOfBoundsException
Indizierte Eigenschaft
InetAddress
inetd.conf
InflaterInputStream
info
Informationen im Internet
INFORMATION_MESSAGE
infoText
init
Initialisieren
initSign
initVerify
Inkrement-Operator
Inner Classes
Input Method Framework
InputEvent
InputStream
InputStream
InputStreamReader
insert
INSERT INTO
insertElementAt
insertItemAt
insertNodeInto
insertSeparator
insertTab
insets
Installation
instanceof
[25.4]
[11.2.5]
[12.2.5]
java.lang
[44.2.3.2]
[45.2.1]
java.net
[45.3.1]
[19.3.3.5]
java.util.zip
[25.4]
[3.2.2]
[36.1.4.1]
[25.4]
[36.1.5] [39.1.1]
[39.1.3.2]
[4.3.2 (von Variablen)]
[4.4.1 (eines Arrays)]
[47.1.6.2]
[47.1.6.2]
[4.3.1]
[10.1.1]
[35.1.3]
[28.1.2] [29.6]
java.awt.event
[19.1]
[19.1] [19.3.1]
java.io
[2.3.3] [18.3.2]
java.io
[18.3.2.1]
[11.4.2] [32.7] [38.3.1]
[42.2.4] [42.3.4]
[42.4.7.2]
[14.2.1]
[37.3.2]
[38.3.4]
[30.3]
[38.1.3]
[31.2.4]
[2.1.2]
[5.7.2.3] [14.2.1]
[32.6]
InstantDB
Instanzmerkmale
Instanzvariablen
int
Integer
Integer.TYPE
Integrale Typen
interface
Interfaces
Internationalisierung
Internet
Internet Activity Board
Interpreter
interrupt
interrupted
InterruptedException
InterruptedIOException
Introspection
Introspector
intValue
invalidate
InvalidClassException
Invalidierung
Invariante
invoke
IOException
IP-Adresse
IP-Protokoll
ipadx
ipady
IPv6
IS NOT NULL
IS NULL
isAbsolute
[42.3.1]
[7.1.3]
[4.3.1] [4.3.3] [7.1.3]
[4.2] [4.2.3] [10.2.1]
[10.2.1]
[43.3.1]
[4.2.3]
[9.1.1]
[8.1] [9.1] [10.3.3
(Design-Pattern)]
[17.4]
[3.2.2]
[45.1.5]
[50.2]
[22.2.2]
[22.2.2]
[22.2.2] [34.1.1.1]
[45.2.3]
[43.1] [44.1]
[44.6.1]
[10.2.1.2]
[36.3.1.8]
[41.2.1]
[36.3.1.8]
[6.4.1.2]
[43.3.1] [43.3.2]
[14.4.4] [18.2.2.1]
[20.1]
[45.1.3.1]
[45.1.2]
[31.2.4]
[31.2.4]
[45.1.3.1]
[42.4.7.3]
[42.4.7.3]
[21.3]
java.lang
java.lang
java.io
java.beans
java.io
java.io
isAbstract
isAlive
isAltDown
isCancelled
isCellEditable
isCollapsed
isControlDown
isControlSupported
isConversionSupported
isDataFlavorSupported
isDirectory
isDoubleBuffered
isEditable
isEditing
isEmpty
isEnabled
isEnabledAt
isExpanded
isExplicit
isFile
isFinal
isFocusable
isFocusTraversable
isHidden
isIndeterminate
isInterface
isInterrupted
isLeaf
isMetaDown
isModal
isNative
ISO-3166
ISO-639
ISO-8859-1
ISO/OSI-7-Schichten-Modell
isOpen
[43.3.1]
[22.2.4.2]
[29.6]
[26.3.2.1]
[38.2.5]
[38.3.3]
[29.6]
[48.2.2.3]
[48.2.2.1]
[30.7.2]
[21.3]
[36.3.1.6]
[32.6] [37.3.2]
[38.2.4.2]
[14.2.1] [15.1] [15.6.1]
[27.3] [30.4.1] [37.2.1]
[38.1.3]
[38.3.3]
[43.3.1]
[21.3]
[43.3.1]
[33.2.3]
[33.2.3]
[21.3]
[37.4.3]
[43.3.1]
[22.2.2]
[38.3.1]
[29.6]
[31.3]
[43.3.1]
[17.4.1]
[17.4.1]
[4.1.1]
[45.1.2]
[48.3.3]
[44.6.2.3]
[38.3.2.2]
[30.6] [36.2.4]
[43.3.1]
[43.3.1]
[43.3.1]
[31.3]
[38.3.1]
[48.2.2.4] [48.3.4]
[36.2.3.3] [37.2.2]
[37.3.1.1]
[37.3.1.1] [38.3.2.2]
[29.6]
[43.3.1]
[43.3.1]
[43.3.1]
[29.5]
[43.3.1]
[38.3.3]
[43.3.1]
[24.2.1]
[28.1.6.10] [32.8]
[28.1.2] [28.1.6.10]
[32.4] [32.8]
[28.1.6.10] [32.4]
[32.8]
[28.1.6.10] [32.4]
[32.8]
[15.3.1] [15.4.2]
[1.2.4] [15.3.1]
[10.3.5]
isPaintable
isPathSelected
isPopupTrigger
isPrivate
isProtected
isPublic
isResizable
isRootVisible
isRunning
isSelected
isSelectedIndex
isSelectionEmpty
isShiftDown
isStatic
isStrict
isSynchronized
isTemporary
isTransient
isVisible
isVolatile
ITALIC
Item-Ereignisse
ItemEvent
ItemListener
itemStateChanged
iterator
Iterator
Iterator-Pattern
<
>
>>
java.awt.event
java.util
java.awt.event
-JJ++
J2EE
J2ME
J2SE
JAAS
Jakarta
JApplet
[1.1]
[1.1]
[1.1]
[1.1]
[47.1.5]
[13.3.2.2]
[35.2.2.2]
javax.swing
[36.1.5]
[50.6.2]
jar
JAR-Archiv
[39.2.2]
[19.2.3.4]
JarOutputStream
java.util.jar
[47.3.2]
jarsigner
[50.11.2]
[2.2.2.1]
java
[50.2.2]
Java 2 Enterprise Edition
[1.1]
Java 2 Micro Edition
[1.1]
Java 2 Platform
[1.1]
Java 2 SDK
[1.1]
Java 2 Standard Edition
[1.1]
Java 2D API
[1.1] [1.2.3]
Java Authentication and Authorization Service [47.1.5]
Java Beans Homepage
[44.3.1]
Java Communications API
[26.1] [26.4]
Java Community Process
[1.1]
JAVA Cryptography Extension
[47.1.5]
Java Database Connectivity
[1.2.4]
[42.1.1]
Java Developer's Connection
[1.1] [3.2.2.2]
Java Developer's Journal
[3.2.2.4]
Java Development Kit
[1.1]
[1.1] [1.2.3]
[35.1.1]
[48.1]
[46.2.6]
[13.5.1]
[50.4.2]
[3.2.2.4]
[2.1.2.1]
[50.2.3]
[47.1.5]
[1.3.2]
[3.2.2.4]
[49.3.1]
[13.5]
[45.3.3]
[13.5.1]
[3.2.2.4]
[35.1.2.4]
[40.4]
[1.1]
[13.2.1.2]
[13.2.1.2]
[23.2.1]
[30.7.1]
[28.1.2]
[1.2.3]
[26.3.1]
[13.2.1.2]
[44.4.1]
[16.3.1]
[16.3.1]
[50.2.2]
[16.3.1]
[13.2.1.2]
[18.1]
[13.2.1.1]
[13.2.1.2]
java.lang.ref
java.lang.reflect
java.math
java.net
java.nio
java.policy
java.rmi
java.rmi.server
java.security
java.security.cert
java.specification.name
java.specification.vendor
java.specification.version
java.sql
java.text
java.util
java.util.jar
java.util.zip
java.vendor
java.vendor.url
java.version
java.vm.name
java.vm.specification.name
java.vm.specification.vendor
java.vm.specification.version
java.vm.vendor
java.vm.version
JavaBeans
[13.2.1.2]
[13.2.1.2]
[43.3.1]
[13.2.1.2]
[17.3]
[13.2.1.2]
[45.2.1]
[13.2.1.2]
[47.3.4.1]
[13.2.1.2]
[46.2.2]
[46.2.3.1]
[13.2.1.2]
[47.1.6.2]
[16.3.1]
[16.3.1]
[16.3.1]
[13.2.1.2]
[42.2.1]
[13.2.1.2]
[17.4.2]
[13.2.1.2]
[15.1]
[28.1.2]
[19.2.3.4]
[19.2.3.4]
[16.3.1]
[16.3.1]
[16.3.1]
[16.3.1]
[16.3.1]
[16.3.1]
[16.3.1]
[16.3.1]
[16.3.1]
[1.1] [1.2.4]
javac
javadoc
javadt
javaidl
javakey
JavaLobby
JavaOne
JavaOS 1.0
javap
JavaScript
JavaSoft
JavaStation
javaw
javax-Pakete
javax.accessibility
javax.comm
javax.crypto
javax.imageio
javax.jnlp
javax.naming
javax.print
javax.security.auth
javax.sound
javax.sound.midi
javax.sound.sampled
javax.swing
javax.swing.event
javax.swing.plaf
javax.swing.table
javax.swing.text
javax.swing.tree
[2.2.1.3]
[2.2.2.1]
[50.1.2]
[4.1.2]
[50.5.2]
[50.4.2]
[1.2.4]
[47.1.6.1]
[3.2.2.2]
[1.1]
[1.1]
[50.7.2]
[1.2.2]
[1.1] [3.2.2.2]
[1.1]
[2.3.6.3]
[50.2.2]
[13.2.1.2]
[13.2.1.2]
[26.4.1.2]
[13.2.1.2]
[13.2.1.2]
[13.5.3.2]
[13.2.1.2]
[13.2.1.2]
[13.2.1.2]
[13.2.1.2]
[48.3.2]
[48.2.2]
[13.2.1.2]
[35.2.2.1]
[37.3.1.1]
[37.4.2]
[36.3.1.3]
[38.2.5]
[37.1.2]
[38.3.1]
javax.xml
JAVA_COMPILER
java_g
JButton
JCE
JCheckBox
JCheckBoxMenuItem
JComboBox
JComponent
jdb
JDBC
JDBC-ODBC-Bridge
JDC
JDesktopPane
JDialog
JDK
JEditorPane
JFC
JFormattedTextField
JFrame
JInsight
JInternalFrame
JIT
JLabel
[13.2.1.2]
[49.3.2.4]
[50.2.2]
[49.3.2.4]
[50.2.3]
[35.2.2.8]
[37.2.1]
[47.1.5]
[37.2.2]
[36.2.3.3]
[37.3.2]
[35.2.2.3]
[36.3.1]
[50.4.2]
[1.1] [1.2.4]
[42] [42.1.1]
[42.1.2.1]
[3.2.2.2]
[3.2.2.2
(Newsletter)]
[36.1.6.1]
[35.2.2.2]
[36.1.3]
[1.1]
[37.1.4]
[1.2.3]
[37.1.2]
[10.3.6]
[35.2.2.2]
[36.1.1]
[49.3.3]
[36.1.6.2]
[49.1]
[50.2.2]
[35.2.2.4]
[37.1.1]
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
JLayeredPane
JList
JMenu
JMenuBar
JMenuItem
JNDI
jnlp-Datei
Johnson, Ralph
join
JOptionPane
Joy, Bill
JPanel
JPasswordField
JPDA
jpeg-Format
JPopupMenu
JProbe
JProgressBar
JRadioButton
JRadioButtonMenuItem
JRE
jre
JRootPane
JScrollBar
JScrollPane
JSlider
JSpinner
JSplitPane
JSSE
JTabbedPane
[36.1.1.1]
[36.3.2.2]
[35.2.2.7]
[37.3.1]
[36.2.2.2]
[36.1.1.1]
[36.2.2.3]
[46.2.6]
[13.5.2.2]
[10.3]
[22.2.2]
[22.2.4.3]
[36.1.4]
[1.1]
[35.2.2.3]
[36.3.2.1]
[35.2.2.5]
[37.1.3]
[50.4.2]
[34.1.1]
[36.2.4]
[49.3.3]
[37.4.3]
[37.2.3]
[36.2.3.3]
[2.1.2.1]
[50.2.3]
[36.1.1.1]
[37.4.1]
[35.2.2.7]
[37.1.4]
[38.1.1]
[37.4.2]
[37.1.5]
[38.1.2]
[47.1.5]
[38.1.3]
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
[38.2.1]
[37.1.4]
[37.1.2]
[37.1.2]
[37.1.4]
[37.2.2]
[36.3.1.2]
[38.3.1]
[49.1]
[50.2.2]
[49.3.1]
[35.2.2.2]
[36.1.2]
JTable
JTextArea
JTextComponent
JTextField
JTextPane
JToggleButton
JToolTip
JTree
Just-In-Time-Compiler
JVMPI
JWindow
<
>
>>
javax.swing
javax.swing
javax.swing
javax.swing.text
javax.swing
javax.swing
javax.swing
javax.swing
javax.swing
-KKapselung
Kestrel
Key-Ereignisse
Key-Events
KeyAdapter
KeyEvent
KeyListener
keyPressed
keyReleased
keys
keySet
KeyStore
KeyStroke
keytool
keyTyped
KEY_EVENT_MASK
KEY_PRESSED
Klammerung
Klartext
Klassen
Klassendiagramme
Klassenmethoden
Klassenobjekt
[7.1.3]
[1.1]
[28.1.6.2]
[29.6]
[28.1.5] [28.2.2.1]
[28.2.2.2]
[28.1.2] [28.1.6.2]
[28.2.1] [29.6]
[28.1.6.2] [28.2.1]
[28.2.2.1] [29.6]
[28.1.6.2] [28.2.1]
[28.2.2.2] [29.6]
[28.1.6.2] [28.2.1]
[29.6]
[14.4.3]
[15.6.1]
[47.1.6.2]
[36.2.2.3]
[47.1.6.1] [47.3.3]
[50.9.2]
[28.1.6.2] [28.2.1]
[29.6]
[33.2.3]
[33.2.3]
[5.1]
[47.1.1]
[13.1.4]
[3.2.4]
[8.3.3] [13.1.3]
[43.2.2]
java.awt.event
java.awt.event
java.awt.event
java.security
javax.swing
Klassenvariablen
[4.3.1] [4.3.3]
[8.3.1]
Kleiner-Operator
[5.3]
Kleinergleich-Operator
[5.3]
Kommentare
[4.1.2]
Komposition
[7.1.5.2]
Konstanten
[8.3.2] [9.4.1 (in
Interfaces)]
Konstruktoren
[7.3.6]
Konstruktorenverkettung
[7.3.6.2] [8.1.4.1]
Kontext-URL
[40.1.3]
Kontextmens
[30.6 (im AWT)]
[36.2.4 (in Swing)]
Konvertierungen auf primitiven Datentypen [4.6.1]
Konvertierungsfunktionen
[11.2.7]
Koordinatensystem
[23.2.3]
Kopieren einer Datei
[19.3.2.1]
Kopieren von Flchen
[23.4.2]
Kopieren von Objekten
[41.3.2]
Kreisbgen zeichnen
[23.3.5]
Kreise zeichnen
[23.3.4]
Kritischer Bereich
[22.4.2]
Kryptoanalyse
[47.1.1]
Kryptographie
[47] [47.1.1]
Kryptologie
[47.1.1]
Handbuch der Java-Programmierung, 3. Auflage,
Addison Wesley, Version 3.0
1998-2002 Guido Krger,
API
http://www.javabuch.de
<
>
>>
-LL10N
Label
Ladefaktor
LANDSCAPE
last
lastElement
lastIndexOf
lastModified
Late Binding
Laufzeitfehler
LayeredPane
Layoutmanager
LEADING
Lebensdauer
Leere Anweisung
left
LEFT
length
Lexikalische Elemente
LIFO-Prinzip
lightGray
Lightweight Components
LIKE
Line
Line.Info
[17.4]
[32.2]
java.awt
[49.2.1.1]
[26.3.2.2]
[15.7.2]
[14.2.2]
[11.2.5]
[21.3]
[7.1.6]
[12.1]
[36.1.1.1]
[31.2]
[36.2.3.2]
[4.3.3] [8.2]
[6.1.1]
[39.2.2]
[31.2.1 (FlowLayout)]
[32.2 (Label)] [36.2.3.2
(SwingConstants)]
[4.4.2 (Array)] [4.5.1
(Array)] [11.2.3
(String)] [11.4.5
(StringBuffer)] [20.2.2
(RandomAccessFile)]
[4.1]
[14.3]
[25.2]
[35.1.2.1]
[42.4.7.3]
[48.2.2]
javax.sound.sampled
[48.2.2.2]
Logische Operatoren
Logischer Typ
LOG_OPTION
Lokale Klassen
Lokale Variable
Lokalisierung
Long
long
LONG
Long.TYPE
longValue
Look-and-Feel
lookup
loop
lostOwnership
Lotus
lowerCase
LOWER_LEFT_CORNER
LOWER_RIGHT_CORNER
Lnge der Zeichenkette
Lschen von Flchen
[5.4]
[4.2.1]
[36.3.1.4]
[28.2.2.1]
[4.3.1] [6.1.3.2]
[17.4]
[10.2.1]
[4.2] [4.2.3] [10.2.1]
[17.4.3]
[43.3.1]
[10.2.1.2]
[35.1.2.2] [35.2.2.9
(Umschalten)]
[13.5.3.2] [46.2.4.2]
[46.2.5]
[39.3.1]
[30.7.2]
[1.1]
[18.2.3.3]
[38.1.1]
[38.1.1]
[11.2.3]
[23.4.2]
<
>
>>
java.lang
-Mmagenta
main
Main-Class
make
makefile
makeVisible
MalformedURLException
Manifest-Datei
Map
Map.Entry
mark
markSupported
MASTER_GAIN
Math
Mauscursor
max
MAX_PRIORITY
MAX_VALUE
McNealy, Scott
MD5
MDI
Mediator-Pattern
[25.2]
[2.2.1.2]
[8.3.3.1]
[13.1.6]
[39.1.1]
[50.2.2]
[13.4.1.3]
[13.3.2.2]
[13.3.2.2]
[38.3.3]
[40.1.1]
java.net
[13.4.1.3]
[44.3.3.2]
[15.1] [15.6.1] java.util
[15.6.1]
[18.3.1]
[19.3.1]
[18.3.1]
[19.3.1]
[48.2.2.3]
[16.1.2.1]
java.lang
[17.2] [17.5]
[27.5] [27.5.3]
[17.2.2]
[22.5.1]
[4.2.4.1]
[10.2.1.4]
[1.1]
[47.1.3]
[36.1.6]
[28.2.3]
[34.1.1.1]
[17.4.3]
[4.4.3]
[32.9]
[7.1.5.1] [8.1]
[9.1]
Mehrfachverzweigung
[6.2.2.2]
Mehrstufige Client-Server-Architekturen [42.1.2.2]
Mehrzeilige Kommentare
[4.1.2]
Member-Zugriff
[5.7.2.5]
Membervariablen
[7.1.3] [7.2.1]
[30.1]
Menu
[25.4]
menu
[30.1]
MenuBar
[30.1] [30.4.1]
MenuItem
[30.4.3]
MenuShortcut
[25.4]
menuText
Men
[27.5]
Meneintrge
[30.4]
Menleiste
[30.2]
Message Digest
[19.2.3.5]
[47.1.3]
Message Queue
[19.2.2.4]
[47.1.3]
MessageDigest
meta-inf
[13.4.1.3]
Meta-Ressourcen
[3.2.2.2]
Metal-Look-and-Feel
[35.2.1]
[48.3.2]
MetaMessage
[43.3.1]
Method
[44.6.1.3]
[44.6.1.3]
MethodDescriptor
Methoden
[7.1.3] [7.3]
[13.1.3]
[5.7.2.6 (aufruf)] [8.1.3
(berlagerung)]
MediaTracker
MEDIUM
Mehrdimensionale Arrays
Mehrfachselektion
Mehrfachvererbung
java.awt
java.awt
java.awt
java.awt
java.awt
java.security
javax.sound.midi
java.lang.reflect
java.beans
Metriken fr Fonts
Meyer, Bertrand
Microsoft Internet Explorer
middle
Middleware
Midi
Midi-Dateien
Midi-Ereignisse
Midi-Format
Midi-Nachrichten
MidiDevice
MidiEvent
MidiMessage
MidiSystem
MILLISECOND
MIME-Spezifikation
MIME-Typ
min
Minimum und Maximum
MINUTE
MIN_VALUE
MissingResourceException
Mixer
Mixer
Mixer.Info
mkdir
mkdirs
Modale Dialoge
Model-Delegate-Prinzip
Model-View-Controller-Prinzip
Modifier
Modifier
Modulo-Operator
Monitor
Monospaced
[24.3.2]
[6.4.1.4]
[1.2.2]
[39.2.2]
[42.1.2.1]
[48.1] [48.3]
[1.2.3]
[48.3.1]
[39.3.1]
[48.3.1]
[48.3.2]
[48.3.2]
[48.3.2]
[48.3.2]
[16.2.2]
[30.7.1]
[45.3.3]
[17.2.2]
[17.2.2]
[16.2.2]
[4.2.4.1]
[10.2.1.4]
[17.4.4.1]
[48.1]
[48.2.2]
[48.2.2.2]
[21.4.2]
[21.4.2]
[31.3]
[35.1.2.3]
[35.1.2.3]
[7.3.1] [8.2]
[43.3.1]
[5.2]
[22.1]
[24.2.1]
javax.sound.midi
javax.sound.midi
javax.sound.midi
javax.sound.midi
java.util
javax.sound.sampled
java.lang.reflect
[16.2.2]
[28.1.6.3]
[29.3]
[28.1.5]
[28.1.6.3]
[28.1.6.4]
[28.1.6.3]
[28.1.2]
[28.1.6.3]
[28.1.6.4]
[29.3]
[28.1.6.3]
mouseExited
[28.1.6.3]
MouseListener
[29.3]
MouseMotion-Ereignisse
[28.1.6.4]
MouseMotion-Events
[29.4]
[28.1.5]
MouseMotionAdapter
[28.1.6.4]
MouseMotionListener
[28.1.6.4]
mouseMoved
[28.1.6.3]
mousePressed
[28.1.6.3]
mouseReleased
[33.2.3]
MOUSE_EVENT_MASK
[33.2.3]
MOUSE_PRESSED
[37.1.2]
moveCaretPosition
[27.5.3]
MOVE_CURSOR
MS-Access
[42.3.1]
Multi-Tier-Architekturen
[42.1.2.2]
Multiple Document Interface
[36.1.6]
MULTIPLE_INTERVAL_SELECTION [37.3.1.1]
[38.2.3.1]
Multiplikation
[5.2]
[17.3.1]
multiply
mutable
[15.5.1]
[38.3.1]
MutableTreeNode
MVC
[28.2.3]
[35.1.2.3]
MONTH
Mouse-Ereignisse
Mouse-Events
MouseAdapter
mouseClicked
mouseDragged
mouseEntered
MouseEvent
java.awt.event
java.awt.event
java.awt.event
java.awt.event
java.awt.event
javax.swing.tree
<
>
>>
-NNAME
Name-Server
Namens-Service
Namenskonventionen
Naming
NaN
National Institute of Standards and
Technology
Natrliche Ordnung
Naughton, Patrick
NCSA Mosaic
Nebeneffekte
Nebenlufigkeit
negate
NEGATIVE_INFINITY
Netscape
Network Information Center
Networking-API
Netzwerk-ID
Netzwerkprogrammierung
Netzwerkschicht
new
New I/O Package
newAudioClip
newInstance
newLine
Newsgroups
next
[39.2.2]
[45.1.3.2]
[46.1.1]
[2.3.5]
[46.2.4.2]
[4.2.4.1] [10.2.1.4]
[47.1.3]
[15.7.1]
[1.1]
[1.1]
[5.1] [6.1.4.2]
[22.1]
[17.3.1]
[4.2.4.1] [10.2.1.4]
[1.1] [1.2.2 (Navigator)]
[45.1.3.1]
[1.2.4]
[45.1.3.1]
[45]
[45.1.2]
[4.5.2] [5.7.2.4] [7.2.2]
[4.4.1 (bei Arrays)]
[13.2.1.2]
[39.3.2]
[43.2.2 (Class)] [43.3.3
(Constructor)] [43.5.1
(Array)]
[18.2.3.1]
[1.3.2] [3.2.2.1]
[15.3.1] [42.2.3]
java.rmi
nextBytes
nextDouble
nextElement
nextFloat
nextGaussian
nextIndex
nextInt
nextLong
nextToken
NIC
NICHT-Operator
NoClassDefFoundError
nodeChanged
NONE
NONE_OPTION
NORMAL
NORM_PRIORITY
NORTH
NORTHEAST
NORTHWEST
NORTH_EAST
NORTH_WEST
NoSuchElementException
NoSuchMethodException
NOT
NOTE_OFF
NOTE_ON
notify
NotSerializableException
NO_SUCH_PAGE
null
NULL
Null-Layout
[47.1.4]
[16.1.2.1]
[1.2.4] [14.2.3]
[16.1.2.1]
[16.1.2.2]
[15.3.2]
[16.1.2.1]
[16.1.2.1]
[17.1.2]
[45.1.3.1]
[5.4]
[2.2.1.4] [2.2.2.2] [2.3.1]
[38.3.4]
[31.2.4]
[36.3.1.4]
[27.4]
[22.5.1]
[31.1.3] [31.2.4
(GridBagConstraints)]
[36.2.3.2
(SwingConstants)]
[31.2.4]
[31.2.4]
[36.2.3.2]
[36.2.3.2]
[15.3.1]
[43.3.2]
[42.4.7.3]
[48.3.3]
[48.3.3]
[22.4.3]
[41.1.2] [41.2.4]
[26.3.2.4]
[4.1.3] [4.5.1] [7.2.2]
[42.2.3]
[31.2] [31.2.5]
java.util
java.lang
java.io
null-Objekt
NullPointerException
NumberFormat
NumberFormatException
<
>
>>
java.lang
java.text
java.lang
[7.1.5.2]
[43.3.2]
[17.4.2]
[12.2.1]
-OOak
[1.1]
Oberlnge
[24.3.2]
Object
[8.1.2]
[8.1.2]
Object
java.lang
[39.2.2]
OBJECT
[19.3.2.3] [41.1.3]
ObjectInputStream
java.io
[19.2.2.3] [41.1.2]
java.io
ObjectOutputStream
Objektorientierte Programmierung [7.1.1]
Objektvariable
[7.1.5.3]
Observer-Pattern
[10.3.9]
ODBC-Treiber
[42.1.2.1]
ODER-Operator
[5.4]
Offscreen-Image
[34.2.4.3]
[36.1.4.2]
OK_CANCEL_OPTION
Online-Dokumentationen
[3.2.2.4]
OOP
[1.2.1] [7.1.1]
[26.4.1.2] [48.2.2.4 (Line)] [48.3.3
open
(MidiDevice)]
[45.4]
openConnection
[45.4]
openStream
Operator-Vorrangregeln
[5.8]
Operatoren
[5.2 (Arithmetische)] [5.3
(Relationale)] [5.4 (Logische)] [5.5
(Bitweise)] [5.6 (Zuweisungs-)] [5.7
(Sonstige)] [5.7.2 (fr Objekte)]
OptimizeIt
[49.3.3]
[42.4.7.3]
OR
[14.5.2]
or
Oracle
[1.1]
[25.2]
orange
[42.4.7.3]
ORDER BY
org.omg
org.w3c
org.xml
os.arch
os.name
os.version
out
OutOfMemoryError
OutputStream
OutputStream
OutputStreamWriter
[13.2.1.2]
[13.2.1.2]
[13.2.1.2]
[16.3.1]
[16.3.1]
[16.3.1]
[1.2.4] [16.3.2]
[49.2.5]
[19.1]
[19.1] [19.2.1] [49.2.4.1]
[18.2.2] [18.2.2.1]
<
>
>>
java.io
java.io
java.lang
-Ppack
package
package scoped
package-list
Pageable
pageDialog
PageFormat
PAGE_EXISTS
paint
paintBorder
paintChildren
paintComponent
paintValue
Pakete
PAN
Panel
Paper
ParallelPort
PARAM-Tag
Parameter von Methoden
parse
parseByte
parseDouble
parseFloat
parseInt
parseLong
PATH
path.separator
PCM
peek
[31.1.4] [33.2.2]
[13.2.4.1]
[8.2.1] [8.2.2.4]
[50.5.4]
[26.3.1] [26.3.2.5]
[26.3.2.3]
[26.3.2.2]
[26.3.2.4]
[23.2.2] [27.5.4]
[36.3.1.3]
[36.3.1.3]
[36.3.1.3]
[44.6.2.3]
[13.1.5] [13.2] [13.2.4
(Selbst erstellen)]
[48.2.2.3]
[27.1] [31.2.6] [44.5]
[26.3.2.2]
[26.4.1.2]
[39.2.1]
[7.3.3]
[17.4.2]
[10.2.1.3]
[10.2.1.3]
[10.2.1.3]
[10.2.1.3]
[10.2.1.3]
[2.3.7.2] [2.3.7.3]
[16.3.1]
[48.2.3]
[14.3]
java.awt.print
java.awt.print
java.awt
java.awt.print
javax.comm
Performance-Tuning
PersistenceService
Persistenz
PGP
PicoJava
pink
Pipe
PipedInputStream
PipedOutputStream
PipedReader
[49]
[13.5.3.1]
[41.1.1]
[47.1.5]
[1.1]
[25.2]
[22.4.4]
[19.3.2.5] [22.4.4]
[19.2.2.4] [22.4.4]
[18.2.2] [18.3.2]
[22.4.4]
[18.2.2] [18.3.2]
PipedWriter
[22.4.4]
[19.2.3.4]
pkunzip
[24.2.1]
PLAIN
[30.7.2]
plainTextFlavor
[36.1.4.1]
PLAIN_MESSAGE
[39.3.1]
play
Pluggable Look-and-Feel
[1.2.3] [35.1.2.2]
Plugin fr HTML-Browser
[40.4]
[29.3]
Point
Policy-Datei
[47.2.3] [47.3.4]
[47.3.4.2] [50.10.2]
policytool
[23.3.3]
Polygon
Polygone zeichnen
[23.3.3]
Polymorphismus
[7.1.6] [8.4.2]
[14.3]
pop
Popup-Mens
[30.6 (im AWT)]
[36.2.4 (in Swing)]
[30.6]
PopupMenu
[48.2.2]
Port
Port-Nummer
[40.1.1] [45.1.4]
[26.3.2.2]
PORTRAIT
[26.4.1.2]
PORT_PARALLEL
[26.4.1.2]
PORT_SERIAL
Positionierung des Dateizeigers [20.2.1]
javax.jnlp
java.io
java.io
java.io
java.io
java.awt
java.awt
java.awt
javax.sound.sampled
POSITIVE_INFINITY
Postconditions
Postdekrement
Postinkrement
pow
PPQ
Preconditions
Prepared Statements
PreparedStatement
prepareStatement
Pretty Good Privacy
previous
previousIndex
Primitive Datentypen
Primitive Variable
print
Printable
printAll
printDialog
PrinterException
PrinterJob
PrintGraphics
PrintJob
println
PrintService
printStackTrace
PrintStream
PrintWriter
private
[4.2.4.1] [10.2.1.4]
[6.4.1.4]
[5.2]
[5.2]
[17.2.3] [17.3.1]
[48.3.4]
[6.4.1.4]
[42.4.6]
[42.4.6]
java.sql
[42.4.6]
[47.1.5]
[15.3.2]
[15.3.2]
[4.2]
[7.1.5.3]
[18.2.3.2 (PrintWriter)]
[19.2.3.2
(PrintStream)] [26.2.3
(Component)]
[26.3.2.4 (PrinterJob)]
[26.3.1] [26.3.2.4]
java.awt.print
[26.2.3]
[26.3.2.3]
[26.3.2.4]
java.awt.print
[26.3.1] [26.3.2.1]
java.awt.print
[26.2.1]
java.awt
[26.2.1]
java.awt
[16.3.2] [18.2.3.2]
[19.2.3.2]
[13.5.3.1]
javax.jnlp
[12.2.2]
[1.2.4] [16.3.2]
java.io
[19.2.3.2]
[18.2.2] [18.2.3]
java.io
[18.2.3.2]
[1.2.1] [8.1.3.1] [8.2.1]
[8.2.2.1] [49.2.2]
[16.4.2]
Process
java.lang
[28.2.4]
processActionEvent
processComponentEvent [33.2.3]
[28.2.4]
processEvent
[33.2.3]
processFocusEvent
[28.2.4] [33.2.3]
processKeyEvent
[28.2.4] [30.6] [33.2.3]
processMouseEvent
Producer/Consumer-Beispiel
[22.4.3]
Profiler
[49.3.1] [50.2.3]
Programmende
[22.2.1]
[48.3.3]
PROGRAM_CHANGE
Projektverwaltung
[13.3.2]
[14.4.4] [16.3.1]
Properties
java.util
[44.4.1]
propertyChange
[44.4.1]
PropertyChangeEvent
java.beans
java.beans
PropertyChangeListener[44.4.1]
java.beans
PropertyChangeSupport [44.4.1]
[44.6.1.2]
java.beans
PropertyDescriptor
java.beans
PropertyEditorSupport [44.6.2]
[14.4.4] [16.3.1]
propertyNames
[47.3.4.2]
PropertyPermission
java.util
java.util
PropertyResourceBundle[17.4.4.4]
java.beans
PropertyVetoException [44.4.2]
[1.2.1] [8.2.1] [8.2.2.2]
protected
Protokoll
[45.1.2]
Provider fr Security-API
[47.1.6.2]
Proxy-Server
[45.1.6]
Prdekrement
[5.2]
Prinkrement
[5.2]
Prprozessor
[4.1.4]
Pseudo-Zufallszahlen
[47.1.4]
[1.2.1] [8.2.1] [8.2.2.3]
public
[13.2.4.3] [13.3.2.1
(Klassen in Datei)]
Public-Key-Verschlsselung
[47.1.5]
[14.3]
push
PushbackInputStream
PushbackReader
put
putAll
[19.3.3.2]
[18.3.2] [18.3.3.3]
[14.4.1] [15.6.1]
[15.6.1]
<
>
>>
java.io
java.io
-Q[36.1.4.1]
[15.4.1]
QUESTION_MESSAGE
Queue
<
>
>>
Titel
<<
DOC
API
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-RRadiobuttons
Random
Random-Access-I/O
RandomAccessFile
read
read-Methoden
readBoolean
readByte
readChar
readDouble
Reader
readFloat
readFully
readInt
readLine
readLong
readObject
readShort
readUnsignedByte
readUnsignedShort
readUTF
ready
rebind
Receiver
Rechtecke zeichnen
Rechtsschiebeoperator
Rectangle
red
Red-Black-Tree
Referenzgleichheit und -ungleichheit
Referenztypen
Reflection
regionMatches
registerKeyboardAction
Registry
[32.5]
[1.2.4] [16.1.1]
[20]
[19.2.3.3] [20.1] [49.2.4.3]
[18.3.1] [19.3.1]
[20.3]
[20.3] [41.1.3]
[20.3] [41.1.3]
[20.3] [41.1.3]
[20.3] [41.1.3]
[18.3.1]
[20.3] [41.1.3]
[20.3]
[20.3] [41.1.3]
[18.3.3.1] [20.3]
[20.3] [41.1.3]
[41.1.3]
[20.3] [41.1.3]
[20.3]
[19.3.3.3] [20.3]
[20.3] [41.1.3]
[18.3.1]
[46.2.4.2]
[48.3.2]
[23.3.2]
[5.5]
[34.2.3]
[25.2]
[15.7.2]
[5.7.2.2]
[4.5]
[1.2.4] [41.1.2] [43]
[11.2.4]
[36.3.1.10]
[2.1.2.1]
java.util
java.io
java.io
javax.sound.midi
java.awt
Relationale Operatoren
remainder
Remote
Remote Method Invocation
Remote-Interface
Remote-Objekte
Remote-Referenzen
RemoteException
remove
[5.3]
[17.3.1]
[46.2.2]
java.rmi
[1.2.4] [46]
[46.1.1]
[46.1.1]
[46.1.1]
[46.2.2]
java.rmi
[15.2.1 (List)] [15.3.1
(Iterator)] [15.6.1 (Map)]
[30.2 (MenuBar)] [30.3
(Menu)] [31.1.3
(Container)] [32.9 (List)]
[38.3.1
(DefaultMutableTreeNode)]
[36.2.2.3]
removeActionListener
[15.2.1] [38.1.3]
removeAll
[38.3.1]
removeAllChildren
[37.3.2]
removeAllItems
removeColumnSelectionInterval[38.2.3.3]
[37.3.2]
removeItem
[37.3.2]
removeItemAt
[38.3.4]
removeNodeFromParent
removePropertyChangeListener [44.4.1]
[38.2.3.3]
removeRowSelectionInterval
[37.3.1.1]
removeSelectionInterval
[38.1.3]
removeTabAt
[38.2.5]
removeTableModelListener
removeVetoableChangeListener [44.4.2]
[21.4.2]
renameTo
Rendering von Tabellen
[38.2.7]
[29.2] [33.2.3]
repaint
repaint-Schleife
[34.2.1.1]
[11.3.3] [11.2.6 (String)]
replace
[11.4.4 (StringBuffer)]
[32.9]
replaceItem
[32.7]
replaceRange
Request For Comments
[45.1.5]
[38.1.3]
requestDefaultFocus
[29.5] [33.2.3]
requestFocus
[28.1.2]
RESERVED_ID_MAX
reset
ResourceBundle
Ressourcen
Ressourcen-Dateien
Ressourcendatei
Restwertoperator
ResultSet
ResultSetMetaData
resume
retainAll
return
revalidate
REVERSE_LANDSCAPE
RFC
RFC 1521
RFC 1522
RGB-Farbmodell
right
RIGHT
Rivest, Ron
rmf-Format
RMI
RMI-Registry
rmic
rmiregistry
RMISecurityManager
rollback
RootPane
RootPaneContainer
round
ROUND_CEILING
ROUND_DOWN
ROUND_FLOOR
ROUND_HALF_DOWN
ROUND_HALF_EVEN
[18.2.2.2
(CharArrayWriter)] [18.3.1
(Reader)] [19.3.1
(InputStream)] [41.2.3
(ObjectOutputStream)]
[17.4.4]
java.util
[17.4.4]
[13.4.2]
[30.1]
[5.2]
[42.2.3]
java.sql
[42.4.1]
java.sql
[22.2.3]
[15.2.1]
[5.7.2.6] [7.3.4] [12.2.6]
[36.3.1.8]
[26.3.2.2]
[45.1.5]
[30.7.1]
[30.7.1]
[25.1]
[39.2.2]
[31.2.1 (FlowLayout)] [32.2
(Label)] [36.2.3.2
(SwingConstants)]
[47.1.3]
[39.3.1]
[46]
[46.1.1]
[46.2.3.2] [50.12.2]
[46.2.4.1] [50.13.2]
[46.2.4.3]
java.rmi
[42.4.3]
[36.1.1.1]
[36.1.1.1]
javax.swing
[17.2.4]
[17.3.2]
[17.3.2]
[17.3.2]
[17.3.2]
[17.3.2]
[17.3.2]
[17.3.2]
[17.3.2]
[38.2.8]
[47.1.5]
[13.2.2.3]
[22.1] [22.2.4.2]
[17.2.4]
[22.1] [22.3] [22.3.2]
[16.4.1]
[12.3.2.1]
[47.3.4.2]
[7.3.4]
ROUND_HALF_UP
ROUND_UNNECESSARY
ROUND_UP
rowAtPoint
RSA
rt.jar
run
Runden und Abschneiden
Runnable
Runtime
RuntimeException
RuntimePermission
Rckgabewert einer Methode
Titel
<<
>
>>
DOC
API
java.lang
java.lang
java.lang
java.lang
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-SSamples
Sampling
Sandbox-Konzept
SansSerif
save
scale
Schachteln
Schiebeoperationen
Schieberegler
Schleifen
Schleifeninvarianten
Schlieen eines Fensters
Schlssel
Schlsseltext
Schlsseltransformation
Schlsselwrter
Schneier, Bruce
Schnittstellen (Interfaces)
Schriftarten
scrollbar
Scrollbar
SCROLLBARS_ALWAYS
SCROLLBARS_AS_NEEDED
SCROLLBARS_BOTH
SCROLLBARS_HORIZONTAL_ONLY
SCROLLBARS_NEVER
SCROLLBARS_NONE
SCROLLBARS_VERTICAL_ONLY
ScrollPane
search
SECOND
SecureRandom
SecurityException
SecurityManager
seek
[48.1]
[48.2.1]
[47.2.2]
[24.2.1]
[14.4.4]
[17.3.2]
[18.2.3 (von AusgabeStreams)] [18.3.3 (von
Eingabe-Streams)]
[31.2.6 (von
Layoutmanagern)]
[5.5]
[32.10]
[6.3]
[6.4.1.4]
[23.2.4]
[47.1.1]
[47.1.1]
[14.4]
[4.1.3]
[47.1.2.3]
[9.1]
[24.2]
[25.4]
[32.10]
[32.11]
[32.11]
[32.7]
[32.7]
[32.11]
[32.7]
[32.7]
[25.4] [32.11]
[14.3]
[16.2.2]
[47.1.4]
[47.3]
[47.3.5]
[20.2.1]
java.awt
java.awt
java.security
java.lang
java.lang
Segment7
SELECT
select
SELECT-Anweisung
selectAll
semidynamische Arrays
send
Separatoren
Sequence
SequenceInputStream
Sequencer
Sequencer
Sequenz
Sequenzer
Serialisierte Beans
Serialisierung
Serializable
SerialPort
serialver
serialVersionUID
Serif
Server-Hotspot
ServerSocket
ServiceManager
Services
Servlet-API
set
Set
setAccelerator
setActionCommand
setAsText
setAutoCommit
setAutoResizeMode
setBackground
setBlockIncrement
setBoolean
setBorder
setBounds
setByte
[33.2.2]
[42.4.7.3]
[32.6] [32.8] [32.9]
[42.2.3]
[32.6] [38.2.3.3]
[1.2.1]
[48.3.3 (Receiver)]
[30.3]
[48.3.2]
javax.sound.midi
[19.3.2.4]
java.io
[48.1]
[48.3.2]
javax.sound.midi
[48.3.1]
[48.3.1]
[44.3.4]
[1.2.4] [41.1.1]
[41.1.2] [41.1.3]
java.io
[26.4.1.2]
javax.comm
[41.2.1] [50.8.2]
[41.2.1]
[24.2.1]
[50.2.2]
[45.2.2] [45.3.1]
java.net
[13.5.3.2]
javax.jnlp
[13.5.3.1]
[1.3.2]
[2.3.7.3] [14.5.1
(BitSet)] [15.3.2
(ListIterator)] [16.2.2
(Calendar)] [43.4
(Field)] [43.5.2 (Array)]
[15.1] [15.5.1]
java.util
[36.2.2.3]
[30.4.3 (MenuItem)]
[30.5 (MenuItem)]
[32.3 (Button)]
[44.6.2.1]
[42.4.3]
[38.2.2]
[23.3] [27.5.4]
[32.10] [37.4.1]
[43.5.2]
[35.2.2.6] [36.3.1.1]
[27.3] [31.2.5]
[43.5.2]
setCaretPosition
setCellSelection
setChar
setCharAt
setCheckboxGroup
setClip
setClosable
setColor
setColumnHeaderView
setColumns
setColumnSelectionAllowed
setColumnSelectionInterval
setComponentAt
setConstraints
setContentPane
setContents
setCopies
setCorner
setCurrent
setCursor
setDebugGraphicsOptions
setDecimalSeparatorAlwaysShown
setDefaultButton
setDefaultCloseOperation
setDefaultRenderer
setDouble
setDoubleBuffered
setEchoChar
setEchoCharacter
setEditable
setEnabled
setEnabledAt
setErr
setFlashCount
setFlashTime
setFloat
setFont
setForeground
setGridColor
setGroupingSize
setHeaderValue
[32.6] [37.1.2]
[38.2.3.1]
[43.5.2]
[11.4.4]
[32.5]
[23.4.3]
[36.1.6.2]
[25.3]
[38.1.1]
[32.6]
[38.2.3.1]
[38.2.3.3]
[38.1.3]
[31.2.4]
[36.1.2]
[30.7.2]
[26.3.2.1]
[38.1.1]
[32.5]
[27.5.3]
[36.3.1.4]
[17.4.2]
[37.2.1]
[36.1.6.2]
[38.2.7]
[43.4] [43.5.2]
[36.3.1.6]
[37.1.3]
[32.6] [35.2.2.5]
[32.6] [37.3.2]
[27.3 (Component)]
[30.4.1 (MenuItem)]
[36.2.2.3 (JMenuItem)]
[37.2.1 (JButton)]
[38.1.3]
[16.3.2] [19.2.3.2]
[36.3.1.4]
[36.3.1.4]
[43.5.2]
[24.2.1] [27.5.5]
[27.5.4]
[38.2.2]
[17.4.2]
[38.2.6]
setHorizontalAlignment
setHorizontalTextPosition
setIcon
setIconifiable
setIconImage
setIn
setIndeterminate
setInt
setIntercellSpacing
setJMenuBar
setJobName
setLabel
setLayout
setLength
setLineNumber
setLineWrap
setLocation
setLong
setLookAndFeel
setMajorTickSpacing
setMaximizable
setMaximum
setMaximumSize
setMenuBar
setMessage
setMinimum
setMinimumSize
setMinorTickSpacing
setMnemonic
setModal
setName
setNextFocusableComponent
setOneTouchExpandable
setOpaque
setOut
setPage
setPaintLabels
setPaintTicks
setPreferredSize
setPrintable
setPriority
setPropertyEditorClass
setReceiver
[37.1.1] [37.2.1]
[36.2.3.2] [37.1.1]
[37.2.1]
[36.2.3.2]
[36.1.6.2]
[27.5.2]
[16.3.2]
[37.4.3]
[43.4] [43.5.2]
[38.2.2]
[36.2.2.3]
[26.3.2.1]
[30.4.1] [32.3] [32.4]
[31.1.2] [31.2]
[20.2.2]
[18.3.3.2]
[37.1.4]
[27.3]
[43.5.2]
[35.2.2.9]
[37.4.2]
[36.1.6.2]
[37.4.1]
[36.3.1.7]
[30.2]
[48.3.3]
[37.4.1]
[36.3.1.7] [38.1.2]
[37.4.2]
[36.2.2.3] [37.2.1]
[31.3]
[22.5.1]
[36.3.1.9]
[38.1.2]
[36.3.1.5]
[16.3.2] [19.2.3.2]
[26.3.2.5]
[37.4.2]
[37.4.2]
[36.3.1.7]
[26.3.2.4]
[22.5.1]
[44.6.1.2]
[48.3.4]
setResizable
setRootPaneCheckingEnabled
setRootVisible
setRowHeaderView
setRowHeight
setRowMargin
setRowSelectionAllowed
setRowSelectionInterval
setScale
setScrollPosition
setSeed
setSelected
setSelectedIndex
setSelectedIndices
setSelectedItem
setSelectionBackground
setSelectionEnd
setSelectionForeground
setSelectionInterval
setSelectionMode
setSelectionModel
setSelectionPath
setSelectionPaths
setSelectionStart
setSequence
setShort
setShortCut
setShowGrid
setShowHorizontalLines
setShowVerticalLines
setSize
setSnapToTicks
setSoTimeout
setState
setStringPainted
setTabPlacement
setTabSize
setTempoInBPM
setter-Methoden
[31.3] [36.1.6.2]
[36.1.1.2]
[38.3.1]
[38.1.1]
[38.2.2]
[38.2.2]
[38.2.3.1]
[38.2.3.3]
[17.3.2]
[32.11]
[47.1.4]
[36.2.3.3] [37.2.2]
[37.3.1.1] [37.3.2]
[38.1.3]
[37.3.1.1]
[37.3.2]
[38.2.2]
[37.1.2]
[38.2.2]
[37.3.1.1]
[37.3.1.1] [38.2.3.1]
[38.3.2.1]
[38.3.2.1]
[38.3.2.3]
[38.3.2.3]
[37.1.2]
[48.3.4]
[43.5.2]
[30.4.3]
[38.2.2]
[38.2.2]
[38.2.2]
[27.3] [31.2.5] [32.11]
[37.4.2]
[45.2.3]
[27.4 (Frame)] [30.4.2
(CheckboxMenuItem)]
[32.4 (Checkbox)]
[36.2.3.3
(JCheckBoxMenuItem)]
[37.4.3]
[38.1.3]
[37.1.4]
[48.3.4]
[44.2.3]
setText
setTime
setTimeZone
setTitle
setToolTipText
setTransactionIsolation
setUnitIncrement
setUserObject
setValue
setValueAt
setVerticalAlignment
setVisible
setVisibleAmount
setWindowAdapter
setWrapStyleWord
SHA
shallow copy
Shape
Shell
Sheridan, Mike
short
Short
SHORT
Short-Circuit-Evaluation
Short.TYPE
ShortMessage
show
showConfirmDialog
showDocument
showInputDialog
showMessageDialog
showStatus
Sicherheit
Sichtbarkeit
sign
Signatur einer Methode
Signature
signedjar
signierte Applets
java.awt
java.lang
javax.sound.midi
java.security
signum
SimpleBeanInfo
sin
Singleton-Pattern
SINGLE_INTERVAL_SELECTION
SINGLE_SELECTION
SINGLE_TREE_SELECTION
size
Skeleton
skip
skipBytes
sleep
SMPTE-Format
Socket
Socket
SocketException
SocketPermission
Sonstige Operatoren
sort
SortedMap
SortedSet
Sortierte Collections
Sound
Soundausgabe
Soundbanks
source
SourceDataLine
SOUTH
SOUTHEAST
SOUTHWEST
SOUTH_EAST
SOUTH_WEST
Speichermanagement
SpinnerDateModel
SpinnerListModel
SpinnerModel
SpinnerNumberModel
SplashScreen
Sprachmerkmale
[17.3.1]
[44.6.1]
[17.2.1]
[10.3.1]
[37.3.1.1] [38.2.3.1]
[37.3.1.1] [38.2.3.1]
[38.3.2.1]
[14.2.1 (Vector)] [15.1
(Collection)] [15.6.1
(Map)] [18.2.2.2
(CharArrayWriter)]
[46.1.2]
[18.3.1] [19.3.1]
[20.2.1]
[16.3.5] [22.2.4.1]
[48.3.4]
[45.2.2]
[45.2.2]
[45.2.3]
[47.3.4.2]
[5.7]
[15.8.1] [16.5]
[15.1] [15.7.3]
[15.1] [15.7.2]
[15.7]
[48]
[1.2.3] [39.3]
[48.1]
[50.1.3]
[48.2.2]
[31.1.3] [31.2.4
(GridBagConstraints)]
[36.2.3.2
(SwingConstants)]
[31.2.4]
[31.2.4]
[36.2.3.2]
[36.2.3.2]
[4.5.2]
[37.1.5]
[37.1.5]
[37.1.5]
[37.1.5]
[36.1.2]
[1.2.1]
java.beans
java.net
java.net
java.net
java.util
java.util
javax.sound.sampled
javax.swing
javax.swing
javax.swing
javax.swing
Sprunganweisungen
SQL-2 Entry-Level
SQLException
sqrt
Stack
Standard-Font
Standard-Sichtbarkeit
Standarderweiterungen
Standardschriftarten
Standardwert
Star Seven
start
Statische Konstruktoren
statische Methoden
Statische Variable
Statuszeile des HTML-Browsers
Stelligkeit eines Operators
stop
store
Stored Procedures
Stream
StreamTokenizer
String
String einlesen
String-Literale
[6.3.3.3]
[42.1.2.3]
[42.2.1] [42.2.4]
java.sql
[17.2.3]
[14.3]
java.util
[27.5]
[8.2.1]
[13.2.1.2]
[24.2.2]
[4.2]
[1.1]
[22.2.1 (Thread)]
[36.1.5 (JApplet)]
[39.1.1 (Applet)]
[39.1.3.3 (Applet)]
[48.2.2.4 (Clip)] [48.3.4
(Sequencer)]
[2.2.2.1]
[11.2.4]
[37.4.2]
[42.2.2]
java.sql
[8.1.3.1] [8.2.2.5]
[8.3.1] [8.3.3] [8.3.4
(Statischer
Konstruktor)]
[8.3.4]
[8.3.3]
[8.3.1]
[39.1.4.2]
[5.1]
[22.2.2 (Thread)]
[36.1.5 (JApplet)]
[39.1.3.4 (Applet)]
[39.3.1 (AudioClip)]
[48.2.2.4 (Clip)] [48.3.4
(Sequencer)]
[14.4.4]
[42.1]
[18.1]
[17.1.2]
java.io
[1.2.4] [4.5.1] [11.1]
java.lang
[4.2.2.1 (Literale)]
[2.3.3]
[11.3.2.1]
String-Verkettung
[5.7.2.1] [11.2.3]
[49.2.1.1]
[5.7.2.2]
String.intern
[1.2.4] [4.5.1] [11.4]
StringBuffer
java.lang
[19.3.2.2]
java.io
StringBufferInputStream
[30.7.2]
stringFlavor
java.lang
StringIndexOutOfBoundsException [11.2.2] [11.4.4]
[18.3.2] [18.3.2.2]
java.io
StringReader
Strings
[11]
[30.7.2]
java.awt.datatransfer
StringSelection
[17.1] [31.3]
StringTokenizer
java.util
[24.3.2]
stringWidth
[18.2.2] [18.2.2.2]
StringWriter
java.io
Stub
[46.1.2]
Subqueries
[42.4.7.3]
[15.7.2]
subSet
[11.2.2] [11.3.3]
substring
[49.2.1.4]
[17.3.1]
subtract
Subtraktion
[5.2]
Suchen in Zeichenketten
[11.2.5]
SUN HotJava
[1.2.2]
[13.2.2.2]
sun.boot.class.path
[18.2.2.1] [18.3.2.1]
sun.io
[42.2.1]
sun.jdbc.odbc.JdbcOdbcDriver
SunWorld '95
[1.1]
[8.1.4.1]
super
[9.4.2]
super.clone
Superklassenkonstruktor
[8.1.4.1]
Superklassenmethoden
[8.1.3.2]
[44.6.2.3]
supportsCustomEditor
supportsTransactionIsolationLevel[42.4.3]
[22.2.3]
suspend
Swing
[1.1] [1.2.3] [23.1.2.2]
[35.1.1]
[36.2.3.2]
SwingConstants
javax.swing
[35.2.2.9]
javax.swing
SwingUtilities
[1.2.1] [6.2] [6.2.2.2]
switch
Symantec
[1.1]
Symboldarstellung
[27.4]
symmetrische Verschlsselung
[47.1.2.2]
Synchronisieren
[15.8.2 (von
Collections)] [22.4 (von
Threads)]
synchronized
Synthesizer
Synthesizer
SysexMessage
System
System-Properties
System.currentTimeMillis
System.err
System.in
System.out
System.out.print
System.out.println
SystemColor
Systemfarben
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
javax.sound.midi
javax.sound.midi
java.lang
java.awt
Titel
<<
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-TTA Trustcenter
TableCellRenderer
tableChanged
TableColumn
TableColumnModel
TableModel
TableModelListener
tailSet
tan
TargetDataLine
TCP/IP
TCP/UDP
Temporre Dateien
text
TextArea
Textausgaben
TextComponent
TextEvent
TextField
textHighlight
textHighlightText
textInactiveText
TextListener
textText
texttop
textValueChanged
TEXT_CURSOR
Thawte
this
Thread
Thread-Gruppen
Thread-Synchronisation
[47.1.7]
[38.2.7]
javax.swing.table
[38.2.8]
[38.2.6]
javax.swing.table
[38.2.1] [38.2.6] javax.swing.table
[38.2.1] [38.2.5] javax.swing.table
[38.2.5]
javax.swing.event
[15.7.2]
[17.2.1]
[48.2.2]
javax.sound.sampled
[45.1.2]
[45.1.2]
[21.5.1]
[25.4]
[32.7]
java.awt
[1.2.4]
[32.6]
java.awt
[28.1.2] [28.1.6.11] java.awt.event
[32.6]
[32.6]
java.awt
[25.4]
[25.4]
[25.4]
[28.1.6.11] [32.6] java.awt.event
[25.4]
[39.2.2]
[28.1.6.11] [32.6]
[27.5.3]
[47.1.7]
[7.3.2] [7.3.6.2]
[8.1.4.1] [13.1.2]
[22.1]
java.lang
[22.5.2]
[22.4]
ThreadGroup
Threads
throw
Throwable
throws
Time
Timecodes
Times New Roman
TimesRoman
Timestamp
TimeZone
Titelleiste
TitledBorder
toArray
toCharArray
toLowerCase
Toolkit
Toolkit-Pattern
Tooltips
TOP
top
toString
toUpperCase
Track
[22.5.2]
java.lang
[22.1] [34.2.1.2
(fr Animationen)]
[37.4.3 (in Swing)]
[12.3.3]
[12.2.2] [12.2.3] java.lang
[10.2.1.1] [12.3.2]
[12.3.3]
[42.2.3]
java.sql
[48.1]
[24.2.1]
[24.2.1]
[42.2.3]
java.sql
[17.4]
java.util
[27.5]
[36.3.1.1]
javax.swing.border
[15.1]
[18.2.2.2]
[11.2.6]
[24.2.2] [34.1.1] java.awt
[10.3.4.3]
[35.1.2.1]
[35.2.2.6]
[36.3.1.2]
[36.2.3.2]
[39.2.2]
[5.7.2.1] [8.1.2]
[10.2.1.2 (WrapperKlassen)] [11.4.6
(StringBuffer)]
[12.2.2
(Throwable)]
[18.2.2.2
(CharArrayWriter)]
[18.2.2.2
(StringWriter)]
[49.2.1.3
(StringBuffer)]
[11.2.6] [18.2.3.3]
[48.3.2] [48.3.4] javax.sound.midi
[32.10]
TRACK
Tracks
[48.1]
[36.2.3.2]
TRAILING
Transaction Isolation Level
[42.4.3]
[42.4.3]
TRANSACTION_NONE
TRANSACTION_READ_COMMITTED [42.4.3]
TRANSACTION_READ_UNCOMMITTED[42.4.3]
TRANSACTION_REPEATABLE_READ [42.4.3]
[42.4.3]
TRANSACTION_SERIALIZABLE
Transaktionen
[42.4.3]
[30.7.1]
Transferable
[41.1.2] [41.2.2]
transient
[48.3.2]
Transmitter
Transparente Komponente
[36.3.1.5]
Transportschicht
[45.1.2]
[15.7.2] [15.7.3]
TreeMap
[38.3.1]
TreeModel
[38.3.4]
TreeModelEvent
[38.3.4]
TreeModelListener
[38.3.1]
TreeNode
[38.3.2.2]
TreePath
[38.3.2.2]
TreeSelectionEvent
[38.3.2.2]
TreeSelectionListener
[38.3.2.1]
TreeSelectionModel
[15.7.2]
TreeSet
Treibermanager
[42.2.1]
Trigger
[42.1]
[11.2.2] [49.2.1.4]
trim
[4.1.3] [4.2]
true
[4.2.1.1]
[12.2.1]
try
try-catch-Anweisung
[12.2.1]
[43.3.1]
TYPE
Type-Cast-Operator
[5.7.1.2]
[42.4.1]
Types
Typkonvertierungen
[4.6]
Typsicherheit
[13.3.2.1]
Typberprfungen
[4.3.1]
java.awt.datatransfer
javax.sound.midi
java.util
javax.swing.tree
javax.swing.event
javax.swing.event
javax.swing.tree
javax.swing.tree
javax.swing.event
javax.swing.event
javax.swing.tree
java.util
java.sql
Titel
<<
>
>>
-UUDP
UI Delegate
UIManager
ULAW
UML
Umrandungen
UnavailableServiceException
unbind
UND-Operator
Ungarische Notation
Ungleichheits-Operator
UnicastRemoteObject
Unicode
[45.1.2]
[35.1.2.3]
[35.2.2.9]
[48.2.3]
[3.2.4]
[35.2.2.6]
[13.5.3.2]
[46.2.4.2]
[5.4]
[2.3.5]
[5.3]
[46.2.3.1]
[4.1.1] [4.2.2]
[4.2.2.1
(EscapeSequenzen)]
Unified Modeling Language
[3.2.4]
Uniform Resource Locator
[40.1.1]
[42.4.7.3]
UNION
[32.10]
UNIT_DECREMENT
[32.10]
UNIT_INCREMENT
[45.2.1]
UnknownHostException
[26.3.2.5]
UNKNOWN_NUMBER_OF_PAGES
[18.3.3.3]
unread
[19.3.3.2]
UnsupportedLookAndFeelException[35.2.2.9]
UnsupportedOperationException [15.1]
Unterlnge
[24.3.2]
Untermens
[30.4.4]
Unvernderliche Collections
[15.8.3]
unwrapping
[43.3.1]
javax.swing
javax.jnlp
java.rmi.server
java.net
javax.swing
java.lang
UPDATE
update
updateComponentTreeUI
UPPER_LEFT_CORNER
UPPER_RIGHT_CORNER
URL
URL
URLConnection
Usenet-Newsgroups
User Datagram Protocol
user.dir
user.home
user.name
user.timezone
UTF-8-Codierung
berladen von Methoden
berlagern von Methoden
bersetzen des Quelltextes
<
>
>>
[42.2.4]
[42.4.7.2]
[34.2.4.1]
[47.1.3]
[35.2.2.9]
[38.1.1]
[38.1.1]
[40.1.1] [40.1.3
(relativer)]
[40.1.1] [45.4] java.net
[45.4]
java.net
[3.2.2.1]
[45.1.2]
[16.3.1]
[16.3.1]
[16.3.1]
[16.2.2]
[19.2.3.3]
[7.3.5]
[7.1.6] [8.1.3]
[2.2.1.3]
-V[36.3.1.8]
[36.3.1.8]
[37.3.1.1] [38.3.2.2]
[11.2.7]
[15.6.1]
[1.1]
[4.3] [6.1.3]
[7.1.5.1]
[1.2.4] [14.2] [15.2.2]
[49.2.3]
Verdecken von Variablen
[13.1.2]
Vererbung
[7.1.5.1] [8.1]
Vergleichen von Zeichenketten
[11.2.4]
[47.1.6.2]
verify
VeriSign
[47.1.7]
Verkettung
[5.7.2.1 (von Strings)]
[7.3.6.2 (von
Konstruktoren)]
Verknfung auf dem Desktop
[2.3.6.2]
Verschlsseln
[47.1.1]
Versionierung von Klassen
[41.2.1]
[31.2.4
VERTICAL
(GridBagConstraints)]
[32.10 (Scrollbar)]
[36.2.3.2
(SwingConstants)]
[38.1.1]
VERTICAL_SCROLLBAR_ALWAYS
VERTICAL_SCROLLBAR_AS_NEEDED[38.1.1]
[38.1.1]
VERTICAL_SCROLLBAR_NEVER
[38.1.2]
VERTICAL_SPLIT
Verwalten von Threads
[22.5]
validate
Validierung
valueChanged
valueOf
values
van Hoff, Arthur
Variablen
Vaterklasse
Vector
java.util
[40.1]
[21.4]
[6.2]
[8.2]
[15.5.1]
[44.4.2]
[44.4.2]
[44.4.2]
[15.6.1]
[32.11]
[32.11]
[1.2.2] [49.1]
[10.3.8]
[1.1]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[28.2.1] [29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
[29.6]
java.beans
java.beans
Vlissides, John
VM
Void
void
Void.TYPE
volatile
Vordefinierte Pakete
Vordergrundfarbe
Vorrangregeln
VSPACE
[10.3]
[1.2.2]
[10.2.1]
[5.7.2.6] [7.3.4] [10.2.1]
[43.3.1]
[8.2.2.8]
[13.2.1.2]
[27.5]
[5.8]
[39.2.2]
<
>
>>
java.lang
Titel
<<
DOC
API
0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
[20.1]
[22.2.2] [22.4.3]
[16.4.2]
[34.1.1.1]
[27.5.3]
[36.1.4.1]
[22.4.3]
[42.2.3]
[1.2.3] [39.3.1]
[48.2.2]
WebRunner
[1.1]
WebStart
[13.5.1]
[16.2.2]
WEEK_OF_MONTH
[16.2.2]
WEEK_OF_YEAR
[31.2.4]
weightx
[31.2.4]
weighty
Weitergabe einer Exception
[12.3.2]
[31.1.3] [31.2.4
WEST
(GridBagConstraints)]
[36.2.3.2
(SwingConstants)]
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT[36.3.1.10]
[36.3.1.10]
WHEN_FOCUSED
[36.3.1.10]
WHEN_IN_FOCUSED_WINDOW
[42.4.7.3]
WHERE
[1.2.1] [6.3.1]
while
[6.3.3.3]
[25.2]
white
[39.2.1]
WIDTH
Wiederverwendung
[7.1.4]
[25.4]
window
[23.2.1] [27.1]
java.awt
Window
Window-Ereignisse
[28.1.6.7]
Window-Events
[29.1]
[28.1.6.7] [29.1]
windowActivated
[28.1.5] [29.1]
[25.4]
[28.1.6.7] [29.1]
[23.2.4] [28.1.6.7]
[29.1]
[2.2.2.2] [23.2.4]
[28.1.6.7] [29.1]
[28.1.6.7] [29.1]
[28.1.6.7] [29.1]
[28.1.6.7] [29.1]
[23.2.4] [28.1.6.7]
[29.1]
[28.1.6.7] [29.1]
[25.4]
[17.2.1]
[19.2.3.4]
[10.2]
[18.2.1] [19.2.1]
[20.4]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[20.4] [41.1.2]
[41.1.2]
[18.2.1] [49.2.4.1]
[20.4] [41.1.2]
[18.2.2.2]
[19.2.3.3] [20.4]
[41.1.2]
WindowAdapter
windowBorder
windowClosed
windowClosing
WindowClosingAdapter
windowDeactivated
windowDeiconified
WindowEvent
windowIconified
WindowListener
windowOpened
windowText
Winkelfunktionen
winzip
Wrapper-Klassen
write
write-Methoden
writeBoolean
writeByte
writeBytes
writeChar
writeChars
writeDouble
writeFloat
writeInt
writeLong
writeObject
Writer
writeShort
writeTo
writeUTF
Titel
<<
>
>>
DOC
API
java.awt.event
java.awt.event
java.awt.event
java.io
-XX.509-Zertifikat
XML-Dateien
XML-Untersttzung
xor
[47.1.7]
[13.2.1.2]
[1.1]
[14.5.2]
Handbuch der Java-Programmierung, 3. Auflage,
Addison Wesley, Version 3.0
1998-2002 Guido Krger,
API
http://www.javabuch.de
<
>
>>
-Y[16.2.2]
[25.2]
[36.1.4.2]
[36.1.4.2]
[45.2.3]
YEAR
yellow
YES_NO_CANCEL_OPTION
YES_NO_OPTION
yield
<
>
>>
-ZZapfDingbats
Zeichenextraktion
Zeichenketten
Zeichentasten
Zeichentyp
Zeilenabstand
Zeitzonen
Zeitzonenangabe
Zero-Knowledge Proof
Zertifikat
ZipEntry
ZipInputStream
ZipOutputStream
ZONE_OFFSET
Zufallszahlen
Zuweisung
Zuweisungsoperatoren
Zwischenablage
[24.2.2]
[11.2.2]
[1.2.4] [11.1]
[29.6]
[4.2.2]
[24.3.2]
[16.2]
[16.2.2]
[47.1.3.2]
[47.1.7]
[19.2.3.4]
[19.3.3.5]
[19.2.3.4]
[16.2.2]
[1.2.4] [16.1.1]
[4.3.1]
[5.6]
[30.7]
<
>
>>
java.util.zip
java.util.zip
java.util.zip
Titel
<<
>
>>
API
Falls Sie die ersten Gehversuche in Java machen wollen, ohne erst viele Grundlagen
lernen zu mssen, oder wenn Sie einfach nur daran interessiert sind, mglichst schnell
Ihr erstes Java-Programm auszufhren, dann sollten Sie den vorliegenden Abschnitt
lesen. Sie erfahren hier in komprimierter Form, wie Sie ein einfaches Programm
erstellen und mit den Werkzeugen des JDK bersetzen und ausfhren. Zustzlich gibt
es einige Hinweise, um einfache Ein- und Ausgaben durchzufhren.
/* Hello.java */
Hello.java
Achten Sie bei der Vergabe der Datei- und Klassennamen auf korrekte
Warnung
Gro-/Kleinschreibung. Sowohl der Compiler als auch das Laufzeitsystem
erwarten, da die Hauptklasse einer Quelldatei genauso geschrieben wird
wie der Name der Datei, in der sie sich befindet. Der Dateiname unserer
Beispielklasse Hello lautet daher Hello.java und nicht hello.java,
HELLO.JAVA oder HELLO.JAV. Erstellen Sie die Datei nicht auf
Systemen oder Laufwerken (beispielsweise im Netz), die keine langen
Dateinamen untersttzen. Der Compiler wrde die Datei in diesem Fall
nicht finden.
Sie knnen zum Editieren beispielsweise notepad oder edit (unter Windows) oder vi
oder Emacs (gibt es fr UNIX und Windows) verwenden. Ein guter Windows-Editor,
der fast ebensoviel kann wie seine professionellen (und sehr viel teureren) Brder, ist
TextPad von Helios Software Solutions. Eine Testversion kann von
http://www.textpad.com heruntergeladen werden, die Vollversion ist fr wenig Geld zu
haben. Wer ein wenig Einarbeitungszeit, Konfigurationsaufwand und das Erlernen von
Grundkenntnissen in LISP nicht scheut, der sollte sich Emacs nher ansehen.
Warnung
Falls Sie es trotz aller Bemhungen bis zu diesem Punkt noch nicht geschafft
haben, das Beispiel zu bersetzen und zu starten, kann Ihnen mglicherweise
Abschnitt 2.3.7 weiterhelfen. Er beschreibt einige hufig vorkommende Fehler,
gibt Tips zu ihrer Diagnose und zeigt, wie man sie behebt.
Tip
Titel
<<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Erstellen Sie die Quelldatei mit einem ASCII-Editor. Verwenden Sie keine Textverarbeitung, denn
die wrde dem Code unverstndliche Steuerzeichen hinzufgen.
Achten Sie darauf, da die Datei die Erweiterung .java trgt, und geben Sie ihr exakt denselben
Namen wie der Hauptklasse.
bersetzen Sie das Programm mit dem Compiler javac, und geben Sie dabei den Dateinamen als
Argument an. Um alle Java-Dateien in einem Verzeichnis zu bersetzen, knnen Sie auch *.java als
Argument verwenden.
Falls im Quelltext syntaktische Fehler enthalten sind, meldet der Compiler sie zusammen mit der
Zeilennummer und der Quelldatei, in der sie aufgetreten sind. Am Anfang passieren leicht Fehler wie
vergessene oder berflssige Klammern oder Semikolons. Bedenken Sie auch, da alle
Schlsselwrter kleingeschrieben werden und bei Bezeichnern streng zwischen Gro- und
Kleinschreibung unterschieden wird.
Mitunter gibt es Fehlermeldungen, weil Code nicht erreicht werden kann oder Variablen nicht
initialisiert werden. Das ist in Java nicht erlaubt und wird vom Compiler mittels Datenfluanalyse
berprft. Stellen Sie den Code in einem solchen Fall geeignet um.
Ignorieren Sie zunchst Warnungen, bei denen der Compiler die Verwendung von Klassen oder
Methoden, die als deprecated markiert wurden, kritisiert. Derartige Programmteile funktionieren
zwar meist noch, sind aber veraltet und sollten eigentlich nicht mehr verwendet werden.
Gibt der Compiler gar keine Meldung aus, wurde das Programm erfolgreich bersetzt.
Sie knnen das Programm nun mit dem Java-Interpreter java starten. Geben Sie als Argument nur
den Klassennamen ohne die Erweiterung .java oder .class an.
Wenn es beim Aufruf des Interpreters eine Fehlermeldung der Art NoClassDefFoundError
gibt, liegt das fast immer daran, da der Name der Klasse falsch geschrieben wurde oder da keine
oder eine falsch benannte main-Methode vorhanden ist. Beachten Sie, da main genauso deklariert
wird wie beispielsweise in Listing 2.1.
/* Listing0202.java */
Listing0202.java
Leider ist es etwas komplizierter, Daten zeichenweise von der Tastatur zu lesen. Zwar steht ein
vordefinierter Eingabe-Stream System.in zur Verfgung. Er ist aber nicht in der Lage, die eingelesenen
Zeichen in primitive Datentypen zu konvertieren. Statt dessen mu zunchst eine Instanz der Klasse
InputStreamReader und daraus ein BufferedReader erzeugt werden. Dieser kann dann dazu
verwendet werden, die Eingabe zeilenweise zu lesen und das Ergebnis in einen primitiven Typ
umzuwandeln. Weitere Informationen zur streambasierten Ein-/Ausgabe sind in Kapitel 18 und Kapitel 19
zu finden.
Das folgende Listing zeigt ein Programm, das zwei Ganzzahlen einliest, sie zusammenzhlt und das
Ergebnis auf dem Bildschirm ausgibt:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
/* Listing0203.java */
Listing0203.java
import java.io.*;
public class Listing0203
{
public static void main(String[] args)
throws IOException
{
int a, b, c;
BufferedReader din = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Bitte a eingeben: ");
a = Integer.parseInt(din.readLine());
System.out.println("Bitte b eingeben: ");
b = Integer.parseInt(din.readLine());
c = a + b;
System.out.println("a+b="+c);
}
}
Das Ergebnis von din.readLine ist ein String, der den Inhalt der Eingabezeile enthlt. Sollen
keine numerischen Datenwerte, sondern Zeichenketten eingelesen werden, kann der Rckgabewert
auch direkt verwendet werden.
Tip
import java.io.*;
public class Listing0204
{
public static void main(String[] args)
{
//Hier steht der Methodenrumpf
}
}
001
002
003
004
005
006
007
008
009
if (cmd.equals("Grer")) {
d.height *= 1.05;
d.width *= 1.05;
} else if (cmd.equals("Kleiner")) {
d.height *= 0.95;
d.width *= 0.95;
} else {
x = 10;
}
2.3.5 Namenskonventionen
Wie in allen Programmiersprachen, gibt es auch in Java Konventionen fr die Vergabe von Namen. Sie sind
zwar nicht zwingend erforderlich, erleichtern aber das Verstndnis der Quelltexte ungemein und sollten
daher unbedingt eingehalten werden. Die wichtigsten sind:
Klassennamen beginnen stets mit einem Grobuchstaben. Beispiele sind String, Vector oder
Hello. Besteht ein Klassenname aus mehreren Silben, knnen zur Steigerung der bersichtlichkeit
auch die Folgesilben mit einem Grobuchstaben beginnen. Beispiele dafr wren HelloWorld,
KeyAdapter oder NoSuchMethodException. Klassennamen, die nur aus Grobuchstaben
bestehen, sind unblich.
Methodennamen beginnen mit einem Kleinbuchstaben. Haben sie mehrere Silben, ist die erste oft ein
Verb. Weitere beginnen mit einem Grobuchstaben. Beispiele sind println,
hasMoreElements oder isEnabled.
Paketnamen bestehen ausschlielich aus Kleinbuchstaben. Beispiele sind java.lang,
javax.swing.event oder com.solution42.util (mehrteilige Paketnamen werden durch
Punkte separiert).
Fr Variablennamen gelten dieselben Konventionen wie fr Methoden. Es ist unblich,
Membervariablen mit einem Prfix wie z.B. "m_" zu versehen. Auch die Verwendung der
ungarischen Notation, bei der Variablen datentypbezogene Namensprfixe erhalten, ist in Java nicht
blich.
Weitere Konventionen werden, wenn erforderlich, im Buch beschrieben.
2.3.7 Troubleshooting
Nachfolgend noch einmal eine kurze Zusammenfassung der hufigsten Probleme beim Erstellen, bersetzen
und Starten eines Java-Programms, inklusive Beschreibung, wie man sie behebt oder umgeht.
Was ist eine DOS-Box und wie startet man sie?
Alle Werkzeuge des JDK arbeiten kommandozeilenorientiert. Anders als typische GUI-Programme wie
Adobe Photoshop, Microsoft Excel oder Netscape Navigator besitzen sie also keine grafische Oberflche,
sondern werden aus einer DOS-Box (bzw. einer UNIX-Shell) heraus aufgerufen. Diese wird unter
Windows-Betriebsystemen als MS-DOS-Eingabeaufforderung bezeichnet und ist meist im Startmen
(unter Programme) zu finden. In der DOS-Box werden Befehle und ihre Parameter ber die Tastatur
eingegeben und starten so die zugehrigen Programme. Um in einer DOS-Box zurecht zu kommen, sollte
man deren Kommandosyntax und die wichtigsten Befehle zum Starten von Programmen und fr Datei- und
Verzeichnisoperationen kennen. Beides wird in unzhligen Bchern und (zum Teil) in den Hilfedateien des
Betriebssystems beschrieben.
Das UNIX-Pendant zu einer DOS-Box ist die Shell. Auch sie dient primr dazu,
Hinweis
Benutzerkommandos zu empfangen und auszufhren. UNIX-Shells sind wesentlich mchtiger als
DOS-Boxen unter Windows, und im Laufe der Jahre haben sich verschiedene Varianten
entwickelt (Bourne-Shell, C-Shell, Korn-Shell, BASH etc.). Obwohl viele der elementaren ShellKommandos den DOS-Box-Pendants gleichen oder ihnen recht hnlich sind, lassen sich mit ihrer
detaillierten Beschreibung leicht ganze Bcher fllen. Das Kommando man liefert eine
Beschreibung der Shell und aller zugehrigen UNIX-Kommandos.
Wer nicht kommandozeilenorientiert arbeiten will, kann statt der im Buch beschriebenen JDK-Werkzeuge
natrlich auch eine integrierte Entwicklungsumgebung zum Erlernen der Java-Programmierung verwenden
(z.B. Borland JBuilder). In diesem Fall stehen Editor, Compiler, Interpreter und alle anderen Werkzeuge
unter einer gemeinsamen und einheitlichen grafischen Oberflche zur Verfgung und knnen auf
Knopfdruck gestartet werden. Der Nachteil dieser integrierten Werkzeuge ist allerdings eine etwas hhere
Einarbeitungszeit, denn von der Vielzahl der Mglichkeiten wird man zunchst erschlagen. Zudem sind
wichtige Techniken und Arbeitsschritte oftmals hinter Hilfsprogrammen und Assistenten verborgen und
erschweren so das Verstndnis grundlegender Konzepte.
java luft, javac aber nicht
Wenn unter Windows der Java-Interpreter java gestartet werden kann, beim Aufruf des Compilers javac
aber eine Fehlermeldung kommt, liegt das meist daran, da der PATH nicht korrekt gesetzt wurde. Whrend
die JDK-Installation den Interpreter unter anderem auch in Verzeichnisse kopiert, auf die der PATH bereits
verweist (so da dieser ohne weiteres Zutun aus jedem Verzeichnis aufgerufen werden kann), ist das fr den
Compiler und die brigen JDK-Werkzeuge nicht der Fall. Diese knnen nur dann ohne vorangestellten Pfad
aufgerufen werden, wenn der PATH auf das Unterverzeichnis bin des Installationsverzeichnisses verweist.
Bei der in diesem Buch angenommen Standard-Installation mu die PATH-Variable also das Verzeichnis
c:\jdk1.4\bin enthalten.
Was sind eigentlich Umgebungsvariablen?
Einer der Standardmechanismen zur Konfiguration von Programmen besteht darin, Umgebungsvariablen zu
setzen. Diese werden vom Anwender (meist innerhalb einer DOS-Box bzw. Shell mit Hilfe des setKommandos) gesetzt und vom Programm gelesen und zur Konfiguration verwendet. Die beiden fr das JDK
wichtigsten Umgebungsvariablen sind PATH und CLASSPATH. ber erstere wird dem Betriebssystem
mitgeteilt, wo es nach ausfhrbaren Programmen suchen soll, also etwa nach dem Compiler oder Interpreter
des JDK. Die Umgebungsvariable CLASSPATH (umgangssprachlich der CLASSPATH genannt) ist JDKspezifisch. Sie zeigt dem Compiler und Interpreter an, in welchen Verzeichnissen er nach Klassendateien
suchen soll. Im Gegensatz zu PATH kann der CLASSPATH bei der Standardinstallation eines aktuellen
JDKs (Version 1.3 oder spter) ungesetzt bleiben. Compiler und Interpreter finden ihr eigenes
Laufzeitsystem automatisch, und die selbst geschriebenen Klassen werden im aktuellen Verzeichnis gesucht.
Da es zu umstndlich ist, hufig bentigte Umgebungsvariablen nach jedem Aufruf einer DOS-Box neu zu
setzen, bieten alle Betriebssysteme die Mglichkeit, sie permanent festzulegen. Abschnitt 2.1.2 erlutert dies
am Beispiel der PATH-Variable.
Der Compiler javac arbeitet nicht
Wenn der Compiler javac die .java-Datei nicht findet, liegt dies in aller Regel daran, da sie nicht
existiert. Der Compiler unterscheidet zwischen Gro- und Kleinschreibung; die Datei Test1.java ist somit
streng von test1.java oder TEST1.JAVA zu unterscheiden. Zudem mu die Dateierweiterung .java lauten,
denn andere Erweiterungen werden nicht akzeptiert. Hat der Editor flschlicherweise die Erweiterung .txt
angehngt, wird die Datei vom Compiler nicht gefunden. Mitunter kommt es auch vor, da Beispieldateien
beim Kopieren oder Entpacken in das MS-DOS-8.3-Format konvertiert werden. Die Datei Test1.java wrde
dann TEST1.JAV heien und vom Compiler nicht akzeptiert werden.
Wichtig ist auch, da der Compiler korrekt aufgerufen wird. Anders als beim Interpreter wird die
Dateierweiterung stets angegeben. Ein Aufruf von javac Test1 wird also nicht funktionieren, javac
Test1.java dagegen sehr wohl. Schlielich ist zu beachten, da die zu bersetzende Klasse denselben
Basisnamen hat wie die Datei, in der sie definiert wurde. In der Datei Test1.java mu also eine ffentliche
Klasse mit dem Namen Test1 definiert worden sein.
Der Interpreter java arbeitet nicht korrekt
Der hufigste Fehler beim Aufruf des Interpreters ist ein NoClassDefFoundError. Ein trivialer Fehler
besteht darin, da der Interpreter falsch aufgerufen wurde. Im Gegensatz zum Compiler mchte er keinen
Dateinamen als Argument bergeben bekommen, sondern einen Klassennamen. Folglich darf die
Erweiterung .java oder .class nicht angegeben werden. Die in die Datei Test1.class bersetzte Klasse Test1
wird also durch Aufruf von java Test1 gestartet, und nicht durch java Test1.class.
Das funktioniert allerdings nur, und das ist auch schon die zweite Fehlerquelle, wenn Test1 auch
tatschlich eine Methode public static void main enthlt. Diese versucht nmlich der Interpreter
zu starten, und wenn sie nicht vorhanden ist, gibt es obige Fehlermeldung.
Ist der Aufruf korrekt und die main-Methode ebenso vorhanden wie die ntige Klassendatei, kann es
trotzdem vorkommen, da der Interpreter die Klasse nicht starten kann. Das liegt dann meist daran, da
etwas mit dem CLASSPATH nicht stimmt. Der CLASSPATH ist eine Umgebungsvariable, die eine Liste von
Verzeichnissen und Archivdateien enthlt, die vom Interpreter der Reihe nach durchsucht werden, um die
auszufhrenden Klassen zu finden. Die genaue Interpretation des CLASSPATH hat sich ber die Jahre etwas
gendert, aber bei aktuellen JDK-Versionen kann sie wie folgt zusammengefat werden:
Ist gar kein CLASSPATH angegeben, sucht der Interpreter im aktuellen Verzeichnis (bzw. bei Klassen in
Unterpaketen in darin befindlichen Unterverzeichnissen) nach der Klassendatei. Ist dagegen eine
Umgebungsvariable CLASSPATH vorhanden, durchsucht der Interpreter dessen Elemente der Reihe nach.
Befindet sich darin nicht das aktuelle Verzeichnis (entweder absolut oder als . angegeben), so werden
auch keine Klassen gefunden, die im aktuellen Verzeichnis liegen. Fr unsere ersten Versuche ist es bei
aktuellen JDKs also am besten, den CLASSPATH gar nicht zu setzen und alle Klassen in das aktuelle
Verzeichnis zu legen.
Mitunter wird der CLASSPATH von anderen installierten Java-Programmen verndert und sorgt so
unbeabsichtigt dafr, da die eigenen Klassen nicht mehr gefunden werden. Das ist zwar kein guter Stil,
kommt in der Praxis aber dennoch manchmal vor. In einem solchen Fall mu der CLASSPATH whrend der
eigenen Experimente zurckgesetzt oder so gendert werden, da das aktuelle Verzeichnis (bzw. das mit
den eigenen Klassendateien) darin enthalten ist.
Hinweis
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
Beschreibung
General Info
API &
Language
Guide To
Features
Tool Docs
Im linken oberen Fenster findet sich eine Liste aller Pakete des JDK. Ein Klick auf eines der
Pakete stellt die Liste der zugehrigen Klassen im linken unteren Fenster dar.
Das linke untere Fenster zeigt alle Klassen, Interfaces und Exceptions des aktuellen Pakets.
Wird ein Element angeklickt, so erscheint auf der rechten Seite seine Beschreibung.
Auf der rechten Seite wird eine einzelne Klasse oder ein Interface beschrieben. Am oberen
Rand werden Vererbungsinformationen angezeigt, darunter folgt die allgemeine
Klassenbeschreibung. Anschlieend kommt eine Linkleiste fr Konstanten, Variablen,
Konstruktoren und Methoden. Ein Klick auf eines dieser Elemente verzweigt zu dessen
detaillierter Beschreibung. Abbildung 3.1 zeigt die Beschreibung der Methode addElement
der Klasse Vector des Pakets java.util.
Die API-Dokumentation ersetzt zwar nicht die konzeptionelle Beschreibung der Java-Themen (das
ist Aufgabe dieses Buchs), als Nachschlagewerk zu Details der Klassenbibliothek ist sie jedoch
unentbehrlich. Der Umgang mit ihr sollte jedem Java-Entwickler in Fleisch und Blut bergehen.
Manchmal bieten die Hilfesysteme der integrierten Entwicklungsumgebungen sogar noch
komfortablere Mglichkeiten, auf die Dokumentation von Klassen und Methoden zuzugreifen.
Durch die alphabetische Anordnung der Pakete mu im linken oberen Fenster sehr hufig
Tip
gescrollt werden. Einfacher wird es, wenn die wichtigsten und am hufigsten bentigten
Pakete in der Liste nach oben verschoben werden. Wer rudimentre HTML-Kenntnisse hat,
kann dazu die Datei c:\jdk1.4\docs\api\overview-frame.html mit einem Texteditor ffnen und
die gewnschten Zeilen editieren. Ntzlich wre es beispielsweise, die Pakete java.lang,
java.io, java.util, java.awt, java.awt.event, javax.swing, java.sql
und java.net an den Anfang der Liste zu setzen.
Inhalt
news:comp.lang.java.3d
news:comp.lang.java.advocacy
news:comp.lang.java.announce
news:comp.lang.java.api
news:comp.lang.java.beans
news:comp.lang.java.corba
news:comp.lang.java.databases
news:comp.lang.java.gui
news:comp.lang.java.help
news:comp.lang.java.machine
news:comp.lang.java.misc
news:comp.lang.java.setup
news:comp.lang.javascript
news:de.comp.lang.java
Dokumentationen geht. Hier gibt es auch Links zu weiteren Meta-Ressourcen, die hier nicht erwhnt
werden. Ein direkter Link auf die von SUN fr Java zur Verfgung gestellten
Entwicklungsumgebungen ist http://java.sun.com/products/. Unter der Adresse
http://java.sun.com/j2se/1.4/ gibt es alles rund um die aktuelle Java-Version 1.4.
Eine wichtige Adresse fr Entwickler ist auch die der Java Developer's Connection (JDC) unter
http://developer.java.sun.com/. Diese Seiten werden von SUN gepflegt, um eine zentrale
Anlaufstelle fr Java-Entwickler zur Verfgung zu stellen. Es gibt dort Diskussionsforen,
Schulungsangebote, weitere Software und jede Menge ntzliche Informationen. Wichtiges Organ
der JDC ist der JDC-Newsletter. Dabei handelt es sich um einen Newsletter, der per E-Mail
regelmig ber aktuelle Neuerungen informiert. Der Zutritt zur JDC ist kostenlos, erfordert aber
das Ausfllen einer Registrierungsseite.
Mitunter ebenfalls wichtig ist die - etwas euphemistisch als Bug Parade bezeichnete Fehlerdatenbank des Java Development Kit. Hier werden alle bekannten Fehler gelistet und mit
Beschreibung, Behebungs-Status und mglichen Workarounds beschrieben. Die Bug Parade kann
unter http://developer.java.sun.com/developer/bugParade/index.jshtml erreicht und online nach
Fehlern durchsucht werden. Registrierte Entwickler knnen neue Fehler eintragen oder zu bekannten
Fehlern ihre Stimme abgegeben - in der Hoffnung, dadurch die Behebung zu beschleunigen.
Auch in den groen Web-Verzeichnissen gibt es meist eigene Rubriken fr die Programmiersprache
Java. Yahoo stellt diese beispielsweise unter
http://www.yahoo.com/Computers_and_Internet/Programming_Languages/Java zur Verfgung, und
bei Google lautet die Adresse
http://directory.google.com/Top/Computers/Programming/Languages/Java/.
In der Anfangszeit der Java-Entwicklung gab es eine ganze Reihe von Sites, die Unmengen an freien
Java-Tools, -Applets und -Programmen oder frei zugnglichen Quellcode anboten. Viele von ihnen
sind mittlerweile verschwunden, in einem anderen Dienst aufgegangen oder wurden
kommerzialisiert. Einige Anlaufstellen sind http://www.componentsource.com/,
http://www.jguru.com/, http://www.sunsource.net/, http://www.jars.com/ oder das von SUN
verwaltete Verzeichnis von Java-Lsungen http://industry.java.sun.com/solutions/. Frei zugngliche
Java-Software und -Projekte gibt es unter anderem auf
http://www.gnu.org/software/software.html#Java, http://jakarta.apache.org/, http://sourceforge.net/
oder http://freshmeat.net/.
JavaLobby ist ein Zusammenschlu von Java-Enthusiasten, die das Ziel verfolgen, die Sprache zu
verbreiten und fr ein 100 % Pure Java einzutreten. Die Homepage unter
http://www.javalobby.org/ bietet auch eine ganze Menge Verweise zu Java-Ressourcen und
interessante Artikel rund um Java. Unter der Adresse http://www.apl.jhu.edu/~hall/java/ verwaltet
Marty Hall von der Johns Hopkins University eine interessante Liste von Java-Ressourcen mit Links
zu FAQs, weiteren Dokumentationen, Beispielanwendungen, Entwicklungsumgebungen,
Klassenbibliotheken und vielem anderen mehr.
FAQs
Eine Liste von Java-FAQs gibt es unter http://www.faqs.org/faqs/computer-lang/java/. Dort wird
auch auf das sehr umfangreiche, aber nicht mehr ganz aktuelle FAQ von Peter van der Linden
verwiesen, das unter http://www.afu.com/javafaq.html gefunden werden kann. Eine weitere Liste
von Java-FAQs gibt es unter http://www.links2go.com/topic/java_faqs.
Von Roedy Green gibt es unter http://mindprod.com/jgloss.html ein Glossar, in dem viele Begriffe
und Konzepte rund um Java erlutert werden.
Von SUN selbst gibt es ebenfalls ein FAQ, das unter http://www.javasoft.com/products/jdk/faq.html
zu finden ist. Dort sind auch einige Metainformationen und firmenbezogene Informationen ber Java
zu finden.
Einige FAQs zur deutschen Java-Newsgroup sind unter http://www.dclj.de/faq.html zu finden.
Online-Magazine und Dokumentationen
Unter http://www.sys-con.com/java/ ist die Onlineversion des Java Developer's Journal zu finden.
Unter http://www.javaworld.com/ findet sich die Java World, und die Adresse fr den Java Report
Online ist http://www.javareport.com/. Auch das nicht sprachgebundene Dr. Dobb's Journal hat eine
Java-Rubrik unter http://www.ddj.com/topics/java/. Das auch in deutscher Sprache erhltliche Java
Spektrum ist unter http://www.sigs-datacom.de/sd/publications/js/index.htm zu finden. Online steht
es allerdings nur in Auszgen zur Verfgung.
Auf dem SUN-Server gibt es weitere Dokumentationen zu Java. Auf http://java.sun.com/docs/books/
wird die Java Series vorgestellt, in der SUN zusammen mit Addison-Wesley eine groe Zahl von
Java-Bchern publiziert hat. Unter http://java.sun.com/docs/books/jls/index.html ist die
Sprachspezifikation zu finden, und die Beschreibung der virtuellen Maschine findet sich unter
http://java.sun.com/docs/books/vmspec/index.html.
Alle Seiten enthalten am oberen und unteren Ende eine Navigationsleiste, mit der folgende
Seiten direkt angesprungen werden knnen:
"Titel": Titelseite
"Inhalt": Globales Inhaltsverzeichnis
"Suchen": Suchfunktion
"Index": Index
"DOC": Die Hauptseite der JDK-Dokumentation
"<<": Voriges Kapitel
[t]: Titelseite
[Z]: Globales Inhaltsverzeichnis
[S]: Suchfunktion
[i]: Index
[p]: API-Dokumentation
[d]: JDK-Dokumentation
[h]: Voriges Kapitel
[j]: Voriger Abschnitt
[k]: Nchster Abschnitt
[l]: Nchstes Kapitel
[a]: Seitenanfang
[e]: Seitenende
Auf der Hauptseite des Index kann der gewnschte Indexbuchstabe auch ber die Tastatur
eingegeben werden. Die zuvor beschriebenen Krzel sind auf dieser Seite auer Kraft.
Einsatz von JavaScript
Die HTML-Ausgabe enthlt hauptschlich HTML-3.2-Code. Cascading Style Sheets oder hnliche
Erweiterungen wurden nicht verwendet. Ein Java-Applet wird nur fr die Suchfunktion verwendet,
und der Einsatz von JavaScript wurde so gering wie mglich gehalten. Die HTML-Ausgabe ist auch
verwendbar, wenn JavaScript im Browser deaktiviert ist oder nicht untersttzt wird. In diesem Fall
gibt es einige kleine Einschrnkungen:
Ist JavaScript aktiviert, kann die JDK-Dokumentation an einer beliebigen Stelle liegen. Damit Tip
die Links der HTML-Ausgabe korrekt funktionieren, mu in diesem Fall an der im
Unterverzeichnis html liegenden JavaScript-Datei hjp3lib.js eine kleine nderung
vorgenommen werden. In den Variablen jdkdocs und apidocs in den Zeilen 27 und 28
mu nmlich der JDK-Dokumentationspfad korrekt gesetzt sein. Er ist standardmig auf
c:\jdk1.4\docs\ bzw. c:\jdk1.4\docs\api\ eingestellt (passend fr eine WindowsStandardinstallation) und sollte der eigenen Installation entsprechend verndert werden. Wenn
alles korrekt eingestellt ist, mten die Schaltflchen "DOC" und "API" am Anfang und Ende
jeder Seite auf die Startseite der JDK- und API-Dokumentation verzweigen.
Klassen und Methoden knnen in Beziehungen zueinander stehen. Diese werden durch
Verbindungslinien grafisch dargestellt. Bei einer Vererbungsbeziehung wird ein Pfeil von der
abgeleiteten zur Basisklasse gezogen. Die Basisklasse steht in aller Regel ber der abgeleiteten
Klasse. Erben mehrere Klassen von einer Basisklasse, werden die Pfeile zur besseren
bersichtlichkeit zusammengefat. Die Implementierung eines Interfaces wird analog dargestellt,
allerdings mit gestrichelten Linien.
Aggregation und Komposition wird durch eine Verbindungslinine dargestellt, die auf der Seite mit
dem Container eine kleine Raute trgt. Wir unterscheiden dabei nicht zwischen den beiden
Varianten. Aufrufbeziehungen werden als gestrichelte Pfeile mit Beschriftung dargestellt. Der Text
beschreibt die Bedeutung des Aufrufs.
Abbildung 3.4 zeigt eine Basisklasse AbstractComponent, die das Interface Component
implementiert. Aus AbstractComponent sind die drei Klassen ConcreteComponent1,
ConcreteComponent2 und Container abgeleitet. Container ist Besitzer einer Sammlung
von AbstractComponent-Objekten. ConcreteComponent2 verwendet die Klasse Cache:
Titel
<<
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
4.6 Typkonvertierungen
4.6 Typkonvertierungen
4.6.1 Standardkonvertierungen
4.6.2 Vorzeichenlose Bytes
4.6.1 Standardkonvertierungen
Es gibt diverse Konvertierungen zwischen unterschiedlichen Datentypen in Java. Diese werden einerseits
vom Compiler automatisch vorgenommen, beispielsweise bei der Auswertung von numerischen
Ausdrcken. Andererseits knnen sie verwendet werden, um mit Hilfe des Type-Cast-Operators (siehe
Kapitel 5) eigene Konvertierungen vorzunehmen.
Java unterscheidet prinzipiell zwischen erweiternden und einschrnkenden Konvertierungen und diese
noch einmal nach primitiven Typen und Referenztypen. Zunchst zu den Referenztypen:
Als erweiternde Konvertierung eines Referenztyps T wird vor allem die Umwandlung eines
Objekts vom Typ T in eine seiner Vaterklassen angesehen.
Als einschrnkende Konvertierung eines Referenztyps T wird vor allem die Umwandlung eines
Objekts vom Typ T in eine der aus T abgeleiteten Klassen angesehen.
Daneben gibt es noch eine ganze Reihe weiterer Regeln zur Definition von erweiternden und
einschrnkenden Konvertierungen von Referenztypen. Die Bedeutung von Vaterklassen und den daraus
abgeleiteten Unterklassen wird in Kapitel 8 ausfhrlich erlutert.
Konvertierungen auf primitiven Datentypen sind etwas aufwendiger zu erklren. Wir benutzen dazu
Abbildung 4.1:
Bei einer Zuweisung, wenn der Typ der Variablen und des zugewiesenen Ausdrucks nicht
identisch ist.
Bei der Auswertung eines arithmetischen Ausdrucks, wenn Operanden unterschiedlich typisiert
sind.
Beim Aufruf einer Methode, falls die Typen der aktuellen Parameter nicht mit denen der formalen
Parameter bereinstimmen.
Es ist daher beispielsweise ohne weiteres mglich, ein short und ein int gemeinsam in einem
Additionsausdruck zu verwenden, da ein short mit Hilfe einer erweiternden Konvertierung in ein int
verwandelt werden kann. Ebenso ist es mglich, ein char als Array-Index zu verwenden, da es
erweiternd in ein int konvertiert werden kann. Auch die Arithmetik in Ausdrcken, die sowohl integrale
als auch Fliekommawerte enthalten, ist mglich, da der Compiler alle integralen Parameter erweiternd in
Fliekommawerte umwandeln kann.
Es ist dagegen nicht ohne weiteres mglich, einer int-Variablen einen double-Wert zuzuweisen. Die
hierzu erforderliche einschrnkende Konvertierung nimmt der Compiler nicht selbst vor; sie kann
allerdings mit Hilfe des Type-Cast-Operators manuell durchgefhrt werden. Auch die Verwendung eines
long als Array-Index verbietet sich aus diesem Grund.
Bei den einschrnkenden Konvertierungen kann es passieren, da ein Wert verflscht wird, da Warnung
der Wertebereich des Zielobjekts kleiner ist. Aber auch erweiternde Konvertierungen sind
nicht immer gefahrlos mglich. So kann zwar beispielsweise ein float mindestens genauso
groe Werte aufnehmen wie ein long. Seine Genauigkeit ist aber auf ca. 8 Stellen
beschrnkt, und daher knnen grere Ganzzahlen (z.B. 1000000123) nicht mehr mit voller
Genauigkeit dargestellt werden.
int verarbeitet wird. Dafr ist ausschlielich die Anwendung selbst verantwortlich.
Das folgende Listing zeigt eine einfache Klasse ByteKit, mit der zwischen beiden Darstellungen
gewechselt werden kann:
ByteKit.java
001 /**
002 * ByteKit
003 *
004 * Einfache Klasse zur Umwandlung zwischen int, char und
005 * vorzeichenlosen Bytes.
006 */
007 public class ByteKit
008 {
009
/**
010
* Wandelt value (0 <= value <= 255) in ein byte um.
011
*/
012
public static byte fromUnsignedInt(int value)
013
{
014
return (byte)value;
015
}
016
017
/**
018
* Wandelt c in ein byte um. Das High-Byte wird ignoriert.
019
*/
020
public static byte fromChar(char c)
021
{
022
return (byte)(c & 0xFF);
023
}
024
025
/**
026
* Betrachtet value als vorzeichenloses byte und wandelt
027
* es in eine Ganzzahl im Bereich 0..255 um.
028
*/
029
public static int toUnsignedInt(byte value)
030
{
031
return (value & 0x7F) + (value < 0 ? 128 : 0);
032
}
033
034
/**
035
* Betrachtet value als vorzeichenloses byte und wandelt
036
* es in ein Unicode-Zeichen mit High-Byte 0 um.
037
*/
038
public static char toChar(byte value)
039
{
040
return (char)toUnsignedInt(value);
041
}
042
043
/**
044
* Liefert die Binaerdarstellung von value.
045
*/
046
public static String toBitString(byte value)
047
{
048
char[] chars = new char[8];
049
050
051
052
053
054
055
}
056 }
int mask = 1;
for (int i = 0; i < 8; ++i) {
chars[7 - i] = (value & mask) != 0 ? '1' : '0';
mask <<= 1;
}
return new String(chars);
Listing0413.java
/* Listing0413 */
public class Listing0413
{
public static void main(String[] args)
{
for (int i = 0; i < 256; ++i) {
System.out.print("i=" + i);
byte b = ByteKit.fromUnsignedInt(i);
System.out.print(" b=" + ByteKit.toBitString(b));
char c = ByteKit.toChar(b);
System.out.print(" c=" + (c >= 32 ? c : '.'));
System.out.println();
}
}
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
7.1.1 Einfhrung
Objektorientierte Programmierung (kurz OOP) ist das Programmierparadigma der
90er Jahre. Viele der heute verwendeten Programmiersprachen sind entweder von
Grund auf objektorientiert (Java, Eiffel, SmallTalk) oder wurden im Laufe der Zeit
mit objektorientierten Erweiterungen versehen (Basic, Pascal, ADA). Selbst manche
Scriptsprachen erlauben den Zugriff auf (mitunter vordefinierte) Objekte oder
besitzen objektorientierte Eigenschaften (JavaScript, Python). Die objektorientierte
Programmierung war eine der "Silver Bullets", die die Software-Industrie aus ihrer
Krise fhren und zu robusteren, fehlerrmeren und besser wartbaren Programmen
fhren sollte.
Was sind nun die Geheimnisse der objektorientierten Programmierung? Was verbirgt
sich hinter dem Begriff, und welches sind seine wichtigsten Konzepte? Wir wollen
uns zunchst mit den Grundideen objektorientierter Programmierung
auseinandersetzen und dann in diesem und den nchsten Kapiteln Schritt fr Schritt
7.1.2 Abstraktion
Eine der wichtigsten Ideen der objektorientierten Programmierung ist die Trennung
zwischen Konzept und Umsetzung, etwa zwischen einem Bauteil und seinem
Bauplan, einer Speise und dem fr die Zubereitung erforderlichen Rezept oder einem
technischen Handbuch und der konkreten Apparatur, die dadurch beschrieben wird.
Diese Art von Unterscheidung ist in der wirklichen Welt sehr bedeutsam. Wer wei,
wie man einen einzigen Lichtschalter bedient, kann andere, gleichartige Schalter
ebenfalls bedienen. Wer ein Rezept fr eine Sachertorte besitzt, ist in der Lage, diese
zu backen, selbst wenn er ansonsten ber keine Koch- oder Backknste verfgt. Wer
einen Fhrerschein gemacht hat, kann ein Auto fahren, ohne im Detail ber das
komplizierte Innenleben desselben unterrichtet zu sein.
In der objektorientierten Programmierung manifestiert sich diese Unterscheidung in
den Begriffen Objekt und Klasse. Ein Objekt ist ein tatschlich existierendes "Ding"
aus der Anwendungswelt des Programms. Es spielt dabei keine Rolle, ob es sich um
die programmierte Umsetzung eines konkret existierenden Gegenstandes handelt,
oder ob "nur" ein abstraktes Konzept modelliert wird. Eine "Klasse" ist dagegen die
Beschreibung eines oder mehrerer hnlicher Objekte. "hnlich" bedeutet dabei, da
eine Klasse nur Objekte eines bestimmten Typs beschreibt. Diese mssen sich zwar
nicht in allen Details gleichen, aber doch in so vielen von ihnen bereinstimmen, da
eine gemeinsame Beschreibung angebracht ist. Eine Klasse beschreibt mindestens
drei wichtige Dinge:
hnlich wie ein Rezept zur Herstellung von Hunderten von Sachertorten verwendet
werden kann, ermglicht eine Klasse das Erzeugen einer prinzipiell beliebigen
Anzahl von Objekten. Jedes hat dabei seine eigene Identitt und mag sich in
gewissen Details von allen anderen unterscheiden. Letzlich ist das Objekt aber immer
eine Instanz der Klasse, nach der es modelliert wurde. In einem Haus kann es
beispielsweise fnfzig Lichtschalter-Objekte geben. Sie alle sind Instanzen der
Klasse "Lichtschalter", lassen sich in vergleichbarer Weise bedienen und sind
identisch konstruiert. Dennoch unterscheiden wir sehr wohl zwischen dem
Lichschalter-Objekt, das die Flurbeleuchtung bedient, und jenem, das den Keller
erhellt. Und beide widerum unterscheiden sich eindeutig von allen anderen
Lichschalterinstanzen im Haus.
Es ist brigens kein Zufall, da wir die Begriffe "Instanz" und "Objekt"
synonym verwenden. In der objektorientierten Programmierung ist das
sehr verbreitet (auch wenn Puristen zwischen beiden Begriffen noch
Unterschiede sehen), und wir wollen uns diesem Wortgebrauch
anschlieen.
Hinweis
7.1.3 Kapselung
In objektorientierten Programmiersprachen wird eine Klasse durch die
Zusammenfassung einer Menge von Daten und darauf operierender Funktionen (die
nun Methoden genannt werden) definiert. Die Daten werden durch einen Satz
Variablen reprsentiert, der fr jedes instanziierte Objekt neu angelegt wird (diese
werden als Attribute, Membervariablen, Instanzvariablen oder Instanzmerkmale
bezeichnet). Die Methoden sind im ausfhrbaren Programmcode nur einmal
vorhanden, operieren aber bei jedem Aufruf auf den Daten eines ganz bestimmten
Objekts (das Laufzeitsystem bergibt bei jedem Aufruf einer Methode einen Verweis
auf den Satz Instanzvariablen, mit dem die Methode gerade arbeiten soll).
Die Instanzvariablen reprsentieren den Zustand eines Objekts. Sie knnen bei jeder
Instanz einer Klasse unterschiedlich sein und sich whrend seiner Lebensdauer
verndern. Die Methoden reprsentieren das Verhalten des Objekts. Sie sind - von
gewollten Ausnahmen abgesehen, bei denen Variablen bewut von auen zugnglich
gemacht werden - die einzige Mglichkeit, mit dem Objekt zu kommunizieren und so
Informationen ber seinen Zustand zu gewinnen oder diesen zu verndern. Das
Verhalten der Objekte einer Klasse wird in seinen Methodendefinitionen festgelegt
und ist von dem darin enthaltenen Programmcode und dem aktuellen Zustand des
Objekts abhngig.
Diese Zusammenfassung von Methoden und Variablen zu Klassen bezeichnet man
als Kapselung. Sie stellt die zweite wichtige Eigenschaft objektorientierter
Programmiersprachen dar. Kapselung hilft vor allem, die Komplexitt der Bedienung
eines Objekts zu reduzieren. Um eine Lampe anzuschalten, mu man nicht viel ber
den inneren Aufbau des Lichtschalters wissen. Sie vermindert aber auch die
Komplexitt der Implementierung, denn undefinierte Interaktionen mit anderen
Bestandteilen des Programms werden verhindert oder reduziert.
7.1.4 Wiederverwendung
Durch die Abstraktion und Kapselung wird die Wiederverwendung von
Programmelementen gefrdert, die dritte wichtige Eigenschaft objektorientierter
Programmiersprachen. Ein einfaches Beispiel dafr sind Collections, also Objekte,
die Sammlungen anderer Objekte aufnehmen und auf eine bestimmte Art und Weise
verarbeiten knnen. Collections sind oft sehr kompliziert aufgebaut (typischerweise
zur Geschwindigkeitssteigerung oder Reduzierung des Speicherbedarfs), besitzen
aber in aller Regel eine einfache Schnittstelle. Werden sie als Klasse implementiert
und werden durch die Kapselung der Code- und Datenstrukturen die komplexen
Details "wegabstrahiert", knnen sie sehr einfach wiederverwendet werden. Immer,
wenn im Programm eine entsprechende Collection bentigt wird, mu lediglich ein
Objekt der passenden Klasse instanziert werden, und das Programm kann ber die
einfach zu bedienende Schnittstelle darauf zugreifen. Wiederverwendung ist ein
wichtiger Schlssel zur Erhhung der Effizienz und Fehlerfreiheit beim
Programmieren.
7.1.5 Beziehungen
Objekte und Klassen existieren fr gewhnlich nicht vllig alleine, sondern stehen in
Beziehungen zueinander. So hnelt ein Fahrrad beispielsweise einem Motorrad, hat
aber auch mit einem Auto Gemeinsamkeiten. Ein Auto hnelt dagegen einem
Lastwagen. Dieser kann einen Anhnger haben, auf dem ein Motorrad steht. Ein
Fhrschiff ist ebenfalls ein Transportmittel und kann viele Autos oder Lastwagen
aufnehmen, genauso wie ein langer Gterzug. Dieser wird von einer Lokomotive
gezogen. Ein Lastwagen kann auch einen Anhnger ziehen, mu es aber nicht. Bei
einem Fhrschiff ist keine Zugmaschine erforderlich, und es kann nicht nur
Transportmittel befrdern, sondern auch Menschen, Tiere oder Lebensmittel.
Wir wollen ein wenig Licht in diese Beziehungen bringen und zeigen, wie sie sich in
objektorientierten Programmiersprachen auf wenige Grundtypen reduzieren lassen:
Motorrad, ist ein Straenfahrzeug, ebenso wie das Auto und der Lastwagen. All diese
Klassen reprsentieren Transportmittel, zu denen aber auch die Schiffe und
Gterzge zhlen.
Die "is-a"-Beziehung zwischen zwei Klassen A und B sagt aus, da "B ein A ist", also
alle Eigenschaften von A besitzt, und vermutlich noch ein paar mehr. B ist demnach
eine Spezialisierung von A. Andersherum betrachtet, ist A eine Generalisierung
(Verallgemeinerung) von B.
"is-a"-Beziehungen werden in objektorientierten Programmiersprachen durch
Vererbung ausgedrckt. Eine Klasse wird dabei nicht komplett neu definiert, sondern
von einer anderen Klasse abgeleitet. In diesem Fall erbt sie alle Eigenschaften dieser
Klasse und kann nach Belieben eigene hinzufgen. In unserem Fall wre also B von
A abgeleitet. A wird als Basisklasse (manchmal auch als Vaterklasse), B als
abgeleitete Klasse bezeichnet.
Vererbungen knnen mehrstufig sein, d.h. eine abgeleitete Klasse kann Basisklasse
fr weitere Klassen sein. Auf diese Weise knnen vielstufige Vererbungshierarchien
entstehen, die in natrlicher Weise die Taxonomie (also die gegliederte
Begriffsstruktur) der zu modellierenden Anwendungswelt reprsentieren.
Vererbungshierarchien werden wegen ihrer Baumstruktur auch als Ableitungsbume
bezeichnet. Sie werden meist durch Graphen dargestellt, in denen die abgeleiteten
Klassen durch Pfeile mit den Basisklassen verbunden sind und die Basisklassen
oberhalb der abgeleiteten Klassen stehen. Fr unsere Fahrzeugwelt ergbe sich
beispielsweise folgender Ableitungsbaum:
7.1.6 Polymorphismus
Als letztes wichtiges Konzept objektorientierter Programmiersprachen wollen wir
uns mit dem Polymorphismus beschftigen. Polymorphismus bedeutet direkt
bersetzt etwa "Vielgestaltigkeit" und bezeichnet zunchst einmal die Fhigkeit von
Objektvariablen, Objekte unterschiedlicher Klassen aufzunehmen. Das geschieht
7.1.7 Fazit
Objektorientierte Programmierung erlaubt eine natrliche Modellierung vieler
Problemstellungen. Sie vermindert die Komplexitt eines Programms durch
Abstraktion, Kapselung, definierte Schnittstellen und Reduzierung von
Querzugriffen. Sie stellt Hilfsmittel zur Darstellung von Beziehungen zwischen
Klassen und Objekten dar, und sie erhht die Effizienz des Entwicklers durch
Frderung der Wiederverwendung von Programmcode. Wir werden in den nchsten
Abschnitten zeigen, wie die objektorientierte Programmierung sich in Java gestaltet.
<
>
>>
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
10.3 Design-Patterns
10.3 Design-Patterns
10.3.1 Singleton
10.3.2 Immutable
10.3.3 Interface
10.3.4 Factory
Factory-Methode
Factory-Klasse
Abstrakte Factory
10.3.5 Iterator
10.3.6 Delegate
10.3.7 Composite
10.3.8 Visitor
10.3.9 Observer
Design-Patterns (oder Entwurfsmuster) sind eine der wichtigsten und interessantesten Entwicklungen der
objektorientierten Programmierung der letzten Jahre. Basierend auf den Ideen des Architekten Christopher Alexander
wurden sie durch das Buch "Design-Patterns - Elements of Reusable Object-Oriented Software" von Erich Gamma,
Richard Helm, Ralph Johnson und John Vlissides 1995 einer breiten ffentlichkeit bekannt.
Als Design-Patterns bezeichnet man (wohlberlegte) Designvorschlge fr den Entwurf objektorientierter
Softwaresysteme. Ein Design-Pattern deckt dabei ein ganz bestimmtes Entwurfsproblem ab und beschreibt in
rezeptartiger Weise das Zusammenwirken von Klassen, Objekten und Methoden. Meist sind daran mehrere Algorithmen
und/oder Datenstrukturen beteiligt. Design-Patterns stellen wie Datenstrukturen oder Algorithmen vordefinierte Lsungen
fr konkrete Programmierprobleme dar, allerdings auf einer hheren Abstraktionsebene.
Einer der wichtigsten Verdienste standardisierter Design-Patterns ist es, Softwaredesigns Namen zu geben. Zwar ist es in
der Praxis nicht immer mglich oder sinnvoll, ein bestimmtes Design-Pattern in allen Details zu bernehmen. Die
konsistente Verwendung ihrer Namen und ihres prinzipiellen Aufbaus erweitern jedoch das Handwerkszeug und die
Kommunikationsfhigkeit des OOP-Programmierers betrchtlich. Begriffe wie Factory, Iterator oder Singleton werden in
OO-Projekten routinemig verwendet und sollten fr jeden betroffenen Entwickler dieselbe Bedeutung haben.
Wir wollen nachfolgend einige der wichtigsten Design-Patterns vorstellen und ihre Implementierung in Java skizzieren.
Die Ausfhrungen sollten allerdings nur als erster Einstieg in das Thema angesehen werden. Viele Patterns knnen hier
aus Platzgrnden gar nicht erwhnt werden, obwohl sie in der Praxis einen hohen Stellenwert haben (z.B. Adapter,
Bridge, Mediator, Command etc.). Zudem ist die Bedeutung eines Patterns fr den OOP-Anfnger oft gar nicht
verstndlich, sondern erschliet sich erst nach Monaten oder Jahren zustzlicher Programmiererfahrung.
Die folgenden Abschnitte ersetzen also nicht die Lektre weiterfhrender Literatur zu diesem Thema. Das oben erwhnte
Werk von Gamma et al. ist nach wie vor einer der Klassiker schlechthin (die Autoren und ihr Buch werden meist als
"GoF" bezeichnet, ein Akronym fr "Gang of Four"). Daneben existieren auch spezifische Kataloge, in denen die DesignPatterns zu bestimmten Anwendungsgebieten oder auf der Basis einer ganz bestimmten Sprache, wie etwa C++ oder Java,
beschrieben werden.
10.3.1 Singleton
Ein Singleton ist eine Klasse, von der nur ein einziges Objekt erzeugt werden darf. Es stellt eine globale
Zugriffsmglichkeit auf dieses Objekt zur Verfgung und instanziert es beim ersten Zugriff automatisch. Es gibt viele
Beispiele fr Singletons. So ist etwa der Spooler in einem Drucksystem ein Singleton oder der Fenstermanager unter
Windows, der Firmenstamm in einem Abrechnungssystem oder die bersetzungstabelle in einem Parser.
Wichtige Designmerkmale einer Singleton-Klasse sind:
Sie besitzt eine statische Membervariable ihres eigenen Typs, in dem die einzige Instanz gespeichert wird.
Sie besitzt eine statische Methode getInstance, mit der auf die Instanz zugegriffen werden kann.
Sie besitzt einen privaten parameterlosen Konstruktor, um zu verhindern, da andere Klassen durch Anwendung
des new-Operators eine Instanz erzeugen (er verhindert allerdings auch das Ableiten anderer Klassen).
Singleton.java
10.3.2 Immutable
Als immutable (unvernderlich) bezeichnet man Objekte, die nach ihrer Instanzierung nicht mehr verndert werden
knnen. Ihre Membervariablen werden im Konstruktor oder in Initialisierern gesetzt und danach ausschlielich im
lesenden Zugriff verwendet. Unvernderliche Objekte gibt es an verschiedenen Stellen in der Java-Klassenbibliothek.
Bekannte Beispiele sind die Klassen String (siehe Kapitel 11) oder die in Abschnitt 10.2 erluterten Wrapper-Klassen.
Unvernderliche Objekte knnen gefahrlos mehrfach referenziert werden und erfordern im Multithreading keinen
Synchronisationsaufwand.
Wichtige Designmerkmale einer Immutable-Klasse sind:
Lesende Zugriffe auf Membervariablen sind verboten, wenn der Member ein vernderliches Objekt oder ein Array
ist.
Werden vernderliche Objekte oder Arrays an einen Konstruktor bergeben, so mssen sie geklont (also kopiert)
werden, bevor sie Membervariablen zugewiesen werden drfen.
Immutable.java
Warnung
10.3.3 Interface
Ein Interface trennt die Beschreibung von Eigenschaften einer Klasse von ihrer Implementierung. Dabei ist es sowohl
erlaubt, da ein Interface von mehr als einer Klasse implementiert wird, als auch, da eine Klasse mehrere Interfaces
implementiert. In Java ist ein Interface ein fundamentales Sprachelement. Es wurde in Kapitel 9 ausfhrlich beschrieben
und soll hier nur der Vollstndigkeit halber aufgezhlt werden. Fr Details verweisen wir auf die dort gemachten
Ausfhrungen.
10.3.4 Factory
Eine Factory ist ein Hilfsmittel zum Erzeugen von Objekten. Sie wird verwendet, wenn das Instanzieren eines Objekts
mit dem new-Operator alleine nicht mglich oder sinnvoll ist - etwa weil das Objekt schwierig zu konstruieren ist oder
aufwendig konfiguriert werden mu, bevor es verwendet werden kann. Manchmal mssen Objekte auch aus einer Datei,
ber eine Netzwerkverbindung oder aus einer Datenbank geladen werden, oder sie werden auf der Basis von
Konfigurationsinformationen aus systemnahen Modulen generiert. Eine Factory wird auch dann eingesetzt, wenn die
Menge der Klassen, aus denen Objekte erzeugbar sind, dynamisch ist und zur Laufzeit des Programms erweitert werden
kann.
In diesen Fllen ist es sinnvoll, das Erzeugen neuer Objekte von einer Factory erledigen zu lassen. Wir wollen
nachfolgend die drei wichtigsten Varianten einer Factory vorstellen.
Factory-Methode
Gibt es in einer Klasse, von der Instanzen erzeugt werden sollen, eine oder mehrere statische Methoden, die Objekte
desselben Typs erzeugen und an den Aufrufer zurckgeben, so bezeichnet man diese als Factory-Methoden. Sie rufen
implizit den new-Operator auf, um Objekte zu instanzieren, und fhren alle Konfigurationen durch, die erforderlich sind,
ein Objekt in der gewnschten Weise zu konstruieren.
Das Klassendiagramm fr eine Factory-Methode sieht so aus:
Icon.java
Hinweis
Factory-Klasse
Eine Erweiterung des Konzepts der Factory-Methode ist die Factory-Klasse. Hier ist nicht eine einzelne Methode
innerhalb der eigenen Klasse fr das Instanzieren neuer Objekte zustndig, sondern es gibt eine eigenstndige Klasse fr
diesen Vorgang. Das kann beispielsweise sinnvoll sein, wenn der Herstellungsvorgang zu aufwendig ist, um innerhalb der
zu instanzierenden Klasse vorgenommen zu werden. Eine Factory-Klasse knnte auch sinnvoll sein, wenn es spter
erforderlich werden knnte, die Factory selbst austauschbar zu machen. Ein dritter Grund kann sein, da es gar keine
Klasse gibt, in der eine Factory-Methode untergebracht werden knnte. Das ist insbesondere dann der Fall, wenn
unterschiedliche Objekte hergestellt werden sollen, die lediglich ein gemeinsames Interface implementieren.
DoubleMethodFactory.java
Hinweis
Eine Abstracte Factory ist eine recht aufwendige Erweiterung der Factory-Klasse, bei der zwei zustzliche Gedanken im
Vordergrund stehen:
Erstens soll nicht nur ein einzelner Objekttyp erzeugt werden, sondern mehrere von ihnen. Deren Klassen stehen in
einer bestimmten Beziehung zueinander und die erzeugten Objekte mssen miteinander vertrglich sein. Die
Objekttypen knnen als Produkte, die Gesamtheit der von einer Factory erzeugten Produkte als Produktgruppe
bezeichnet werden.
Zweitens soll die Factory austauschbar sein. Dann kann auf einfache Weise eine andere Implementierungsvariante
gemeinsam fr alle zu erzeugenden Objekte gewhlt werden.
Eine abstrakte Factory wird auch als Toolkit bezeichnet. Ein Beispiel dafr findet sich in grafischen Ausgabesystemen bei
der Erzeugung von Dialogelementen (Widgets) fr unterschiedliche Fenstermanager. Eine konkrete Factory mu in der
Lage sein, unterschiedliche Dialogelemente so zu erzeugen, da sie in Aussehen und Bedienung konsistent sind. Auch die
Schnittstelle fr Programme sollte ber Fenstergrenzen hinweg konstant sein. Konkrete Factories knnte es etwa fr
Windows, X-Window oder die Macintosh-Oberflche geben.
Eine abstrakte Factory kann durch folgende Bestandteile beschrieben werden:
Jedes Produkt besitzt eine Basisklasse, die seine spezifischen Eigenschaften angibt (die abstrakte Produktklasse).
Jede Factory-Methode hat einen Rckgabewert, dessen Typ einer der abstrakten Produktklassen entspricht.
Je Implementierungsvariante gibt es aus den abstrakten Produkten abgeleitete konkrete Produkte, die von der
zugehrigen konkreten Factory erzeugt werden.
Alle Factory-Methoden werden in der abstrakten Factory-Klasse zusammengefat. Sie bildet das Interface fr das
Erzeugen der Produkte.
Zu jeder Implementierungsvariante gibt es eine aus der abstrakten Factory abgeleitete konkrete Factory. Sie
implementiert alle abstrakten Factory-Methoden und ist in der Lage, die konkreten Produkte einer
Implementierungsvariante zu erzeugen.
Schlielich gibt es eine Mglichkeit, eine konkrete Factory zu erzeugen. Das kann beispielsweise durch eine
statische Methode in der abstrakten Factory realisiert werden.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
/* Listing1010.java */
Listing1010.java
//-----------------------------------------------------------------//Abstrakte Produkte
//-----------------------------------------------------------------abstract class Product1
{
}
abstract class Product2
{
}
//-----------------------------------------------------------------//Abstrakte Factory
//-----------------------------------------------------------------abstract class ProductFactory
{
public abstract Product1 createProduct1();
public abstract Product2 createProduct2();
public static ProductFactory getFactory(String variant)
{
ProductFactory ret = null;
if (variant.equals("A")) {
ret = new ConcreteFactoryVariantA();
} else if (variant.equals("B")) {
ret = new ConcreteFactoryVariantB();
}
return ret;
}
public static ProductFactory getDefaultFactory()
{
return getFactory("A");
}
}
//-----------------------------------------------------------------//Konkrete Produkte fr Implementierungsvariante A
//-----------------------------------------------------------------class Product1VariantA
extends Product1
{
}
class Product2VariantA
extends Product2
{
}
//-----------------------------------------------------------------//Konkrete Factory fr Implementierungsvariante A
//-----------------------------------------------------------------class ConcreteFactoryVariantA
extends ProductFactory
{
public Product1 createProduct1()
{
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
Ein wenig mehr Aufwand mu allerdings getrieben werden, wenn ein neues Produkt hinzukommt. Dann mssen nicht nur
neue abstrakte und konkrete Produktklassen definiert werden, sondern auch die Factories mssen um eine Methode
erweitert werden.
Mit Absicht wurde bei der Benennung der abstrakten Klassen nicht die Vor- oder Nachsilbe "Abstract" verwendet. Tip
Da die Clients nur mit den Schnittstellen der abstrakten Klassen arbeiten und die Namen der konkreten Klassen
normalerweise nie zu sehen bekommen, ist es vollkommen unntig, sie bei jeder Deklaration daran zu erinnern,
da sie eigentlich nur mit Abstraktionen arbeiten.
Auch in Java gibt es Klassen, die nach dem Prinzip der abstrakten Factory implementiert sind. Ein Beispiel ist Hinweis
die Klasse Toolkit des Pakets java.awt. Sie dient dazu, Fenster, Dialogelemente und andere
plattformabhngige Objekte fr die grafische Oberflche eines bestimmten Betriebssystems zu erzeugen. In
Abschnitt 24.2.2 finden sich ein paar Beispiele fr die Anwendung dieser Klasse.
10.3.5 Iterator
Ein Iterator ist ein Objekt, das es ermglicht, die Elemente eines Collection-Objekts nacheinander zu durchlaufen. Als
Collection-Objekt bezeichnet man ein Objekt, das eine Sammlung (meist gleichartiger) Elemente eines anderen Typs
enthlt. In Java gibt es eine Vielzahl von vordefinierten Collections, sie werden in Kapitel 14 und Kapitel 15 ausfhrlich
erlutert.
Obwohl die Objekte in den Collections unterschiedlich strukturiert und auf sehr unterschiedliche Art und Weise
gespeichert sein knnen, ist es bei den meisten von ihnen frher oder spter erforderlich, auf alle darin enthaltenen
Elemente zuzugreifen. Dazu stellt die Collection einen oder mehrere Iteratoren zur Verfgung, die das Durchlaufen der
Elemente ermglichen, ohne da die innere Struktur der Collection dem Aufrufer bekannt sein mu.
Ein Iterator enthlt folgende Bestandteile:
Eine Methode hasNext, mit der berprft wird, ob Elemente vorhanden sind, die noch nicht besucht wurden.
Eine Methode next, die das nchste unbesuchte Element liefert.
Die Collection-Klasse selbst enthlt Methoden wie getAllElements oder getKeys, mit denen Iteratoren fr
bestimmte Teilmengen der enthaltenen Objekte angefordert werden knnen.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
/* Listing1011.java */
Listing1011.java
interface StringIterator
{
public boolean hasNext();
public String next();
}
class StringArray
{
String[] data;
public StringArray(String[] data)
{
this.data = data;
}
public StringIterator getElements()
{
return new StringIterator()
{
int index = 0;
public boolean hasNext()
{
return index < data.length;
}
public String next()
{
return data[index++];
}
};
}
}
public class Listing1011
{
static final String[] SAYHI = {"Hi", "Iterator", "Buddy"};
public static void main(String[] args)
{
//Collection erzeugen
StringArray strar = new StringArray(SAYHI);
//Iterator beschaffen und Elemente durchlaufen
StringIterator it = strar.getElements();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
Die Implementierung eines Iterators erfolgt hufig mit Hilfe lokaler oder anonymer Klassen. Das hat den
Vorteil, da alle bentigten Hilfsvariablen je Aufruf angelegt werden. Wrde die Klasse StringArray
dagegen selbst das StringIterator-Interface implementieren (und die Hilfsvariable index als
Membervariable halten), so knnte sie jeweils nur einen einzigen aktiven Iterator zur Verfgung stellen.
Hinweis
Iteratoren knnen auch gut mit Hilfe von for-Schleifen verwendet werden. Das folgende Programmfragment ist
quivalent zum vorigen Beispiel:
Tip
10.3.6 Delegate
In objektorientierten Programmiersprachen gibt es zwei grundverschiedene Mglichkeiten, Programmcode
wiederzuverwenden. Die erste von ihnen ist die Vererbung, bei der eine abgeleitete Klasse alle Eigenschaften ihrer
Basisklasse erbt und deren nicht-privaten Methoden aufrufen kann. Die zweite Mglichkeit wird als Delegation
bezeichnet. Hierbei verwendet eine Klasse die Dienste von Objekten, aus denen sie nicht abgeleitet ist. Diese Objekte
werden oft als Membervariablen gehalten.
Das wre an sich noch nichts Besonderes, denn Programme verwenden fast immer Code, der in anderen Programmteilen
liegt, und delegieren damit einen Teil ihrer Aufgaben. Ein Designpattern wird daraus, wenn Aufgaben weitergegeben
werden mssen, die eigentlich in der eigenen Klasse erledigt werden sollten. Wenn also der Leser des Programmes spter
erwarten wrde, den Code in der eigenen Klasse vorzufinden. In diesem Fall ist es sinnvoll, die bertragung der
Aufgaben explizit zu machen und das Delegate-Designpattern anzuwenden.
Anwendungen fr das Delegate-Pattern finden sich meist, wenn identische Funktionalitten in Klassen
Hinweis
untergebracht werden sollen, die nicht in einer gemeinsamen Vererbungslinie stehen. Ein Beispiel bilden die
Klassen JFrame und JInternalFrame aus dem Swing-Toolkit (sie werden in Kapitel 36 ausfhrlich
besprochen). Beide Klassen stellen Hauptfenster fr die Grafikausgabe dar. Eines von ihnen ist ein
eigenstndiges Top-Level-Window, das andere wird meist zusammen mit anderen Fenstern in ein Desktop
eingebettet. Soll eine Anwendung wahlweise in einem JFrame oder einem JInternalFrame laufen,
mssen alle Funktionalitten in beiden Klassen zur Verfgung gestellt werden. Unglcklicherweise sind beide
nicht Bestandteil einer gemeinsamen Vererbungslinie. Hier empfiehlt es sich, die Gemeinsamkeiten in einer
neuen Klasse zusammenzufassen und beiden Fensterklassen durch Delegation zur Verfgung zu stellen.
Das Delegate-Pattern besitzt folgende Bestandteile:
Die zu delegierende Funktionalitt wird in einer Delegate-Klasse untergebracht und ber deren ffentliche
Schnittstelle zur Verfgung gestellt. Um deren Bedeutung deutlich zu machen, kann ihr Name mit "Delegate"
enden (z.B. XYZFrameDelegate).
Alle Clienten halten eine Delegate-Membervariable, die bei der Konstruktion initialisiert wird. Wird eine
bestimmte Funktionalitt delegiert, ist einfach die korrespondierende Methode des Delegate aufzurufen.
Falls das Delegate auch Methoden der Clients aufrufen mu, sollte ein Delegator-Interface definiert und von allen
Clients implementiert werden. Der Client bergibt bei der Konstruktion des Delegates einen Zeiger auf sich selbst
und stellt sich selbst dem Delegate als Delegator zur Verfgung.
/* Listing1012.java */
class Delegate
{
private Delegator delegator;
public Delegate(Delegator delegator)
{
this.delegator = delegator;
}
public void service1()
{
}
public void service2()
{
}
}
interface Delegator
{
public void commonDelegatorServiceA();
public void commonDelegatorServiceB();
}
class Client1
implements Delegator
{
private Delegate delegate;
public Client1()
{
delegate = new Delegate(this);
}
public void service1()
{
//implementiert einen Service und benutzt
//dazu eigene Methoden und die des
//Delegate-Objekts
}
public void commonDelegatorServiceA()
{
}
Listing1012.java
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
10.3.7 Composite
In der Programmierpraxis werden hufig Datenstrukturen bentigt, bei denen die einzelnen Objekte zu Baumstrukturen
zusammengesetzt werden knnen.
Es gibt viele Beispiele fr derartige Strukturen:
Die Mens in einem Programm enthalten Menpunkte und Untermens. Untermens enthalten weitere
Menpunkte, sind aber selbst Menpunkte im bergeordneten Men.
Ein Verzeichnis in einem Dateisystem enthlt Dateien und Unterverzeichnisse. Unterverzeichnisse weisen dieselbe
prinzipielle Struktur wie ihre bergeordneten Verzeichnisse auf. Sowohl Dateien als auch Unterverzeichnisse
haben gemeinsame Eigenschaften, wie etwa einen Namen oder zugeordnete Rechte.
Die Komponenten einer grafischen Oberflche knnen sowohl einfache Dialogelemente (Buttons, Textfelder,
Listboxen) als auch Container (Unterfenster, Split-Panels, Tab-Panels) sein. Container enthalten ebenfalls
Komponenten (vergleiche zum Beispiel die Hierarchie der AWT-Fensterklassen in Abbildung 27.1).
Ein mechanisches Bauteil besteht aus elementaren Teilen, die nicht mehr weiter zerlegt werden knnen, und
zusammengesetzten Bauteilen, die aus Unterbauteilen bestehen.
Fr diese hufig anzutreffende Abstraktion gibt es ein Design-Pattern, das als Composite bezeichnet wird. Es ermglicht
derartige Kompositionen und erlaubt eine einheitliche Handhabung von individuellen und zusammengesetzten Objekten.
Ein Composite enthlt folgende Bestandteile:
Eine (oft abstrakte) Basisklasse, die sowohl zusammengesetzte als auch elementare Objekte reprsentiert. Diese
Basisklasse wird auch als "Component" bezeichnet.
Alle elementaren Objekte sind aus dieser Basisklasse abgeleitet.
Daraus abgeleitet gibt es mindestens eine Containerklasse, die in der Lage ist, eine Menge von Objekten der
Basisklasse aufzunehmen.
Somit sind beide Bedingungen erfllt. Der Container ermglicht die Komposition der Objekte zu Baumstrukturen, und
die Basisklasse stellt die einheitliche Schnittstelle fr elementare Objekte und Container zur Verfgung. Das
Klassendiagramm fr ein Composite sieht so aus:
/* Listing1013.java */
class MenuEntry1
{
protected String name;
public MenuEntry1(String name)
{
this.name = name;
}
public String toString()
{
return name;
}
}
class IconizedMenuEntry1
extends MenuEntry1
{
private String iconName;
public IconizedMenuEntry1(String name, String iconName)
{
super(name);
this.iconName = iconName;
}
}
class CheckableMenuEntry1
extends MenuEntry1
Listing1013.java
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
{
private boolean checked;
public CheckableMenuEntry1(String name, boolean checked)
{
super(name);
this.checked = checked;
}
}
class Menu1
extends MenuEntry1
{
MenuEntry1[] entries;
int
entryCnt;
public Menu1(String name, int maxElements)
{
super(name);
this.entries = new MenuEntry1[maxElements];
entryCnt = 0;
}
public void add(MenuEntry1 entry)
{
entries[entryCnt++] = entry;
}
public String toString()
{
String ret = "(";
for (int i = 0; i < entryCnt; ++i) {
ret += (i != 0 ? "," : "") + entries[i].toString();
}
return ret + ")";
}
}
public class Listing1013
{
public static void main(String[] args)
{
Menu1 filemenu = new Menu1("Datei", 5);
filemenu.add(new MenuEntry1("Neu"));
filemenu.add(new MenuEntry1("Laden"));
filemenu.add(new MenuEntry1("Speichern"));
Menu1 confmenu = new Menu1("Konfiguration", 3);
confmenu.add(new MenuEntry1("Farben"));
confmenu.add(new MenuEntry1("Fenster"));
confmenu.add(new MenuEntry1("Pfade"));
filemenu.add(confmenu);
filemenu.add(new MenuEntry1("Beenden"));
System.out.println(filemenu.toString());
}
}
Die Komponentenklasse hat den Namen MenuEntry1. Sie reprsentiert Meneintrge und ist Vaterklasse der
spezialisierteren Meneintrge IconizedMenuEntry1 und CheckableMenuEntry1. Zudem ist sie Vaterklasse
des Containers Menu1, der Meneintrge aufnehmen kann.
Bestandteil der gemeinsamen Schnittstelle ist die Methode toString. In der Basisklasse und den elementaren
Meneintrgen liefert sie lediglich den Namen des Objekts. In der Containerklasse wird sie berlagert und liefert eine
geklammerte Liste aller darin enthaltenen Meneintrge. Dabei arbeitet sie unabhngig davon, ob es sich bei dem
jeweiligen Eintrag um einen elementaren oder einen zusammengesetzten Eintrag handelt, denn es wird lediglich die
immer verfgbare Methode toString aufgerufen.
Das Testprogramm erzeugt ein "Datei"-Men mit einigen Elementareintrgen und einem Untermen "Konfiguration" und
gibt es auf Standardausgabe aus:
(Neu,Laden,Speichern,(Farben,Fenster,Pfade),Beenden)
10.3.8 Visitor
Das vorige Pattern hat gezeigt, wie man komplexe Datenstrukturen mit einer inhrenten Teile-Ganzes-Beziehung aufbaut.
Solche Strukturen mssen oft auf unterschiedliche Arten durchlaufen und verarbeitet werden. Ein Men mu
beispielsweise auf dem Bildschirm angezeigt werden, aber es kann auch die Gliederung fr einen Teil eines
Benutzerhandbuchs zur Verfgung stellen. Verzeichnisse in einem Dateisystem mssen nach einem bestimmten Namen
durchsucht werden, die kumulierte Gre ihrer Verzeichnisse und Unterverzeichnisse soll ermittelt werden, oder es sollen
alle Dateien eines bestimmten Typs gelscht werden knnen.
All diese Operationen erfordern einen flexiblen Mechanismus zum Durchlaufen und Verarbeiten der Datenstruktur.
Natrlich knnte man die einzelnen Bestandteile jeder Operation in den Komponenten- und Containerklassen
unterbringen, aber dadurch wrden diese schnell unbersichtlich, und fr jede neu hinzugefgte Operation mten alle
Klassen gendert werden.
Das Visitor-Pattern zeigt einen eleganteren Weg, Datenstrukturen mit Verarbeitungsalgorithmen zu versehen. Es besteht
aus folgenden Teilen:
Einem Interface Visitor, das Methoden definiert, die beim Durchlaufen der Datenstruktur aufgerufen werden.
Typischerweise gibt es zu jeder Klasse der Datenstruktur eine einzelne Methode, die genau dann aufgerufen wird,
wenn ein Element dieses Typs durchlaufen wird. Bei Containern kann es sinnvoll sein, zwei Methoden zu
definieren: eine, die am Anfang aufgerufen wird, und eine zweite, die aufgerufen wird, nachdem alle Elemente des
Containers durchlaufen wurden. Jede Methode des Visitors erhlt ein Argument, das vom Typ der Klasse ist, die
sie besucht. Die Namen der Methoden setzen sich meist aus dem Prfix "visit" und dem Typ des besuchten
Elements zusammen.
Die Basisklasse der Datenstruktur (also die Komponentenklasse) erhlt eine Methode accept, die ein VisitorObjekt als Argument erhlt. accept ruft die zu seiner Klasse passende Methode des Visitors auf. In jeder
abgeleiteten Komponentenklasse kann accept berlagert werden, wenn fr diese Klasse eine eigene Methode im
Visitor zur Verfgung steht, die anstelle der Basisklassenmethode aufgerufen werden soll. Bei Containern ruft
accept zustzlich die accept-Methoden der darin enthaltenen Elemente auf.
Fr jede zu implementierende Operation wird ein konkreter Visitor definiert, der die bentigte Funktionalitt in
den Aufrufen der "visit..."-Methoden implementiert.
Will ein Client die Funktionalitt eines bestimmten Visitors benutzen, instanziert er ein passendes konkretes
Visitor-Objekt und bergibt es an das Hauptobjekt der Datenstruktur.
/* Listing1014.java */
interface MenuVisitor
{
abstract void visitMenuEntry(MenuEntry2 entry);
abstract void visitMenuStarted(Menu2 menu);
abstract void visitMenuEnded(Menu2 menu);
}
class MenuEntry2
{
protected String name;
public MenuEntry2(String name)
{
this.name = name;
}
public String toString()
{
return name;
}
public void accept(MenuVisitor visitor)
{
visitor.visitMenuEntry(this);
}
}
class Menu2
extends MenuEntry2
{
Listing1014.java
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
MenuEntry2[] entries;
int
entryCnt;
public Menu2(String name, int maxElements)
{
super(name);
this.entries = new MenuEntry2[maxElements];
entryCnt = 0;
}
public void add(MenuEntry2 entry)
{
entries[entryCnt++] = entry;
}
public String toString()
{
String ret = "(";
for (int i = 0; i < entryCnt; ++i) {
ret += (i != 0 ? "," : "") + entries[i].toString();
}
return ret + ")";
}
public void accept(MenuVisitor visitor)
{
visitor.visitMenuStarted(this);
for (int i = 0; i < entryCnt; ++i) {
entries[i].accept(visitor);
}
visitor.visitMenuEnded(this);
}
}
class MenuPrintVisitor
implements MenuVisitor
{
String indent = "";
public void visitMenuEntry(MenuEntry2 entry)
{
System.out.println(indent + entry.name);
}
public void visitMenuStarted(Menu2 menu)
{
System.out.println(indent + menu.name);
indent += " ";
}
public void visitMenuEnded(Menu2 menu)
{
indent = indent.substring(1);
}
}
public class Listing1014
{
public static void main(String[] args)
{
093
094
095
096
097
098
099
100
101
102
103
104
105
}
106 }
Hinweis
10.3.9 Observer
Bei der objektorientierten Programmierung werden Programme in viele kleine Bestandteile zerlegt, die fr sich
genommen autonom arbeiten. Mit zunehmender Anzahl von Bausteinen steigt allerdings der Kommunikationsbedarf
zwischen diesen Objekten, und der Aufwand, sie konsistent zu halten, wchst an.
Ein Observer ist ein Design-Pattern, das eine Beziehung zwischen einem Subject und seinen Beobachtern aufbaut. Als
Subject wird dabei ein Objekt bezeichnet, dessen Zustandsnderung fr andere Objekte interessant ist. Als Beobachter
werden die Objekte bezeichnet, die von Zustandsnderungen des Subjekts abhngig sind; deren Zustand also dem
Zustand des Subjekts konsistent folgen mu.
Das Observer-Pattern wird sehr hufig bei der Programmierung grafischer Oberflchen angewendet. Ist beispielsweise die
Grafikausgabe mehrerer Fenster von einer bestimmten Datenstruktur abhngig, so mssen die Fenster ihre Ausgabe
verndern, wenn die Datenstruktur sich ndert. Auch Dialogelemente wie Buttons, Auswahlfelder oder Listen mssen das
Programm benachrichtigen, wenn der Anwender eine Vernderung an ihnen vorgenommen hat. In diesen Fllen kann das
Ein Interface Observer definiert eine Methode update, die immer dann aufgerufen wird, wenn sich der
Zustand des beobachteten Subjekts ndert.
Eine Klasse Subject definiert Methoden, mit denen sich Observer registrieren und deregistrieren lassen knnen.
Tritt eine Zustandsnderung des Subjekts auf, wird bei allen registrierten Observern die update-Methode
aufgerufen.
Ein konkretes Subjekt wird aus Subject abgeleitet (oder verwendet ein Subject-Objekt per Delegation) und
ruft nach jeder Zustandsnderung fireUpdate auf. Dadurch werden alle registrierten Beobachter aufgerufen
und knnen auf die Zustandsnderung reagieren.
Ein konkreter Beobachter implementiert das Interface Observer und registriert sich bei allen Subjekten, ber
deren Zustandsnderungen er unterrichtet werden mchte. Er implementiert in update den Code, der zur
Bearbeitung der Zustandsnderung erforderlich ist.
/* Listing1015.java */
interface Observer
{
public void update(Subject subject);
}
class Subject
{
Observer[] observers
= new Observer[5];
int
observerCnt = 0;
public void attach(Observer observer)
{
observers[observerCnt++] = observer;
}
public void detach(Observer observer)
{
for (int i = 0; i < observerCnt; ++i) {
if (observers[i] == observer) {
--observerCnt;
for (;i < observerCnt; ++i) {
observers[i] = observers[i + 1];
}
break;
Listing1015.java
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
}
}
}
public void fireUpdate()
{
for (int i = 0; i < observerCnt; ++i) {
observers[i].update(this);
}
}
}
class Counter
{
int cnt = 0;
Subject subject = new Subject();
public void attach(Observer observer)
{
subject.attach(observer);
}
public void detach(Observer observer)
{
subject.detach(observer);
}
public void inc()
{
if (++cnt % 3 == 0) {
subject.fireUpdate();
}
}
}
public class Listing1015
{
public static void main(String[] args)
{
Counter counter = new Counter();
counter.attach(
new Observer()
{
public void update(Subject subject)
{
System.out.print("divisible by 3: ");
}
}
);
while (counter.cnt < 10) {
counter.inc();
System.out.println(counter.cnt);
}
}
}
Hauptprogramm instanzieren wir ein Counter-Objekt und registrieren eine lokale anonyme Klasse als Listener, die bei
jeder Benachrichtigung eine Meldung ausgibt. Whrend des anschlieenden Zhlerlaufs von 1 bis 10 wird sie dreimal
aufgerufen:
1
2
divisible by 3: 3
4
5
divisible by 3: 6
7
8
divisible by 3: 9
10
Das Observer-Pattern ist in Java sehr verbreitet, denn die Kommunikation zwischen graphischen
Hinweis
Dialogelementen und ihrer Anwendung basiert vollstndig auf dieser Idee. Allerdings wurde es etwas
erweitert, die Beobachter werden als Listener bezeichnet, und es gibt von ihnen eine Vielzahl unterschiedlicher
Typen mit unterschiedlichen Aufgaben. Da es zudem blich ist, da ein Listener sich bei mehr als einem
Subjekt registriert, wird ein Aufruf von update statt des einfachen Arguments jeweils ein Listenerspezifisches Ereignisobjekt bergeben. Darin werden neben dem Subjekt weitere spezifische Informationen
untergebracht. Zudem haben die Methoden gegenber der ursprnglichen Definition eine andere
Namensstruktur, und es kann sein, da ein Listener nicht nur eine, sonderen mehrere unterschiedliche UpdateMethoden zur Verfgung stellen mu, um auf unterschiedliche Ereignistypen zu reagieren. Das ListenerKonzept von Java wird auch als Delegation Based Event Handling bezeichnet und in Kapitel 28 ausfhrlich
erlutert.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Die Klasse String definiert eine Vielzahl von Methoden zur Manipulation und zur
Bestimmung der Eigenschaften von Zeichenketten. Da Strings und die auf ihnen
definierten Operationen bei der Anwendung einer Programmiersprache ein wichtiges
und fr die Effizienz der Programmentwicklung kritisches Merkmal sind, sollen hier
die wichtigsten String-Operationen vorgestellt werden. Weitere Methoden dieser
Klasse knnen den Referenzhandbchern der Java-Klassenbibliothek oder der OnlineHilfe entnommen werden.
11.2.1 Konstruktoren
Die Klasse String bietet eine Reihe von Mglichkeiten, neue Instanzen zu
erzeugen. Neben der bereits in Kapitel 4 erluterten Initialisierung mit Hilfe von
Literalen besitzt die Klasse eine Reihe von Konstruktoren, die dazu verwendet
werden knnen, String-Objekte explizit zu erzeugen.
String()
java.lang.String
String(String value)
java.lang.String
java.lang.String
Erzeugt einen neuen String aus einem vorhandenen Zeichen-Array. Dabei werden alle
Elemente des Arrays in den String bernommen.
Nachdem ein String erzeugt wurde, kann er wie jedes andere Objekt
verwendet werden. Insbesondere erfolgt damit im Gegensatz zu C oder
C++ das Speichermanagement vollautomatisch, ohne da sich der
Programmierer darum kmmern mu.
Hinweis
11.2.2 Zeichenextraktion
char charAt(int index)
throws StringIndexOutOfBoundsException
java.lang.String
Liefert das Zeichen an Position index. Dabei hat das erste Element eines Strings den
Index 0 und das letzte den Index length()-1. Falls der String krzer als index +
1 Zeichen ist, wird eine Ausnahme des Typs
StringIndexOutOfBoundsException erzeugt.
String substring(int begin, int end)
java.lang.String
Liefert den Teilstring, der an Position begin beginnt und an Position end endet.
Wie bei allen Zugriffen ber einen numerischen Index beginnt auch hier die Zhlung
bei 0.
Ungewhnlich bei der Verwendung dieser Methode ist die Tatsache, da
der Parameter end auf das erste Zeichen hinter den zu extrahierenden
Teilstring verweist (siehe Abbildung 11.1). Der Rckgabewert ist also die
Zeichenkette, die von Indexposition begin bis Indexposition end - 1
reicht.
Hinweis
java.lang.String
Die Methode liefert den String, der entsteht, wenn auf beiden Seiten der Zeichenkette
jeweils alle zusammenhngenden Leerzeichen entfernt werden. Dabei werden alle
Zeichen, die einen Code kleiner gleich 32 haben, als Leerzeichen angesehen. Leider
gibt es keine separaten Methoden fr das rechts- oder linksbndige Entfernen von
Leerzeichen, trim entfernt immer die Leerzeichen auf beiden Seiten. Da die Klasse
String als final deklariert wurde, gibt es auch keine Mglichkeit, entsprechende
Methoden nachzursten.
java.lang.String
Liefert die aktuelle Lnge des String-Objekts. Ist der Rckgabewert 0, so bedeutet
dies, da der String leer ist. Wird ein Wert n grer 0 zurckgegeben, so enthlt der
String n Zeichen, die an den Indexpositionen 0 bis n - 1 liegen.
Das folgende Beispiel zeigt die Verwendung der Methoden substring und
length und der String-Verkettung auf (letztere wird in Abschnitt 11.3.2 noch
einmal genauer behandelt).
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
Listing1101.java
/* Listing1101.java */
public class Listing1101
{
public static void main(String[] args)
{
String s1;
s1 = "Auf der Mauer";
s1 += ", auf der Lauer";
s1 += ", sitzt \'ne kleine Wanze";
System.out.println(s1);
for (int i = 1; i <= 5; ++i) {
s1 = s1.substring(0,s1.length()-1);
System.out.println(s1);
}
}
}
der
der
der
der
der
der
Mauer,
Mauer,
Mauer,
Mauer,
Mauer,
Mauer,
auf
auf
auf
auf
auf
auf
der
der
der
der
der
der
Lauer,
Lauer,
Lauer,
Lauer,
Lauer,
Lauer,
sitzt
sitzt
sitzt
sitzt
sitzt
sitzt
'ne
'ne
'ne
'ne
'ne
'ne
kleine
kleine
kleine
kleine
kleine
kleine
Wanze
Wanz
Wan
Wa
W
java.lang.String
boolean startsWith(String s)
boolean endsWith(String s)
int compareTo(String s)
boolean regionMatches(
int toffset,
String other,
int ooffset,
int len
)
equals liefert true, wenn das aktuelle String-Objekt und anObject gleich sind.
Analog zu der gleichnamigen Methode der Klasse Object berprft equals also
nicht, ob beide Strings dasselbe Objekt referenzieren, sondern testet auf inhaltliche
Gleichheit. Interessant an equals ist die Tatsache, da als Parameter ein Objekt der
Klasse Object erwartet wird. equals kann einen String also nicht nur mit einem
anderen String vergleichen, sondern mit der String-Darstellung eines beliebigen
Objekts.
Neben equals gibt es noch eine hnliche Methode, equalsIgnoreCase, die
eventuell vorhandene Unterschiede in der Gro-/Kleinschreibung beider
Zeichenketten ignoriert.
startsWith testet, ob das String-Objekt mit der Zeichenkette s beginnt. Ist das der
Fall, so gibt die Methode true zurck, andernfalls false. endsWith berprft
dagegen, ob das String-Objekt mit der Zeichenkette s endet. Ist das der Fall, gibt die
Methode ebenfalls true zurck, andernfalls false.
Die wichtige Methode compareTo fhrt einen lexikalischen Vergleich beider
Strings durch. Bei einem lexikalischen Vergleich werden die Zeichen paarweise von
links nach rechts verglichen. Tritt ein Unterschied auf oder ist einer der Strings
beendet, wird das Ergebnis ermittelt. Ist das aktuelle String-Objekt dabei kleiner als
s, wird ein negativer Wert zurckgegeben. Ist es grer, wird ein positiver Wert
zurckgegeben. Bei Gleichheit liefert die Methode den Rckgabewert 0.
regionMatches vergleicht zwei gleich lange String-Regionen, die in zwei
unterschiedlichen Strings an zwei unterschiedlichen Positionen liegen knnen. Die
Region im ersten String beginnt dabei an der Position toffset, die im zweiten
String other an der Position ooffset. Verglichen werden len Zeichen. Das
Ergebnis ist true, wenn beide Teilstrings identisch sind, andernfalls ist es false.
Die Methode steht auch in einer Variante zur Verfgung, bei der Gro- und
Kleinschreibung ignoriert werden. In diesem Fall wird als zustzlicher Parameter an
erster Stelle ein boolescher Wert ignoreCase bergeben.
Die Anwendung von regionMatches soll an folgendem Beispiel erlutert werden.
Der erste Vergleich liefert true (siehe Abbildung 11.2), der zweite false:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
/* Listing1102.java */
public class Listing1102
{
public static void main(String[] args)
{
System.out.println(
"Gre aus Hamburg".regionMatches(
8,
"Greetings from Australia",
8,
2
)
);
System.out.println(
"Gre aus Hamburg".regionMatches(
6,
"Greetings from Australia",
15,
3
)
);
}
}
Listing1102.java
java.lang.String
Die Methode indexOf sucht das erste Vorkommen der Zeichenkette s innerhalb des
String-Objekts. Wird s gefunden, liefert die Methode den Index des ersten
bereinstimmenden Zeichens zurck, andernfalls wird -1 zurckgegeben. Die
Methode gibt es auch in einer Version, die einen Parameter vom Typ char
akzeptiert. In diesem Fall sucht sie nach dem ersten Auftreten des angegebenen
Zeichens.
Die zweite Variante von indexOf arbeitet wie die erste, beginnt mit der Suche aber
erst ab Position fromIndex. Wird s beginnend ab dieser Position gefunden, liefert
die Methode den Index des ersten bereinstimmenden Zeichens, andernfalls -1. Auch
diese Methode gibt es in einer Variante, die anstelle eines String-Parameters ein
Argument des Typs char erwartet. Ihr Verhalten ist analog zur vorherigen.
Die Methode lastIndexOf sucht nach dem letzten Vorkommen des Teilstrings s
im aktuellen String-Objekt. Wird s gefunden, liefert die Methode den Index des
ersten bereinstimmenden Zeichens, andernfalls -1. Wie die beiden vorherigen
Methoden gibt es auch lastIndexOf wahlweise mit einem Parameter vom Typ
char und mit einem zweiten Parameter, der die Startposition der Suche bestimmt.
java.lang.String
Die Methode toLowerCase liefert den String zurck, der entsteht, wenn alle
Zeichen des Argumentstrings in Kleinbuchstaben umgewandelt werden. Besitzt der
String keine umwandelbaren Zeichen, wird der Original-String zurckgegeben.
toUpperCase arbeitet ganz hnlich, liefert aber den String, der entsteht, wenn alle
Zeichen in Grobuchstaben umgewandelt werden. Besitzt der String keine
umwandelbaren Zeichen, wird der Original-String zurckgegeben.
Mit Hilfe von replace wird eine zeichenweise Konvertierung des aktuellen StringObjekts durchgefhrt. Dabei wird jedes Auftreten des Zeichens oldchar durch das
Zeichen newchar ersetzt.
Leider gibt es in der Klasse String keine Methode, die das Ersetzen von
Teilstrings durch andere Teilstrings (von mglicherweise unterschiedlicher
Lnge) ermglicht. Die auf Einzelzeichen basierende Methode replace ist
das einzige Mittel, um berhaupt Ersetzungen vornehmen zu knnen. Seit der
Version 1.2 gibt es im JDK aber in der Klasse StringBuffer eine
entsprechende Methode. Sie wird in Abschnitt 11.4.4 beschrieben.
Tip
11.2.7 Konvertierungsfunktionen
Da es oftmals ntig ist, primitive Datentypen in Zeichenketten umzuwandeln, bietet
Java eine ganze Reihe von Methoden, die zu diesem Zweck entwickelt wurden. Allen
Methoden ist der Name valueOf und die Tatsache, da sie exakt einen Parameter
erwarten, gemein.
Alle valueOf-Methoden sind als Klassenmethoden implementiert, d.h. sie knnen
auch ohne ein String-Objekt aufgerufen werden. Dies macht Sinn, denn sie werden
ja in aller Regel erst dazu verwendet, Strings zu erzeugen. Ein Aufruf von valueOf
wandelt ein primitives Objekt mit Hilfe der Methode toString, die von der
zugehrigen Wrapper-Klasse zur Verfgung gestellt wird, in eine Zeichenkette um.
Die wichtigsten valueOf-Methoden sind:
static
static
static
static
static
static
static
static
String
String
String
String
String
String
String
String
valueOf(boolean b)
valueOf(char c)
valueOf(char[] c)
valueOf(double d)
valueOf(float f)
valueOf(int i)
valueOf(long l)
valueOf(Object obj)
java.lang.String
<
>
>>
Der Compiler erzeugt keine direkt ausfhrbaren Programme, sondern .classFiles, die von einem Java-Interpreter ausgefhrt werden. Mittlerweile arbeiten
bereits mehrere Betriebssystem-Hersteller daran, .class-Files direkt ausfhrbar
zu machen, und es gibt schon Prozessoren, die den Maschinencode in .classFiles ohne zwischengeschalteten Interpreter verstehen.
Es gibt keinen expliziten Link-Lauf, denn die verschiedenen .class-Files
werden zur Ausfhrungszeit gebunden.
Die .class-Files eines einzigen Projekts knnen auf unterschiedlichen
Plattformen mit unterschiedlichen Compilern erzeugt werden.
Die .class-Files lassen sich auf allen Plattformen ausfhren, die einen JavaInterpreter besitzen; unabhngig davon, wo sie ursprnglich entwickelt
wurden.
Abbildung 13.1 zeigt den schematischen Ablauf bei der Entwicklung eines JavaProgramms, das aus den Klassen A, B und C besteht.
13.3.2 Projektverwaltung
Getrenntes Kompilieren
Wie die Abbildungen deutlich machen, spielen die .class-Files fr den
Entwicklungsproze und die Portierbarkeit von Java-Programmen eine entscheidende
Rolle. Jede .class-Datei enthlt den Bytecode fr eine bersetzte Klasse. Zustzlich
sind in ihr Informationen enthalten, um dynamisches Linken und Late-Bindung zu
untersttzen und gegebenenfalls Symbole, Zeilennummern und andere Informationen
fr den Debugger zur Verfgung zu stellen.
Eine der Grundregeln bei der Entwicklung von Java-Programmen ist es,
Hinweis
genau eine Klassendefinition je Quelldatei aufzunehmen. Anders als etwa
in C++, ist es in Java grundstzlich nicht mglich, die Quellen einer
einzigen Klasse auf mehrere Dateien zu verteilen (und auf diese Weise
weniger als eine Klasse in einer Quelldatei zu speichern). Obwohl es - wie
wir gleich sehen werden - mglich ist, mehr als eine Klasse in einer
Quelldatei abzulegen, sollte dies in der Regel nicht getan werden. Wenn
diese Regeln eingehalten werden, ergibt sich eine eindeutige Abbildung
zwischen Klassen und Quelldateien, die bei der sauberen Strukturierung
eines Projektes hilft. Durch die Verwendung von Paketen kann eine
Verteilung der Quelltexte auf verschiedene Verzeichnisse und
Unterverzeichnisse erreicht werden.
Wie bereits angedeutet, drfen tatschlich auch zwei oder mehr Klassen in einer
Quelldatei enthalten sein. Voraussetzung dafr ist allerdings, da hchstens eine von
ihnen als public deklariert wurde. Eine solche Vorgehensweise kann
beispielsweise bei sehr kleinen Projekten, die nur aus ganz wenigen Klassen
bestehen, sinnvoll sein, um alle Klassen in eine einzige Datei zu bekommen. Sie kann
auch angewendet werden, wenn kleine Hilfsklassen bentigt werden, die nur fr eine
einzige andere Klasse von Bedeutung sind. Der Compiler erzeugt in jedem Fall eine
separate .class-Datei fr jede Klasse, die in einer Quelldatei enthalten ist. Wurde in
einer Quelldatei mehr als eine Klasse public deklariert, gibt es einen CompilerFehler.
Aus diesen Grnden ist es bei kleineren und mittleren Projekten oftmals
Tip
sinnvoll, auf den Einsatz von make zu verzichten und die Programme bei
Bedarf durch Aufruf von javac *.java komplett neu zu kompilieren. Der
Aufruf-Overhead entsteht in diesem Fall nur einmal, und der Compiler braucht
nicht wesentlich lnger, als wenn lediglich eine einzige Quelle bersetzt
wrde.
Eine Alternative zu make ist das Open-Source-Projekt ant, ein komplett in
Java geschriebenes make-Tool mit umfangreichen Scripting-Mglichkeiten.
ant kann am ehesten als Kombination aus make und Kommando-Shell
angesehen werden. Basierend auf XML als Steuerungssprache bietet es eine
Vielzahl von eingebauten Kommandos, die beim bersetzen von JavaProgramm und whrend des gesamten Build-Prozesses ntzlich sind. Eigene
Erweiterungen knnen in Java geschrieben und nahtlos integriert werden. ant
wird als Jakarta-Projekt entwickelt, und seine Homepage ist
http://jakarta.apache.org/ant.
Handbuch der Java-Programmierung, 3. Auflage,
Addison Wesley, Version 3.0
1998-2002 Guido Krger,
API
http://www.javabuch.de
<
>
>>
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Hinweis
Applets werden ab Kapitel 39 erklrt. Sie waren es, die mit der Mglichkeit, eigenstndige Programme mit grafischer
Oberflche in Webseiten einzubinden, einen groen Teil der anfnglichen Begeisterung fr Java auslsten. Spter erkannte
man noch einen zweiten, strategischen Vorteil: diese Programme muten nicht installiert werden, sondern wurden einfach
aufgerufen und waren immer up-to-date. Das brachte gute alte Zeiten in Erinnerung, bei denen die Anwender an
einfachen Terminals saen, die - wenn sie wirklich einmal defekt waren - ohne groen Aufwand ausgetauscht werden
konnten.
Schnell war die Idee geboren, dies mit aktueller (Java-)Technologie nachzuahmen. Warum nicht alle bentigten
Programme als Applets implementieren, die bei Bedarf von einem zentralen Server geladen werden? Man hatte nmlich
erkannt, da in den Unternehmen ein Groteil der durch Computerarbeitspltze verursachten Kosten gar nicht bei deren
Kauf entstand, sondern erst danach. Etwa durch Updates, Reparaturen und Wartungen; aber auch durch Probleme, die
durch nicht verfgbare, fehlerhafte oder inkonsistente Programmversionen entstand. Die aus dieser Idee entstandenen Java
Workstations konnten sich allerdings nicht durchsetzen. Trotz vielversprechender Anfnge wurden die durch langsame
Netzwerkverbindungen oder unzulngliche Java-Implementierungen in den Browsern verursachten Probleme nicht gelst.
Die Java-Stations verschwanden ebenso schnell von der Bildflche, wie sie zuvor aufgetaucht waren.
Whrend der Entwicklung des JDK 1.3 brachte SUN eine Technologie auf den Markt, mit der die Vorteile
von Applets und Applikationen kombiniert werden sollten. Sie wird als Java Web Start (kurz WebStart)
bezeichnet und ist seit dem JDK 1.4 fester Bestandteil jedes JDKs und JREs. Java Web Start bietet die
Mglichkeit, Applikationen ber einen Web-Server automatisch zu laden und zu aktualisieren, ohne da
dazu eine lokale Installation oder das manuelle Einspielen eines Softwareupdates erforderlich wre. Sie
kombiniert so die Installationsfreiheit von Applets mit der Geschwindigkeit und Flexibilitt von JavaApplikationen.
JDK1.1-1.4
Der Entwickler liefert seine Java-Applikation in dem von WebStart bentigten Format aus. Dazu mu er alle
Bestandteile seiner Applikation (Klassen und Ressourcen) in einem oder mehreren jar-Archiven unterbringen.
Zustzlich mu er eine Deskriptordatei zur Verfgung stellen, in der alle von WebStart bentigten Informationen
untergebracht sind.
Der Administrator stellt eine Web-Seite zur Verfgung, von der die WebStart-Applikation geladen werden kann. Er
kopiert dazu alle jar-Dateien und die Deskriptordatei auf den Server und macht letztere ber einen Link den
potentiellen Anwendern verfgbar. Einmalig mu er seinen Web-Server so konfigurieren, da dieser
Deskriptordateien an ihrer Extension .jnlp erkennt und den Browsern den korrekten Mime-Typ application/xjava-jnlp-file bertrgt.
Mchte der Anwender eine Java-Applikation verwenden, die noch nicht lokal auf seinem Rechner verfgbar ist,
ruft er die vom Administrator zur Verfgung gestellte Web-Seite auf und klickt auf den Link mit der DeskriptorDatei. Diese wird vom Web-Browser geladen, der WebStart-Anwendungsmanager wird automatisch aufgerufen
und berprft, ob die gewnschte Applikation bereits lokal vorhanden und alle Bestandteile auf dem neuesten Stand
sind. Ist das der Fall, wird die Applikation gestartet, andernfalls werden zuvor die fehlenden Bestandteile
nachgeladen. Der Anwender kann mit der Applikation nun wie mit jedem anderen Java-Programm arbeiten.
Hat der Anwender die Applikation bereits einmal geladen, ist die Web-Seite fr weitere Aufrufe nicht mehr
unbedingt erforderlich. WebStart speichert die Bestandteile der Applikation in einem Cache und kann sie auch dann
zur Verfgung stellen, wenn keine Verbindung zu dem Server besteht, von dem sie heruntergeladen wurde. Dazu
ruft der Anwender einfach das (zusammen mit dem JDK oder JRE installierte) Programm Java Web Start auf und
whlt aus der Liste der bereits heruntergeladenen Programme das zu startende aus. Wird das Programm oft
bentigt, kann der Anwender sich eine Verknpfung auf dem Desktop oder einen Eintrag im Startmen erstellen
lassen.
Die hier skizzierte Vorgehensweise beschreibt die Nutzungsmglichkeiten von Java Web Start nur in Anstzen. Hinweis
Tatschlich bietet diese Technologie weit mehr Mglichkeiten, als hier erlutert werden knnen. So ist es
beispielsweise mglich, die Anwendung in separate Teile zu zerlegen, die erst bei Bedarf geladen werden. Teile
von Anwendungen lassen sich versionieren und werden nur dann aktualisiert, wenn eine neuere Version zur
Verfgung steht. Man kann Applikationen auch signieren, um ihnen den Zugriff auf den kompletten
Arbeitsplatz zu ermglichen. Ohne Signatur laufen sie - hnlich wie Applets - lediglich in einer Sandbox ab,
in der sie nur beschrnkte Zugriffsmglichkeiten auf lokale Ressourcen haben. Weitere Informationen dazu
werden in Abschnitt 13.5.3 gegeben.
Ein Groteil dieser Mglichkeiten wird im Java Network Launching Protocol beschrieben, das ber die
Download-Seite der WebStart-Homepage heruntergeladen werden kann. Es findet sich wie alle anderen
WebStart-Ressourcen und -Dokumentationen auf http://java.sun.com/products/javawebstart/index.html.
Anwendungsmanager fr das Laden, Ausfhren und Darstellen der Applikation bentigt. Sie heit in unserem Beispiel
wstest.jnlp und hat folgenden Inhalt:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
In information werden beschreibende Angaben zur Applikation gemacht. Neben Titel, Icon, Beschreibung und
Hersteller des Programms kann eine Homepage angegeben werden, auf der der Anwender weitere Informationen
zum Programm finden kann. Wichtig ist der Eintrag offline-allowed. Er gibt an, da das Programm auch
ohne Verbindung zum Internet (genauer: zu seinen Download-Quellen) betrieben werden kann. Das geht natrlich
nur dann, wenn der WebStart-Anwendungsmanager bereits alle Teile der Applikation geladen und lokal im Cache
gespeichert hat. In diesem Fall wrde dann auch nicht geprft, ob Teile der Anwendung veraltet sind und ein
Update fllig wre.
Das information-Element kann ein optionales locale-Argument haben und mehrfach vorhanden sein. So
lassen sich Angaben machen, die nur fr eine bestimmte Sprachversion gelten. In unserem Beispiel gibt es ein
zweites information-Element, in dem die description in deutscher Sprache angegeben wird. Als mgliche
Werte fr das locale-Argument knnen die in Abschnitt 17.4 erluterten Sprachen-/Lnderstrings der LocaleKlasse verwendet werden.
Das Element security dient zur Angabe von sicherheitsrelevanten Informationen. Sein wichtigstes Element ist
all-permissions, mit dem der volle Zugriff auf alle Systemressourcen gefordert wird. Analog zu einem
Applet wird dieser aber nur dann gewhrt, wenn alle jar-Dateien signiert sind und der Anwender das zum Signieren
verwendete Zertifikat akzeptiert. In unserem Beispiel wurde dieses Element auskommentiert, und die Anwendung
hat daher nur eingeschrnkten Zugriff auf Systemressourcen. hnlich wie ein Applet kann eine unsignierte
WebStart-Applikation daher keinen nennenswerten Schaden am System anrichten. Allerdings sind diese
Einschrnkungen etwas weniger ausgeprgt als bei Applets, und es gibt einige APIs, um in kontrollierter Weise auf
diese Systemressourcen zuzugreifen.
Das Element resources dient dazu, die zum Betrieb der Anwendung erforderlichen Ressourcen zu spezifizieren.
Hier wird angegeben, welche Java-Version zum Starten der Anwendung verwendet werden soll (jede WebStartApplikation kann ihre eigene haben), und welche jar-Dateien oder plattformspezifischen Libraries bentigt werden.
In unserem Beispiel soll die Anwendung mit dem JRE 1.3 oder hher betrieben werden, und die zum Betrieb
erforderliche jar-Datei wstest.jar soll relativ zur codebase geladen werden.
Das letzte Element application-desc gibt an, wie die Applikation zu starten ist. In unserem Beispiel wird
lediglich der Name der Klasse mit der main-Methode bentigt. Zustzlich knnten hier bei Bedarf argumentUnterelemente angegeben werden, die beim Aufruf als Parameter an die Anwendung bergeben werden.
Anmerkung: das offline-allowed-Element wird hier nur deshalb dupliziert, weil es auf Grund eines
Bugs in der zum JDK 1.4 gehrenden WebStart-Version 1.0.1 nicht vererbt wurde. Laut BugParade sollte
dieser Fehler ab WebStart 1.2 behoben sein.
Warnung
Hinweis
Wir wollen nun noch eine einfache HTML-Datei wstest.html zum Starten der WebStart-Applikation erstellen. Sie enthlt
im wesentlichen einen Link auf die jnlp-Datei:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
<html>
<head>
<title>HJP3 WebStart Demo Application</title>
</head>
<body>
<h2>HJP3 WebStart Demo Application</h2>
<a href="wstest.jnlp">Anwendung laden/starten</a>
</body>
</html>
selbsterklrend.
Wird eine WebStart-Anwendung das zweite Mal gestartet, fragt der Anwendungsmanager, ob die Anwendung auf dem
Desktop bzw. im Startmen verankert werden soll. Stimmt der Anwender zu, kann sie anschlieend auch auf diesem Weg
gestartet werden.
Nachdem die Anwendung im lokalen Cache gespeichert wurde, kann sie auch offline betrieben werden, d.h.
Hinweis
ohne den auf Port 7777 laufenden Webserver. Sie kann dann zwar nicht mehr ber den Link im Browser
gestartet werden, aber die drei anderen Wege stehen ihr noch offen. Stellt WebStart beim Aufruf einer
Applikation fest, da die in der jnlp-Datei genannten Ressourcen nicht erreichbar sind, verwendet er die lokalen
Kopien und startet die Anwendung aus dem Cache. Das ist allerdings nur mglich, wenn in der jnlp-Datei das
Element offline-allowed gesetzt wurde. War das nicht der Fall, kann die Anwendung nicht offline
gestartet werden.
Der unkontrollierte Zugriff auf das lokale Dateisystem ist nicht erlaubt
Alle jar-Dateien mssen von demselben Host geladen werden
Netzwerkverbindungen drfen nur mit dem Host betrieben werden, vom dem die jar-Dateien geladen wurden
Native Libraries sind nicht erlaubt
Der Zugriff auf System-Properties ist eingeschrnkt
Damit unsignierte WebStart-Anwendungen dennoch ein gewisses Ma an praxisrelevanter Funktionalitt anbieten knnen,
stellt die WebStart-Laufzeitumgebung einige Services zur Verfgung, ber die Anwendungen in kontrollierter Weise auf
Systemressourcen zugreifen knnen:
Der BasicService stellt (hnlich dem AppletContext) Methoden zur Interaktion mit der Laufzeitumgebung
zur Verfgung
Der ClipboardService bietet Zugriff auf die systemweite Zwischenablage
Der DownloadService erlaubt einer Applikation zu kontrollieren, wie ihre Ressourcen heruntergeladen und
gecached werden
Mit dem FileOpenService kann die Anwendung mit Hilfe eines Dateiffnen-Dialogs lokale Dateien lesen
Mit dem FileSaveService kann die Anwendung mit Hilfe eines DateiSpeichern-Dialogs lokale Dateien
schreiben
Der PrintService erlaubt der Anwendung, auf den Drucker zuzugreifen
Der PersistenceService erlaubt das Erzeugen und Lesen lokaler persistenter Daten (hnlich den Cookies in
Web-Browsern)
All diese Services sind insofern als relativ sicher anzusehen, als sie dem Programm entweder nur sehr
beschrnkten Zugriff auf Systemressourcen erlauben (z.B. ClipboardService,
PersistenceService) oder der Anwender per GUI-Dialog ihrer Benutzung zustimmen mu und somit
selbst entscheiden kann, welche konkreten Ressourcen verwendet werden (z.B. FileOpenService,
FileSaveService, PrintService).
Dennoch sollten unsignierte WebStart-Applikationen aus potentiell unsicheren Quellen mit der ntigen
Vorsicht verwendet werden. Einerseits ist nicht auszuschlieen, da man als Anwender im Eifer des Gefechts
einmal unbeabsichtigt einer Service-Nutzung zustimmt, die spter Schaden anrichtet. Andererseits sind Denialof-Service-Attacken nicht auszuschlieen. Hierbei verwendet eine bsartige Anwendung eine Ressource in so
hohem Mae, da sie fr den ordnungsgemen Betrieb anderer Anwendungen nicht mehr ausreichend zur
Verfgung steht. Beispiele sind etwa Programme, die 100 Prozent CPU-Last verursachen oder solche, die das
Dateisystem durch Erzeugen riesiger Dateien zum berlauf bringen. Gegen derartige Programme bieten auch
die Service-Einschrnkungen der WebStart-Applikationen keinen Schutz.
Warnung
javax.jnlp.ServiceManager
Die Methode lookup erwartet einen String mit dem Servicenamen als Argument. Dies mu ein qualifizierter
Klassenname sein, etwa "javax.jnlp.FileOpenService" oder "javax.jnlp.PrintService". Kann der Service nicht zur
Verfgung gestellt werden (die meisten Services sind optional und mssen nicht von allen WebStart-Clients implementiert
werden), wird eine Ausnahme des Typs UnavailableServiceException ausgelst. Andernfalls wird der
Rckgabewert auf den gewnschten Typ konvertiert und kann dann verwendet werden.
Alle Klassen aus dem jnlp-API befinden sich im Paket javax.jnlp. Dieses ist - auch in der Version 1.4 nicht Bestandteil des JDKs, sondern mu separat heruntergeladen werden. Es ist wie alle anderen WebStartRessourcen im Download-Bereich von http://java.sun.com/products/javawebstart/index.html zu finden.
Bentigt wird meist lediglich die Datei jnlp.jar, die zum Kompilieren in den Klassenpfad einzubinden ist. Zur
Laufzeit mu sie nicht explizit angegeben werden, sondern wird vom WebStart-Applikationsmanager zur
Verfgung gestellt.
Hinweis
Die nun folgenden Schritte sind Service-spezifisch. Der FileOpenService stellt beispielsweise folgende Methode zur
Verfgung, um einen Dateiffnen-Dialog zu erzeugen:
public FileContents openFileDialog(
java.lang.String pathHint,
java.lang.String[] extensions
)
throws java.io.IOException
javax.jnlp.FileOpenService
Das erste Argument pathhint ist ein Vorgabewert der Anwendung fr das Verzeichnis, aus dem die Datei geladen
werden soll. Das zweite Argument enthlt eine Liste von Datei-Erweiterungen, die standardmig angezeigt werden. Der
Rckgabewert ist entweder null, falls der Dialog abgebrochen wurde, oder er enthlt ein FileContents-Objekt fr
die vom Anwender ausgewhlte Datei. Dieses kann verwendet werden, um Informationen ber die Datei abzufragen sowie
um Eingabe- oder Ausgabestreams zum Lesen und Schreiben der Datei zu beschaffen.
Wichtige Methoden der Klasse FileContents sind:
javax.jnlp.FileContents
getName liefert den Namen der Datei, und mit getLength kann ihre Lnge bestimmt werden. Mit canRead und
canWrite kann festgestellt werden, ob Lese- bzw. Schreibzugriffe erlaubt sind. getInputStream beschafft einen
InputStream, mit dem die Datei gelesen werden kann, und getOutputStream stellt einen OutputStream zum
Schreiben der Datei zur Verfgung. Das Argument overwrite gibt dabei an, ob der bestehende Inhalt berschrieben
oder die neuen Daten an das Ende der bestehenden Datei angehngt werden sollen.
Nach diesen Vorbemerkungen knnen wir uns nun das Beispielprogramm ansehen:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
/* WebStartTest2.java */
import java.io.*;
import javax.jnlp.*;
public class WebStartTest2
{
public static void main(String[] args)
{
try {
//FileOpenService anfordern
FileOpenService fos = (FileOpenService)ServiceManager.lookup(
"javax.jnlp.FileOpenService"
);
//Dateiffnen-Dialog aufrufen
FileContents fc = fos.openFileDialog(null, null);
if (fc == null) {
System.err.println("openFileDialog fehlgeschlagen");
} else {
//Dateiinhalt auf der Konsole ausgeben
InputStream is = fc.getInputStream();
int c;
while ((c = is.read()) != -1) {
System.out.print((char)c);
}
is.close();
}
} catch (UnavailableServiceException e) {
System.err.println("***" + e + "***");
} catch (IOException e) {
System.err.println("***" + e + "***");
}
//10 Sekunden warten, dann Programm beenden
try {
WebStartTest2.java
035
Thread.sleep(10000);
036
} catch (InterruptedException e) {
037
}
038
System.exit(0);
039
}
040 }
Listing 13.12: Ein Beispielprogramm fr das jnlp-API
Das Programm kann wie im vorigen Abschnitt gezeigt bersetzt, in eine WebStart-Applikation verpackt und ausgefhrt
werden. Wenn die Konsole im WebStart-Applikationsmanager aktiviert wurde, kann mit dem Programm jede beliebige
Datei gelesen werden - vorausgesetzt, der Anwender stimmt im Dateiffnen-Dialog zu.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Danach stehen alle Klassen aus dem Paket java.awt zur Verfgung.
Zur Ausgabe von grafischen Elementen bentigt die Anwendung ein Fenster, auf das die Ausgabeoperationen
angewendet werden knnen. Whrend bei der Programmierung eines Applets ein Standardfenster automatisch zur
Verfgung gestellt wird, mu eine Applikation ihre Fenster selbst erzeugen. Da die Kommunikation mit einem
Fenster ber eine Reihe von Callback-Methoden abgewickelt wird, wird eine Fensterklasse in der Regel nicht einfach
instanziert. Statt dessen ist es meist erforderlich, eine eigene Klasse aus einer der vorhandenen abzuleiten und die
bentigten Interfaces zu implementieren.
Zum Ableiten einer eigenen Fensterklasse wird in der Regel entweder die Klasse Frame oder die Klasse Dialog
verwendet, die beide aus Window abgeleitet sind. Da Dialog vorwiegend dafr verwendet wird, Dialogboxen zu
erstellen, die ber darin enthaltene Komponenten mit dem Anwender kommunizieren, wollen wir ihre Verwendung
bis zum Kapitel 31 zurckstellen. Die wichtigste Klasse zur Ausgabe von Grafiken in Java-Applikationen ist also
Frame.
Um ein einfaches Fenster zu erzeugen und auf dem Bildschirm anzuzeigen, mu ein neues Element der Klasse
Frame erzeugt, auf die gewnschte Gre gebracht und durch Aufruf der Methode setVisible sichtbar gemacht
werden:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
/* Listing2301.java */
Listing2301.java
import java.awt.*;
class Listing2301
{
public static void main(String[] args)
{
Frame wnd = new Frame("Einfaches Fenster");
wnd.setSize(400,300);
wnd.setVisible(true);
}
}
java.awt.Component
Graphics ist Javas Implementierung eines Device-Kontexts (auch Grafikkontext genannt) und stellt somit die
Abstraktion eines universellen Ausgabegerts fr Grafik und Schrift dar. Die Klasse bietet Methoden zur Erzeugung
von Linien-, Fll- und Textelementen. Darber hinaus verwaltet Graphics die Zeichenfarbe, in der alle Ausgaben
erfolgen, und einen Font, der zur Ausgabe von Schrift verwendet wird. Ein Device-Kontext kann daher als eine Art
universelles Ausgabegert angesehen werden, das elementare Funktionen zur Ausgabe von farbigen Grafik- und
Schriftzeichen zur Verfgung stellt.
/* WindowClosingAdapter.java */
import java.awt.*;
import java.awt.event.*;
public class WindowClosingAdapter
extends WindowAdapter
{
private boolean exitSystem;
/**
* Erzeugt einen WindowClosingAdapter zum Schliessen
* des Fensters. Ist exitSystem true, wird das komplette
* Programm beendet.
*/
public WindowClosingAdapter(boolean exitSystem)
{
this.exitSystem = exitSystem;
}
/**
* Erzeugt einen WindowClosingAdapter zum Schliessen
* des Fensters. Das Programm wird nicht beendet.
WindowClosingAdapter.java
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038 }
*/
public WindowClosingAdapter()
{
this(false);
}
public void windowClosing(WindowEvent event)
{
event.getWindow().setVisible(false);
event.getWindow().dispose();
if (exitSystem) {
System.exit(0);
}
}
Listing2303.java
/* Listing2303.java */
import java.awt.*;
class Listing2303
{
public static void main(String[] args)
{
Frame wnd = new Frame("Fenster schlieen");
wnd.addWindowListener(new WindowClosingAdapter(true));
wnd.setSize(400,300);
wnd.setVisible(true);
}
}
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Hinweis
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Die Klasse Graphics stellt neben vielen anderen Funktionen auch eine Sammlung von
linienbasierten Zeichenoperationen zur Verfgung. Diese sind zur Darstellung von einfachen Linien,
Rechtecken oder Polygonen sowie von Kreisen, Ellipsen und Kreisabschnitten geeignet. Wir wollen im
folgenden jede dieser Funktionsgruppen vorstellen und ihre Anwendung an einem Beispiel zeigen.
Um nicht jeweils eine komplette Klassendefinition angeben zu mssen, werden wir in den
folgenden Beispielen jeweils nur die Implementierung der paint-Methode zeigen. Diese
knnte dann beispielsweise in das folgende Programm eingebettet werden (auf der CD
haben diese Dateien die Erweiterung .inc):
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
/* GrafikBeispiel.java */
import java.awt.*;
import java.awt.event.*;
public class GrafikBeispiel
extends Frame
{
public static void main(String[] args)
{
GrafikBeispiel wnd = new GrafikBeispiel();
}
public GrafikBeispiel()
{
super("GrafikBeispiel");
addWindowListener(new WindowClosingAdapter(true));
setBackground(Color.lightGray);
setSize(300,200);
setVisible(true);
}
Hinweis
GrafikBeispiel.java
023
public void paint(Graphics g)
024
{
025
//wird in den folgenden Beispielen berlagert
026
}
027 }
Listing 23.4: Rahmenprogramm fr nachfolgende Beispiele
Da die paint-Methode in diesem Programm noch keine Ausgabeoperationen enthlt, erzeugt das
Programm lediglich ein leeres Fenster mit dem Titel Grafikbeispiel:
Hinweis
23.3.1 Linie
public void drawLine(int x1, int y1, int x2, int y2)
java.awt.Graphics
Zieht eine Linie von der Position (x1,y1) zur Position (x2,y2). Beide Punkte drfen an beliebiger
Stelle im Fenster liegen, das Einhalten einer bestimmten Reihenfolge ist nicht erforderlich. Teile der
Ausgabe, die auerhalb des darstellbaren Bereichs liegen, werden, wie in grafikorientierten Systemen
blich, unterdrckt.
Das folgende Beispiel zeichnet eine Reihe von gleich hohen Linien, deren horizontaler Abstand durch
einen Zufallszahlengenerator bestimmt wird. Das Ergebnis hat dadurch hnlichkeit mit einem Barcode
(ist aber keiner):
001
002
003
004
005
006
007
008
009
010
011
012
Linien.inc
/* Linien.inc */
public void paint(Graphics g)
{
int i;
int x = 80;
for (i=0; i<60; ++i) {
g.drawLine(x,40,x,100);
x += 1+3*Math.random();
}
}
Hinweis
23.3.2 Rechteck
public void drawRect(int x, int y, int width, int height)
java.awt.Graphics
Zeichnet ein Rechteck der Breite width und der Hhe height, dessen linke obere Ecke an der
Position (x,y) liegt. Eine grere Breite dehnt das Rechteck nach rechts aus, eine grere Hhe nach
unten.
Eine Variante von drawRect ist die Methode drawRoundRect:
public
int
int
int
)
void drawRoundRect(
x, int y,
width, int height,
arcWidth, int arcHeight
java.awt.Graphics
Gegenber drawRect sind hier die Parameter arcWidth und arcHeight dazugekommen. Sie
bestimmen den horizontalen und vertikalen Radius des Ellipsenabschnitts, der zur Darstellung der
runden Ecke verwendet wird.
Das folgende Beispiel zeichnet eine Kette von nebeneinanderliegenden Rechtecken, deren Gre durch
einen Zufallszahlengenerator bestimmt wird. Der Zufallszahlengenerator entscheidet auch, ob ein
Rechteck an der Ober- oder Unterseite seines Vorgngers festgemacht wird:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
/* Rechtecke.inc */
public void paint(Graphics g)
{
int x = 10, y = 80;
int sizex, sizey = 0;
while (x < 280 && y < 180) {
sizex = 4 + (int) (Math.random() * 9);
if (Math.random() > 0.5) {
y += sizey;
sizey = 4 + (int) (Math.random() * 6);
} else {
sizey = 4 + (int) (Math.random() * 6);
y -= sizey;
}
g.drawRect(x,y,sizex,sizey);
x += sizex;
}
}
Rechtecke.inc
23.3.3 Polygon
Mit Hilfe der Methode drawPolygon ist es mglich, Linienzge zu zeichnen, bei denen das Ende
eines Elements mit dem Anfang des jeweils nchsten verbunden ist:
public void drawPolygon(int[] arx, int[] ary, int cnt)
java.awt.Graphics
drawPolygon erwartet drei Parameter. Der erste ist ein Array mit einer Liste der x-Koordinaten und
der zweite ein Array mit einer Liste der y-Koordinaten. Beide Arrays mssen so synchronisiert sein,
da ein Paar von Werten an derselben Indexposition immer auch ein Koordinatenpaar ergibt. Die
Anzahl der gltigen Koordinatenpaare wird durch den dritten Parameter festgelegt.
Im Gegensatz zum JDK 1.0 wird das Polygon nach Abschlu der Ausgabe automatisch
Hinweis
geschlossen. Falls der erste und der letzte Punkt nicht identisch sind, werden diese durch
eine zustzliche Linie miteinander verbunden. Soll dagegen ein nichtgeschlossenes Polygon
gezeichnet werden, so kann dazu die Methode drawPolyline verwendet werden:
public void drawPolyline(int[] arx, int[] ary, int cnt)
java.awt.Graphics
Eine zweite Variante, Polygone zu zeichnen, besteht darin, zunchst ein Objekt der Klasse Polygon
zu konstruieren und dieses dann an drawPolygon zu bergeben. Polygon besitzt zwei
Konstruktoren, von denen einer parameterlos ist und der andere dieselben Parameter wie die oben
beschriebene Methode drawPolygon besitzt:
public void Polygon()
java.awt.Graphics
Mit Hilfe der Methode addPoint kann ein Polygon um weitere Punkte erweitert werden. Schlielich
kann das fertige Polygon an die Methode drawPolygon bergeben werden, die dann wie folgt
aufzurufen ist:
java.awt.Graphics
Das folgende Beispiel gibt den Buchstaben F mit Hilfe eines geschlossenen Polygons aus:
001
002
003
004
005
006
007
008
009
/* Polygon.inc */
Polygon.inc
Warnung
23.3.4 Kreis
Die Graphics-Klasse von Java erlaubt sowohl das Zeichnen von Kreisen als auch von Ellipsen und
Kreisabschnitten. Ein Kreis wird dabei als Verallgemeinerung einer Ellipse angesehen, und beide
java.awt.Graphics
Anders als in anderen Grafiksystemen werden bei dieser Methode nicht der Mittelpunkt und Hinweis
der Radius des Kreises angegeben, sondern die bergebenen Parameter spezifizieren ein
Rechteck der Gre width und heigth, dessen linke obere Ecke an der Position (x,y)
liegt. Gezeichnet wird dann der grte Kreis, der vollstndig in das Rechteck hineinpat.
Da diese Vorgehensweise zwar untypisch ist, aber durchaus ihre Vorteile haben kann, zeigt das
folgende Beispiel:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
/* Kreise.inc */
public void paint(Graphics g)
{
int r = 8;
int i, j;
int x, y;
for (i=1; i<=10; ++i) {
x = 150 - r * i;
y = (int) (40 + (i - 1) * 1.7321 * r);
for (j=1; j<=i; ++j) {
g.drawOval(x,y,2*r,2*r);
x += 2 * r;
}
}
}
Kreise.inc
23.3.5 Kreisbogen
Ein Kreisbogen ist ein zusammenhngender Abschnitt der Umfangslinie eines Kreises. Er kann mit der
Methode drawArc gezeichnet werden:
public void drawArc(
int x, int y, int width, int height,
int startAngle, int arcAngle
)
java.awt.Graphics
Die ersten vier Parameter bezeichnen dabei den Kreis bzw. die Ellipse so, wie dies auch bei
drawOval der Fall war. Mit startAngle wird der Winkel angegeben, an dem mit dem
Kreisabschnitt begonnen werden soll, und arcAngle gibt den zu berdeckenden Bereich an. Dabei
bezeichnet ein Winkel von 0 Grad die 3-Uhr-Position, und positive Winkel werden entgegen dem
Uhrzeigersinn gemessen. Als Einheit wird Grad verwendet und nicht das sonst bliche Bogenma.
Das folgende Beispiel zeichnet durch wiederholten Aufruf der Methode drawArc eine Ellipse mit
einer gestrichelten Umfangslinie. Ein Aufruf zeichnet dabei jeweils 4 Grad der Ellipse und lt dann
eine Lcke von 3 Grad, bevor das nchste Stck gezeichnet wird:
001
002
003
004
005
006
007
008
009
010
011
012
013
/* KreisBoegen.inc */
public void paint(Graphics g)
{
int line = 4;
int gap = 3;
int angle = 0;
while (angle < 360) {
g.drawArc(20,40,250,140,angle,line);
angle += gap + line;
}
}
KreisBoegen.inc
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
java.awt.Graphics
Das nachfolgende Beispiel verwendet die Methoden fillRect, fillPolygon, fillOval und fillArc,
um einen stilisierten Java-Schriftzug anzuzeigen:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
/* GefuellteFlaechen.inc */
GefuellteFlaechen.inc
Tip
java.awt.Graphics
void copyArea(
x, int y,
width, int height,
dx, int dy
Die Methode clearRect lscht das angegebene Rechteck, indem sie den Bereich mit der aktuellen
Hintergrundfarbe ausfllt. (x,y) bezeichnet die linke obere Ecke, (width,height) die Breite und Hhe
des Fensters.
Soll ein Teil des Fensters kopiert werden, kann dazu die Methode copyArea verwendet werden. Die ersten
vier Parameter bezeichnen in der blichen Weise den zu kopierenden Ausschnitt. (dx,dy) gibt die Entfernung
des Zielrechtecks in x- und y-Richtung an. copyArea kopiert das ausgewhlte Rechteck also immer an die
Position (x+dx, y+dy).
Das folgende Beispiel demonstriert die Anwendung von copyArea anhand eines Programms, das den
Bildschirm (hnlich dem Windows 95-Hintergrund Labyrinth) mit einem Muster fllt:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
/* Kopieren.inc */
public void paint(Graphics g)
{
int xorg = 4;
int yorg = 28;
int[] arx = {0,6,6,2,2,4,4,0,0};
int[] ary = {0,0,6,6,4,4,2,2,8};
for (int i = 0; i < arx.length; ++i) {
arx[i] += xorg;
ary[i] += yorg;
}
g.drawPolyline(arx,ary,arx.length);
for (int x = 0; x <= 300; x += 8) {
for (int y = 0; y <= 160; y += 8) {
if (x != 0 || y != 0) {
g.copyArea(xorg,yorg,8,8,x,y);
}
}
}
}
Kopieren.inc
java.awt.Graphics
Ein Aufruf dieser Methode begrenzt die Clipping-Region auf die Schnittmenge zwischen dem
angegebenen Rechteck und ihrer vorherigen Gre. Da eine Schnittmenge niemals grer werden
kann als eine der Mengen, aus denen sie gebildet wurde, kann clipRect also lediglich dazu
verwendet werden, die Clipping-Region zu verkleinern.
Hinweis
Soll die Clipping-Region auf einen beliebigen Bereich innerhalb des aktuellen Fensters ausgedehnt werden (der
dabei auch grer sein kann als die bisherige Clipping-Region), so kann dazu die Methode setClip verwendet
werden, die in zwei verschiedenen Ausprgungen zur Verfgung steht:
public abstract void setClip(int x, int y, int width, int height)java.awt.Graphics
public abstract void setClip(Shape clip)
Die erste Version bergibt ein Rechteck, das die Gre der gewnschten Clipping-Region in Client-Koordinaten
angibt. Die zweite Variante erlaubt die bergabe eines Objekts, welches das Shape-Interface implementiert.
Das Interface besitzt derzeit jedoch nur die Methode getBounds, mit der das umschlieende Rechteck
ermittelt werden kann:
public abstract Rectangle getBounds()
java.awt.Shape
Da auer Rechtecken derzeit keine anders geformten Shape-Objekte zur Definition der Clipping-Region
untersttzt werden, wollen wir hier nicht weiter auf die zweite Variante von setClip eingehen.
Soll die Ausdehnung der aktuellen Clipping-Region ermittelt werden, so kann dazu eine der Methoden
getClip oder getClipBounds verwendet werden:
public abstract Shape getClip()
java.awt.Graphics
Dabei liefert getClip ein Shape-Objekt, das derzeit denselben Einschrnkungen unterliegt wie das beim
Aufruf von setClip bergebene. getClipBounds liefert das kleinste Rechteck, das die aktuelle ClippingRegion vollstndig umschliet.
Das folgende Beispiel wiederholt die Ausgabe des Java-Logos, grenzt aber vorher die Clipping-Region auf ein
Fenster der Gre 150*80 Pixel ein, das seinen Ursprung an Position (50,50) hat:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
/* Clipping.inc */
public void paint(Graphics g)
{
int[] arx = {150,175,200,150};
int[] ary = {100,150,100,100};
g.setClip(50,50,150,80);
//---J
g.fillRect(70,40,20,80);
g.fillArc(30,90,60,60,225,180);
//---a
g.fillOval(100,100,40,50);
g.fillRect(120,100,20,50);
//---v
g.fillPolygon(arx,ary,arx.length);
//---a
g.fillOval(210,100,40,50);
g.fillRect(230,100,20,50);
}
Clipping.inc
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
24.1 Ausgabefunktionen
24.1 Ausgabefunktionen
Neben den Methoden zur Ausgabe von Linien- oder Flchengrafiken gibt es in Java die Mglichkeit, Text in
einem Fenster auszugeben. Die dafr vorgesehenen Methoden drawString, drawChars und drawBytes
gehren ebenfalls zur Klasse Graphics:
public void drawString(
String str, int x, int y
)
java.awt.Graphics
Die einfachste Methode, Text auszugeben, besteht darin, drawString aufzurufen und dadurch den String str
im Grafikfenster an der Position (x,y) auszugeben. Das Koordinatenpaar (x,y) bezeichnet dabei das linke
Ende der Basislinie des ersten Zeichens in str. Die Bedeutung der Basislinie wird spter bei der Beschreibung
der Font-Metriken erlutert.
In dem folgenden Beispiel wird versucht, einen String, der die Gre der Client-Area angibt, zentriert im
Ausgabefenster auszugeben (wir verwenden immer noch Listing 23.4 aus Kapitel 23):
001
002
003
004
005
006
007
008
009
010
011
012
013
/* Textausgabe.inc */
public void paint(Graphics g)
{
int maxX=getSize().width-getInsets().left-getInsets().right;
int maxY=getSize().height-getInsets().top-getInsets().bottom;
g.drawString(
"Die Client-Area ist "+maxX+"*"+maxY+" Pixel gro",
getInsets().left + maxX/2,
getInsets().top + maxY/2
);
}
Textausgabe.inc
Hinweis
Die Methode drawString ist leider nicht besonders vielseitig, denn sie kann Text weder drehen noch clippen.
Sie interpretiert auch keine eingebetteten Formatierungen, wie beispielsweise einen Zeilenumbruch oder einen
Tabulator. Da es im Windows-API all diese und noch weitere Mglichkeiten gibt, zeigt sich hier wie auch an
anderen Stellen des AWT, da eine Java-Portierung in der Regel nicht alle Funktionen des darunterliegenden
Betriebssystems zur Verfgung stellen kann. Das 2D-API des JDK 1.2 stellt darber hinaus viele zustzliche
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
24.2.1 Font-Objekte
Fhrt man die Schriftausgabe wie bisher besprochen durch, werden die Texte in einem systemabhngigen StandardFont ausgegeben. Soll ein anderer Font zur Textausgabe verwendet werden, so mu zunchst ein passendes Objekt der
Klasse Font erzeugt und dem verwendeten Graphics-Objekt zugewiesen werden:
public void setFont(Font font)
java.awt.Graphics
Die Methode setFont wird dazu verwendet, das Font-Objekt font in den Grafikkontext einzutragen, und mit
getFont kann der aktuelle Font abgefragt werden.
Das Erzeugen neuer Font-Objekte wird ber die drei Parameter name, style und size des Konstruktors der
Klasse Font gesteuert:
public Font(String name, int style, int size)
java.awt.Font
Der Parameter name gibt den Namen des gewnschten Fonts an. In allen Java-Systemen sollten die Namen
SansSerif (frher Helvetica), Serif (frher TimesRoman) und Monospaced (frher Courier)
untersttzt werden. Sie stehen fr die systemspezifischen Proportionalzeichenstze der Familien Helvetica und
TimesRoman bzw. fr die nichtproportionale Familie Courier. Unter Windows werden diese Standardnamen auf
die True-Type-Fonts Arial, Times New Roman und Courier New abgebildet.
Der zweite und dritte Parameter des Konstruktors sind beide vom Typ int. Ein beliebter Fehler besteht
darin, beide zu verwechseln und so die Angaben fr die Gre und die Textattribute zu vertauschen.
Leider kann der Fehler vom Compiler nicht gefunden werden, sondern wird frhestens zur Laufzeit
entdeckt. Selbst dann wird er leicht mit dem Fall verwechselt, da die gewnschten Schriftarten bzw.
Attribute auf dem Zielsystem nicht installiert sind. Beim Erzeugen von Font-Objekten ist also einige
Vorsicht geboten.
Warnung
Schriften sind generell recht unportabel, deshalb ist bei ihrer Verwendung Vorsicht angebracht.
Warnung
Insbesondere bei der Verwendung von systemspezifischen Schriftarten kann es sein, da der Font-Mapper
eines anderen Systems eine vllig verkehrte Schrift auswhlt und die Ausgabe des Programms dann
unbrauchbar wird. Werden nur die genannten Standardschriften verwendet, so sollte die Schriftausgabe
auf allen untersttzten Java-Systemen zumindest lesbar bleiben. Die alten Schriftnamen Helvetica,
TimesRoman und Courier aus dem JDK 1.0 werden zwar noch untersttzt, sind aber als
deprecated gekennzeichnet und sollten daher nicht mehr verwendet werden.
Der Parameter style wird verwendet, um auszuwhlen, ob ein Font in seiner Standardausprgung, fett oder kursiv
angezeigt werden soll. Java stellt dafr die in Tabelle 24.1 aufgefhrten numerischen Konstanten zur Verfgung. Die
Werte BOLD und ITALIC knnen auch gemeinsam verwendet werden, indem beide Konstanten addiert werden.
Name
Wert
Bedeutung
Font.PLAIN
Standard-Font
Font.BOLD
Fett
Font.ITALIC
Kursiv
/* Schriften.inc */
public void paint(Graphics g)
{
Font font;
String[] arfonts = {"Serif","SansSerif","Monospaced"};
for (int i=0; i<arfonts.length; ++i) {
font = new Font(arfonts[i],Font.PLAIN,36);
g.setFont(font);
g.drawString(arfonts[i],10,30 + (i+1)*(36+5));
}
}
Schriften.inc
Die Abbildung von Schriftnamen im JDK auf die dazu passenden Schriften des Betriebssystems wird
durch die Datei font.properties im lib-Verzeichnis des JDK gesteuert, die zur Laufzeit vom AWT
interpretiert wird. Werden hier Anpassungen vorgenommen, so ndert sich die Darstellung der
Standardschriften.
Hinweis
24.2.2 Standardschriftarten
Es gibt im AWT eine Klasse Toolkit, die als Hilfsklasse bei der Abbildung der portablen AWT-Eigenschaften
dient. Toolkit ist standardmig abstrakt, wird aber von jeder AWT-Implementierung konkretisiert und den
Anwendungen ber die Klassenmethode getDefaultToolkit zur Verfgung gestellt. Whrend die meisten
Methoden von Toolkit nur fr Implementatoren von AWT-Portierungen von Interesse sind, gibt es auch einige
Methoden, die in der Anwendung sinnvoll verwendet werden knnen. Eine dieser Methoden ist getFontList:
java.awt.Toolkit
Diese Methode liefert ein Array von Strings mit den Namen der Standardschriftarten, die in der vorliegenden AWTImplementierung verfgbar sind.
Die folgende paint-Methode listet alle verfgbaren Standardschriften auf dem Bildschirm auf:
001
002
003
004
005
006
007
008
009
010
011
012
013
Standardschriften.inc
/* Standardschriften.inc */
public void paint(Graphics g)
{
Font font;
String[] arfonts = Toolkit.getDefaultToolkit().getFontList();
for (int i=0; i<arfonts.length; ++i) {
font = new Font(arfonts[i],Font.PLAIN,36);
g.setFont(font);
g.drawString(arfonts[i],10,(i+1)*(36+5));
}
}
JDK1.1-1.4
java.awt.GraphicsEnvironment
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
Standardschriften12.inc
/* Standardschriften12.inc */
public void paint(Graphics g)
{
Font font;
GraphicsEnvironment ge =
GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] arfonts = ge.getAvailableFontFamilyNames();
for (int i=0; i<arfonts.length; ++i) {
font = new Font(arfonts[i],Font.PLAIN,36);
g.setFont(font);
g.drawString(arfonts[i],10,(i+1)*(36+5));
}
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
24.3.1 Font-Informationen
Die Klasse Font besitzt Methoden, um Informationen ber den aktuellen Font zu gewinnen:
java.awt.Font
getFamily liefert den systemspezifischen Namen eines Fonts, getStyle den Style-Parameter und
getSize die Gre des Fonts. Auf diese Weise lt sich ein neues Font-Objekt als Variation eines
bestehenden Fonts erzeugen. Das folgende Beispiel zeigt eine paint-Methode, die den zur Anzeige
verwendeten Font bei jedem Aufruf um 1 Punkt vergrert:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
/* SchriftGroesser.inc */
SchriftGroesser.inc
Hinweis
24.3.2 Font-Metriken
Oft bentigt man Informationen ber die Gre eines einzelnen Zeichens oder eines kompletten Strings. Anders
als in textbasierten Systemen ist die Gre von Schriftzeichen bei der Programmierung unter einer grafischen
Oberflche nmlich nicht konstant, sondern von der Art des Fonts, dem Ausgabegert und vor allem von der
Breite der Zeichen selbst abhngig.
Das Grenmodell von Java sieht fr ein Textzeichen fnf unterschiedliche Mazahlen vor (siehe Abbildung
24.5), die teilweise zu den im Schriftsatz verwendeten Begriffen kompatibel sind. Wichtigste Bezugsmarke fr
die verschiedenen Mae ist dabei die Grundlinie des Zeichens, die den oberen und unteren Teil voneinander
trennt. Die Unterlnge gibt die Lnge zwischen Grundlinie und unterer Begrenzung des Zeichens an. Die
Oberlnge bezeichnet die Lnge zwischen Grundlinie und oberem Rand des Zeichens. Die Breite eines
Zeichens ist der Abstand vom linken Rand des Zeichens bis zum linken Rand des darauffolgenden Zeichens.
Der Zeilenabstand ist der Abstand zwischen dem unteren Rand einer Zeile und dem oberen Rand der nchsten
Zeile. Die Hhe ist die Summe aus Oberlnge, Unterlnge und Zeilenabstand.
java.awt.Toolkit
Die parameterlose Variante dient dazu, Metriken zum aktuellen Font zu ermitteln, an die andere kann der zu
untersuchende Font als Argument bergeben werden. Nun stehen Methoden zur Verfgung, die zur
Bestimmung der genannten Eigenschaften aufgerufen werden knnen. Nachfolgend werden die wichtigsten von
ihnen vorgestellt.
public int charWidth(char ch)
java.awt.FontMetrics
Mit charWidth wird die Breite eines einzelnen Zeichens ch bestimmt, mit stringWidth die eines
kompletten Strings. Der Rckgabewert dieser Methoden wird dabei stets in Bildschirmpixeln angegeben. Bei
der Anwendung von stringWidth werden auch Unterschneidungen oder andere Sonderbehandlungen
bercksichtigt, die bei der Ausgabe der Zeichenkette erfolgen wrden.
java.awt.FontMetrics
getAscent liefert die Oberlnge des Fonts, getDescent die Unterlnge, getLeading den Zeilenabstand
und getHeight die Hhe. Obwohl diese Informationen fr die meisten Zeichen des ausgewhlten Fonts
gltig sind, garantiert Java nicht, da dies fr alle Zeichen der Fall ist. Insbesondere kann es einzelne Zeichen
geben, die eine grere Ober- oder Unterlnge haben. Zur Behandlung dieser Sonderflle gibt es zustzliche
Methoden in FontMetrics, die hier nicht nher behandelt werden sollen.
Das nachfolgende Beispiel zeigt eine paint-Methode, die einige Schriftzeichen in 72 Punkt Gre zusammen
mit einem 10*10 Pixel groen Koordinatengitter ausgibt. Zustzlich gibt das Programm die Font-Metriken aus:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
Fontmetriken.inc
/* Fontmetriken.inc */
public void paint(Graphics g)
{
Font font = new Font("TimesRoman",Font.PLAIN,72);
//---Linien
g.setColor(Color.blue);
for (int x = 10; x <= 260; x += 10) {
g.drawLine(x,30,x,130);
}
for (int y = 30; y <= 130; y += 10) {
g.drawLine(10,y,260,y);
}
//---Schrift
g.setColor(Color.black);
g.drawLine(0,100,270,100);
g.setFont(font);
g.drawString("mgdAW",10,100);
//---Font-Metriken
FontMetrics fm = getFontMetrics(font);
System.out.println("Oberlnge
= " +
System.out.println("Unterlnge
= " +
System.out.println("Hhe
= " +
System.out.println("Zeilenabstand = " +
System.out.println("---");
System.out.println("Breite(m)
= " +
System.out.println("Breite(g)
= " +
System.out.println("Breite(d)
= " +
System.out.println("Breite(A)
= " +
System.out.println("Breite(W)
= " +
System.out.println("---");
}
fm.getAscent());
fm.getDescent());
fm.getHeight());
fm.getLeading());
fm.charWidth('m'));
fm.charWidth('g'));
fm.charWidth('d'));
fm.charWidth('A'));
fm.charWidth('W'));
=
=
=
=
73
16
93
4
=
=
=
=
=
55
35
36
52
68
Als weitere Anwendung der Font-Metriken wollen wir Listing 24.1 wie versprochen komplettieren und den
Text zentriert ausgeben:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
/* Zentriert.inc */
public void paint(Graphics g)
{
int maxX=getSize().width-getInsets().left-getInsets().right;
int maxY=getSize().height-getInsets().top-getInsets().bottom;
String s="Die Client-Area ist "+maxX+"*"+maxY+" Pixel gro";
FontMetrics fm = g.getFontMetrics();
int slen = fm.stringWidth(s);
g.drawString(
s,
getInsets().left + ((maxX - slen)/2),
getInsets().top + (maxY/2)
);
}
Zentriert.inc
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Um Farben bei der Ausgabe von Grafik oder Schrift zu verwenden, mu ein geeignetes ColorObjekt beschafft und dem Graphics-Objekt mit Hilfe der Methode setColor zugewiesen werden.
Die Ausgaben erfolgen dann so lange in der neuen Farbe, bis durch Aufruf von setColor eine
andere Farbe festgelegt wird. Mit Hilfe der Methode getColor kann die aktuelle Farbe ermittelt
werden:
public void setColor(Color c)
java.awt.Graphics
Das folgende Beispiel zeigt die Verwendung von Farben und ihre Zusammensetzung aus den drei
Grundfarben Rot, Grn und Blau. Es stellt das Prinzip der additiven Farbmischung mit Hilfe dreier
berlappender Kreise dar:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
/* Listing2501.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2501
extends Frame
{
public static void main(String[] args)
{
Listing2501 wnd = new Listing2501();
}
public Listing2501()
{
super("Der Farbenkreis");
addWindowListener(new WindowClosingAdapter(true));
setSize(300,200);
setVisible(true);
}
Listing2501.java
022
public void paint(Graphics g)
023
{
024
int top = getInsets().top;
025
int left = getInsets().left;
026
int maxX = getSize().width-left-getInsets().right;
027
int maxY = getSize().height-top-getInsets().bottom;
028
Color col;
029
int[] arx
= {130,160,190};
030
int[] ary
= {60,110,60};
031
int[] arr
= {50,50,50};
032
int[] arcol = {0,0,0};
033
boolean paintit;
034
int dx, dy;
035
036
for (int y = 0; y < maxY; ++y) {
037
for (int x = 0; x < maxX; ++x) {
038
paintit = false;
039
for (int i = 0; i < arcol.length; ++i) {
040
dx = x - arx[i];
041
dy = y - ary[i];
042
arcol[i] = 0;
043
if ((dx*dx+dy*dy) <= arr[i]*arr[i]) {
044
arcol[i] = 255;
045
paintit = true;
046
}
047
}
048
if (paintit) {
049
col = new Color(arcol[0],arcol[1],arcol[2]);
050
g.setColor(col);
051
g.drawLine(x+left,y+top,x+left+1,y+top+1);
052
}
053
}
054
}
055
}
056 }
Listing 25.1: Darstellung des Farbenkreises
Das Programm arbeitet in der Weise, da fr jeden einzelnen Punkt der Zeichenflche
Hinweis
berechnet wird, ob dieser in einem der drei Kreise liegt. Ist dies der Fall, so wird die
zugehrige Farbkomponente auf 255 gesetzt, andernfalls auf 0. Die Bestimmung der
Kreiszugehrigkeit erfolgt mit Hilfe des Satzes von Pythagoras, nach dem ein Punkt genau
dann zu einem Kreis gehrt, wenn die Summe der Quadrate der Abstnde vom x- und yWert zum Mittelpunkt kleiner gleich dem Quadrat des Radius ist. Die drei Mittelpunkte
werden in unserem Beispiel in den Arrays arx und ary, die Radien der Kreise in arr
gespeichert. Die boolesche Variable paintit zeigt an, ob der Punkt in wenigstens einem
der drei Kreise liegt und daher berhaupt eine Ausgabe erforderlich ist.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
25.4 Systemfarben
25.4 Systemfarben
Bedeutung
SystemColor.desktop
SystemColor.activeCaption
SystemColor.activeCaptionText
SystemColor.activeCaptionBorder
SystemColor.inactiveCaption
SystemColor.inactiveCaptionText
Hintergrundfarbe fr Fenster
SystemColor.windowBorder
Farbe fr Fensterrahmen
SystemColor.windowText
SystemColor.menu
Hintergrundfarbe fr Mens
SystemColor.menuText
Textfarbe fr Mens
SystemColor.text
Hintergrundfarbe fr Textfelder
SystemColor.textText
Textfarbe fr Textfelder
SystemColor.textHighlight
SystemColor.textHighlightText
SystemColor.textInactiveText
SystemColor.control
Hintergrundfarbe fr Dialogelemente
SystemColor.controlText
Textfarbe fr Dialogelemente
SystemColor.controlHighlight
SystemColor.controlLtHighlight
SystemColor.controlShadow
SystemColor.controlDkShadow
SystemColor.scrollbar
Hintergrundfarbe fr Schieberegler
SystemColor.info
Hintergrundfarbe fr Hilfetext
SystemColor.infoText
Textfarbe fr Hilfetext
/* Listing2502.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2502
extends Frame
{
public static void main(String[] args)
{
Listing2502 wnd = new Listing2502();
}
Listing2502.java
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049 }
public Listing2502()
{
super("Systemfarben");
setBackground(SystemColor.desktop);
setSize(200,100);
setVisible(true);
addWindowListener(new WindowClosingAdapter(true));
}
public void paint(Graphics g)
{
g.setFont(new Font("Serif",Font.PLAIN,36));
FontMetrics fm = g.getFontMetrics();
int sheight
= fm.getHeight();
int curx
= 10;
int cury
= getInsets().top + 10;
//"Tag" in normaler Textfarbe
int swidth = fm.stringWidth("Tag");
g.setColor(SystemColor.text);
g.fillRect(curx,cury,swidth,sheight);
g.setColor(SystemColor.textText);
g.drawString("Tag",curx,cury+fm.getAscent());
//"&" in Blau auf normalem Hintergrund
curx += swidth + 5;
swidth = fm.stringWidth("&");
g.setColor(Color.blue);
g.drawString("&",curx,cury+fm.getAscent());
//"Nacht" in hervorgehobener Textfarbe
curx += swidth + 5;
swidth = fm.stringWidth("Nacht");
g.setColor(SystemColor.textHighlight);
g.fillRect(curx,cury,swidth,sheight);
g.setColor(SystemColor.textHighlightText);
g.drawString("Nacht",curx,cury+fm.getAscent());
}
Ein weiteres Beispiel zur Verwendung der Systemfarben findet sich in Kapitel 32. Das zu Hinweis
dem Dialogelement ScrollPane vorgestellte Beispielprogramm zeigt alle
Systemfarben zusammen mit ihrem Namen in einem verschiebbaren Fenster an.
Titel
<<
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
26.2.1 Grundlagen
Das Druck-API der Version 1.1 ist recht bersichtlich und leicht zu verstehen. Es gibt zwar einige
Restriktionen und Besonderheiten, die beim Erstellen von Druckausgaben zu Problemen fhren knnen,
aber fr einfache Ausdrucke von Text und Grafik ist die Schnittstelle dennoch geeignet.
Grundlage der Druckausgabe ist die Methode getPrintJob der Klasse Toolkit:
public PrintJob getPrintJob(
Frame frame,
String jobtitle,
Properties props
)
java.awt.Toolkit
Sie liefert ein Objekt des Typs PrintJob, das zur Initialisierung eines Druckjobs verwendet werden kann.
Ein Aufruf von getPrintJob fhrt gleichzeitig dazu, da ein plattformspezifischer Druckdialog
aufgerufen wird, der vom Anwender besttigt werden mu. Bricht der Anwender den Druckdialog ab, liefert
getPrintJob den Rckgabewert null. Andernfalls wird der Drucker initialisiert und die Ausgabe kann
beginnen.
Die Klasse PrintJob stellt einige Methoden zur Verfgung, die fr den Ausdruck bentigt werden:
public Graphics getGraphics()
java.awt.PrintJob
Die wichtigste von ihnen ist getGraphics. Sie liefert den Devicekontext zur Ausgabe auf den Drucker.
Der Rckgabewert ist ein Objekt vom Typ PrintGraphics, das aus Graphics abgeleitet ist und wie
ein normaler Devicekontext verwendet werden kann (so, wie er beispielsweise auch an paint bergeben
wird). Mit Hilfe des von getGraphics zurckgegebenen Devicekontexts knnen alle Grafik- und
Textroutinen, die auch in Graphics zur Verfgung stehen, verwendet werden. Bezglich der Verwendung
von Farben gilt scheinbar, da diese bei den linienbezogenen Ausgaberoutinen nicht untersttzt werden.
Hier wird alles schwarz gezeichnet, was nicht den Farbwert (255, 255, 255) hat. Im Gegensatz dazu stellen
die Fllfunktionen Farben (auf einem Schwarzwei-Drucker) als Grauwerte dar. Dabei kann - je nach
Druckertyp - auch Wei eine Vollfarbe sein und dahinter liegende Objekte verdecken.
java.awt.Component
Auf diese Weise kann bereits ohne zustzliche Erweiterungen eine einfache Druckausgabe realisiert werden,
die der Bildschirmausgabe relativ hnlich sieht. Im Gegensatz zu print gibt printAll dabei nicht nur
die aktuelle Komponente, sondern die komplette Container-Hierarchie eines komplexen Dialogs aus. Soll
innerhalb von paint zwischen Bildschirm- und Druckerausgabe unterschieden werden, kann mit dem
Ausdruck g instanceof PrintGraphics das bergebene Graphics-Objekt g auf Zugehrigkeit
zur Klasse PrintGraphics getestet werden.
Die zweite Mglichkeit, die Druckausgabe zu plazieren, besteht darin, eine eigene Methode zu schreiben,
die nur fr die Ausgabe auf den Drucker verantwortlich ist. Diese knnte zunchst den PrintJob und das
PrintGraphics-Objekt beschaffen und anschlieend die Abmessungen der Ausgabeflche wie zuvor
besprochen bestimmen. Die Methode mte dann nicht so programmiert werden, da sie fr Bildschirmund Druckausgabe vernnftige Resultate liefert, sondern knnte ihre Ausgaben ausschlielich fr die
Druckausgabe optimieren. Der Nachteil bei dieser Lung ist natrlich, da Programmcode zum Erstellen der
Ausgabe mglicherweise doppelt vorhanden ist und doppelt gepflegt werden mu.
Das nachfolgende Listing kombiniert beide Varianten und zeigt den Ausdruck einer Testseite. Das
Programm erstellt ein Hauptfenster und ruft zwei Sekunden spter die Methode printTestPage zur
Druckausgabe auf. Darin wird zunchst ein PrintJob erzeugt und dann gem dem oben beschriebenen
Verfahren die Ausgabegre ermittelt. Anschlieend wird der Grafikkontext beschafft und ein Rahmen,
einige Textzeilen mit Angaben zu den Metriken und eine Graustufenmatrix ausgegeben. Nach Ende der
Druckausgabe wird die Seite mit dispose ausgegeben und der Druckjob mit end geschlossen. Der Code
fr die Darstellung der Graustufenmatrix wurde in der Methode paintGrayBoxes implementiert und
wird von der Bildschirm- und Druckausgabe gemeinsam verwendet:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
/* Listing2601.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2601
extends Frame
{
public static void main(String[] args)
{
Listing2601 wnd = new Listing2601();
}
public Listing2601()
{
super("Drucken");
addWindowListener(new WindowClosingAdapter(true));
setBackground(Color.lightGray);
setSize(400,400);
setVisible(true);
//Ausdruck in 2 Sekunden starten
try {
Thread.sleep(2000);
Listing2601.java
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
} catch (InterruptedException e) {
//nichts
}
printTestPage();
}
public void paint(Graphics g)
{
paintGrayBoxes(g, 40, 50);
}
public void printTestPage()
{
PrintJob pjob = getToolkit().getPrintJob(
this,
"Testseite",
null
);
if (pjob != null) {
//Metriken
int pres = pjob.getPageResolution();
int sres = getToolkit().getScreenResolution();
Dimension d2 = new Dimension(
(int)(((21.0 - 2.0) / 2.54) * sres),
(int)(((29.7 - 2.0) / 2.54) * sres)
);
//Ausdruck beginnt
Graphics pg = pjob.getGraphics();
if (pg != null) {
//Rahmen
pg.drawRect(0, 0, d2.width, d2.height);
//Text
pg.setFont(new Font("TimesRoman",Font.PLAIN,24));
pg.drawString("Testseite",40,70);
pg.drawString(
"Druckerauflsung : " + pres + " dpi",
40,
100
);
pg.drawString(
"Bildschirmauflsung : " + sres + " dpi",
40,
130
);
pg.drawString(
"Seitengre : " + d2.width + " * " + d2.height,
40,
160
);
//Graustufenkstchen
paintGrayBoxes(pg, 40, 200);
//Seite ausgeben
pg.dispose();
}
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094 }
pjob.end();
}
}
private void paintGrayBoxes(Graphics g, int x, int y)
{
for (int i = 0; i < 16; ++i) {
for (int j = 0; j < 16; ++j) {
int level = 16 * i + j;
g.setColor(Color.black);
g.drawRect(x + 20 * j, y + 20 * i, 20, 20);
g.setColor(new Color(level, level, level));
g.fillRect(x + 1 + 20 * j, y + 1 + 20 * i, 19, 19);
}
}
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
26.3.1 berblick
Seit dem JDK 1.2 wurde ein anderer Ansatz verfolgt. Anstelle der im vorigen Abschnitt erwhnten Techniken sind nun die
Klassen und Interfaces aus dem Paket java.awt.print zu verwenden, die zwei unterschiedliche Arten von Funktionen zur
Verfgung stellen:
Die Klasse PrinterJob ist fr die Kontrolle des Druckauftrags verantwortlich. Sie dient zum Aufrufen der
plattformspezifischen Konfigurationsdialoge, registriert die Objekte zur Seitenausgabe und startet den eigentlichen
Druckvorgang.
Der eigentliche Ausdruck wird von Objekten des Typs Printable oder Pageable erledigt. Sie werden beim
PrinterJob registriert und zu geeigneter Zeit von diesem mit der Ausgabe der Druckdaten beauftragt.
Anders als im JDK 1.1 stehen nun zwei Konfigurationsdialoge zur Verfgung. Mit dem einen knnen Job-Parameter wie Anzahl
der Kopien, auszudruckende Seiten oder der Druckertyp eingestellt werden. Der andere dient zur Einstellung von
Seitenparametern, mit dem etwa das Papierformat, die Seitengre oder die Randeinstellungen konfiguriert werden knnen.
Beide Dialoge sind optional und knnen auch unterdrckt werden. Alle mit ihrer Hilfe konfigurierbaren Parameter knnen auch
programmgesteuert verndert werden.
java.awt.print.PrinterJob
PrinterJob besitzt Methoden, mit denen einige globale Eigenschaften des Druckauftrags kontrolliert werden knnen:
java.awt.print.PrinterJob
getUserName liefert den Namen des Benutzers, der den Job gestartet hat. getCopies und setCopies dienen zum Zugriff
auf die Anzahl der Kopien, die ausgedruckt werden sollen. Mit getJobName und setJobName kann der Name des
Druckjobs abgefragt bzw. eingestellt werden. Durch Aufruf von cancel kann ein laufender Druckjob abgebrochen werden.
isCancelled liefert true, falls whrend eines laufenden Druckjobs cancel aufgerufen wurde und der Job bei der
nchstmglichen Gelegenheit beendet wird.
Die Klassen Paper und PageFormat
Neben den eigentlichen Druckdaten besitzt eine auszudruckende Seite globale Eigenschaften wie Papiergre und
Randeinstellungen. Diese werden durch die Klassen PageFormat und Paper gekapselt. Paper reprsentiert ein Blatt Papier
mit festgelegten Abmessungen fr Breite, Hhe und bedruckbaren Bereich:
public double getHeight()
public double getWidth()
java.awt.print.Paper
getHeight und getWidth liefern die Hhe bzw. Breite des Papierblatts. getImageableX und getImageableY geben
den Abstand des bedruckbaren Bereichs vom oberen bzw. linken Blattrand an. getImageableWidth und
getImageableHeight geben die Breite bzw. Hhe des bedruckbaren Bereichs an.
Paper speichert und liefert alle Parameter in einer Einheit von 1/72 Zoll. Das entspricht etwa der typographischen Hinweis
Maeinheit "Punkt" und ist etwas lnger als ein Drittel Millimeter. Ein derartiges Raster reprsentiert die Auflsung
eines durchschnittlichen Monitors und ist fr Druckausgaben viel zu grob. Glcklicherweise werden die Werte als
Fliekommazahlen gespeichert und lassen sich zur Erhhung der Genauigkeit skalieren. Wir werden weiter unter auf
die dazu ntigen Techniken zurckkommen.
Die Klasse PageFormat kapselt ein Paper-Objekt und dessen Orientierung:
public static final int PORTRAIT
public static final int LANDSCAPE
public static final int REVERSE_LANDSCAPE
java.awt.print.PageFormat
Ist die Orientierung PORTRAIT, so wird das Blatt in seiner Standardausrichtung verwendet. Es ist also hher als breit, und der
Koordinatenursprung befindet sich links oben. Beim Drucken im LANDSCAPE-Modus wird das Papier dagegen quer verwendet,
und der rechte Rand des Ausdrucks liegt am oberen Blattrand. REVERSE_LANDSCAPE druckt ebenfalls quer, aber mit
umgekehrter Druckrichtung.
PageFormat stellt Methoden zum Zugriff auf das Papier, seine Orientierung und die aus Paper bekannten Methoden zum
Zugriff auf die Seitenabmessungen zur Verfgung:
java.awt.print.Paper
Im Gegensatz zu Paper sind die Rckgabewerte nun aber an die Orientierung angepat. Wird also beispielsweise
im LANDSCAPE-Modus ausgedruckt, liefert getHeight die Breite des Blattes und getWidth dessen Hhe. Die
anderen Methoden verhalten sich analog.
Hinweis
Ein PageFormat-Objekt wird gewhnlich mit der Methode defaultPage der Klasse PrinterJob beschafft:
public PageFormat defaultPage()
java.awt.print.PrinterJob
Es kann dann entweder programmgesteuert oder durch Aufruf des Seitendialogs konfiguriert werden.
Die Konfigurationsdialoge
Die Klasse PrinterJob besitzt zwei Konfigurationsdialoge. Der erste dient zur Konfiguration eines PageFormat-Objekts
und wird mit pageDialog aufgerufen. Der zweite dient zur Konfiguration der globalen Job-Parameter und wird mit
printDialog aufgerufen:
public PageFormat pageDialog(PageFormat page)
java.awt.print.PrinterJob
pageDialog erwartet ein PageFormat-Objekt (das typischerweise durch defaultPage erzeugt wird) und bietet dem
Anwender die Mglichkeit, dessen Eigenschaften zu verndern. Die dafr verwendeten Dialoge sind plattformabhngig, die
Windows-Variante ist in Abbildung 26.2 zu sehen.
Der Rckgabewert von pageDialog ist das konfigurierte PageFormat-Objekt. Hat der Anwender den Dialog mit "OK"
beendet, wird eine Kopie des als Parameter bergebenen Objekts erzeugt, mit den Einstellungen des Anwenders versehen und
an den Aufrufer zurckgegeben. Hat der Anwender den Dialog dagegen abgebrochen, wird das unvernderte Originalobjekt
zurckgegeben. Durch Vergleichen der beiden Objektreferenzen kann also unterschieden werden, ob der Druckvorgang
fortgesetzt oder abgebrochen werden soll.
java.awt.print.Printable
Ein Programm, das Druckausgaben erzeugen will, mu ein Objekt zur Verfgung stellen, das dieses Interface implementiert. Es
mu mit der Methode setPrintable an den PrinterJob bergeben werden und wird von PrinterJob automatisch
aufgerufen, nachdem der Druckvorgang mit print gestartet wurde:
public void setPrintable(Printable painter)
public void setPrintable(Printable painter, PageFormat format)
java.awt.print.PrinterJob
Printable sorgt dabei fr die Druckausgabe, hnlich wie es paint fr die Bildschirmausgabe bei GUI-Komponenten tut.
Jeder (von PrinterJob initiierte) Aufruf von print fordert das Printable-Objekt auf, eine bestimmte Seite
auszudrucken. Der Seitenindex wird dabei in dem Parameter page bergeben, dessen Zhlung bei 0 beginnt.
Zur Erzeugung von Druckausgaben wird das bergebene Graphics-Objekt verwendet, das wie bei der Erzeugung von
Bildschirmausgaben verwendet werden kann. Das bergebene Objekt kann dabei in ein Graphics2D-Objekt konvertiert
werden und stellt so die erweiterten Funktionen des 2D-APIs zur Verfgung.
Weiterhin wird das konfigurierte PageFormat als Argument an print bergeben. Innerhalb von print wird es dazu
benutzt, die Gre des Papiers und dessen bedruckbaren Bereich zu ermitteln.
Es ist sehr wichtig, zu wissen, da print fr ein und dieselbe Seite mehrfach aufgerufen werden kann (und
normalerweise auch wird). Da die JDK-Dokumentation keine Aussagen darber macht, wie oft und in welcher
Reihenfolge die Seiten abgefordert werden, mu das Printable-Objekt selbst fr eine geeignete Verwaltung der
bentigten Statusinformationen sorgen.
Hinweis
Der Rckgabewert von print gibt an, ob die Seitenzahl gltig war und die Druckausgabe erzeugt werden konnte, oder ob eine
ungltige Seitenzahl bergeben wurde. Im ersten Fall gibt print die in Printable definierte Konstante PAGE_EXISTS
zurck, im zweiten Fall NO_SUCH_PAGE. Da der PrinterJob nicht von Anfang an wei, wie viele Seiten insgesamt
ausgedruckt werden sollen, mu er beim Aufruf von print schrittweise den Seitenzhler erhhen und darauf warten, da
NO_SUCH_PAGE zurckgegeben wird. Danach erfolgen keine weiteren Aufrufe von print.
Will das Printable-Objekt den kompletten Job whrend der Ausgabe abbrechen, braucht es dazu lediglich whrend
des Aufrufs von print eine PrinterException auszulsen. Diese wird vom PrinterJob abgefangen und fhrt
zum Abbruch des Druckjobs.
Tip
java.awt.print.Pageable
Ein Pageable-Objekt kennt (normalerweise) die Anzahl der auszudruckenden Seiten und stellt diese auf Anfrage als
Rckgabewert von getNumberOfPages zur Verfgung. Wahlweise kann aber auch die Konstante
UNKNOWN_NUMBER_OF_PAGES zurckgegeben werden, wenn die Seitenzahl nicht von vorneherein bekannt ist. Im
Unterschied zu einem Printable-Objekt (das ja auch mehrere Seiten ausdrucken kann), kann ein Pageable zu den
einzelnen Seiten unterschiedliche PageFormat- und Printable-Objekte zur Verfgung stellen. Sie werden whrend des
Druckvorgangs mit den Methoden getPageFormat und getPrintable abgefragt.
Mit der Klasse Book stellt java.awt.print eine konkrete Implementierung von Pageable zur Verfgung. Ein Book ist
dabei nichts anderes als eine nach Seitenzahlen indizierte Liste von (PageFormat/Printable)-Paaren, die mit einigen
einfachen Methoden gepflegt werden kann:
public void append(Printable painter, PageFormat pf)
public void append(Printable painter, PageFormat pf, int numPages)
java.awt.print.Book
Mit append werden eine oder mehrere Seiten mit den angegebenen Printable- und PageFormat-Objekten an das Ende
des Buchs angehngt. Mit setPage kann gezielt eine bereits bestehende Seite verndert werden.
/* FilePrintHelper.java */
import java.util.*;
public class FilePrintHelper
{
//---Membervariablen---------------------------------Vector pageinfo;
//---Konstruktor-------------------------------------public FilePrintHelper()
{
pageinfo = new Vector();
}
//---Seitendefinition und -abfrage-------------------public void createPage(int page)
{
for (int i = pageinfo.size(); i <= page; ++i) {
pageinfo.addElement(new Entry());
FilePrintHelper.java
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052 }
}
}
public boolean knownPage(int page)
{
return page < pageinfo.size();
}
//---Verwaltung der Offsets--------------------------public long getFileOffset(int page)
{
Entry entry = (Entry)pageinfo.elementAt(page);
return entry.fileoffset;
}
public void setFileOffset(int page, long fileoffset)
{
Entry entry = (Entry)pageinfo.elementAt(page);
entry.fileoffset = fileoffset;
}
//---Lokale Klasse Entry-----------------------------static class Entry
{
public long fileoffset;
public Entry()
{
this.fileoffset = -1;
}
}
Zunchst wird ein SimpleFilePrinter instanziert. Es erzeugt durch Aufruf von getPrinterJob eine Instanz der
Klasse PrinterJob.
In setupPageFormat wird durch Aufruf von defaultPage ein PageFormat beschafft und zur Bearbeitung an
den Seitendialog bergeben. Die Methode prft anschlieend, ob der Dialog mit "OK" oder "Abbrechen" verlassen
wurde, und gibt entweder true oder false zurck (letzteres fhrt in main zum Abbruch des Druckvorgangs).
In setupJobOptions wird der Dialog zur Konfiguration der Job-Parameter aufgerufen. Auch hier fhrt ein Abbruch
des Anwenders zum Ende des gesamten Druckvorgangs.
Schlielich wird in printFile der eigentliche Druckvorgang angestoen. Dazu wird zunchst ein
RandomAccessFile fr die auszudruckende Datei angelegt und ein FilePrintHelper instanziert. Anschlieend
wird die Druckausgabe durch Aufruf von print gestartet.
Nachfolgend zeigen wir die Implementierung von SimpleFilePrinter. Der eigentlich komplizierte Code steckt natrlich
in der Methode print, die wir im Anschlu an das Listing erlutern wollen.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
/* SimpleFilePrinter.java */
import java.awt.*;
import java.awt.print.*;
import java.io.*;
public class SimpleFilePrinter
implements Printable
{
//---Konstanten-------------------------------------private static final int RESMUL = 4;
//---Membervariablen--------------------------------private PrinterJob
pjob;
private PageFormat
pageformat;
private FilePrintHelper fph;
private String
fname;
private RandomAccessFile in;
//---Konstruktoren----------------------------------public SimpleFilePrinter(String fname)
{
this.pjob = PrinterJob.getPrinterJob();
this.fname = fname;
}
//---ffentliche Methoden---------------------------public boolean setupPageFormat()
{
PageFormat defaultPF = pjob.defaultPage();
this.pageformat = pjob.pageDialog(defaultPF);
pjob.setPrintable(this, this.pageformat);
return (this.pageformat != defaultPF);
}
public boolean setupJobOptions()
{
return pjob.printDialog();
}
public void printFile()
throws PrinterException, IOException
{
fph = new FilePrintHelper();
in = new RandomAccessFile(fname, "r");
pjob.print();
in.close();
}
//---Implementierung von Printable------------------public int print(Graphics g, PageFormat pf, int page)
throws PrinterException
{
int ret = PAGE_EXISTS;
String line = null;
try {
if (fph.knownPage(page)) {
in.seek(fph.getFileOffset(page));
line = in.readLine();
} else {
long offset = in.getFilePointer();
line = in.readLine();
if (line == null) {
SimpleFilePrinter.java
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124 }
ret = NO_SUCH_PAGE;
} else {
fph.createPage(page);
fph.setFileOffset(page, offset);
}
}
if (ret == PAGE_EXISTS) {
//Seite ausgeben, Grafikkontext vorbereiten
Graphics2D g2 = (Graphics2D)g;
g2.scale(1.0 / RESMUL, 1.0 / RESMUL);
int ypos = (int)pf.getImageableY() * RESMUL;
int xpos = ((int)pf.getImageableX() + 2) * RESMUL;
int yd = 12 * RESMUL;
int ymax = ypos + (int)pf.getImageableHeight() * RESMUL - yd;
//Seitentitel ausgeben
ypos += yd;
g2.setColor(Color.black);
g2.setFont(new Font("Monospaced", Font.BOLD, 10 * RESMUL));
g.drawString(fname + ", Seite " + (page + 1), xpos, ypos);
g.drawLine(
xpos,
ypos + 6 * RESMUL,
xpos + (int)pf.getImageableWidth() * RESMUL,
ypos + 6 * RESMUL
);
ypos += 2 * yd;
//Zeilen ausgeben
g2.setColor(new Color(0, 0, 127));
g2.setFont(new Font("Monospaced", Font.PLAIN, 10 * RESMUL));
while (line != null) {
g.drawString(line, xpos, ypos);
ypos += yd;
if (ypos >= ymax) {
break;
}
line = in.readLine();
}
}
} catch (IOException e) {
throw new PrinterException(e.toString());
}
return ret;
}
//---Main-------------------------------------------public static void main(String[] args)
{
SimpleFilePrinter sfp = new SimpleFilePrinter(args[0]);
if (sfp.setupPageFormat()) {
if (sfp.setupJobOptions()) {
try {
sfp.printFile();
} catch (Exception e) {
System.err.println(e.toString());
System.exit(1);
}
}
}
System.exit(0);
}
In print wird zunchst geprft, ob die Seite schon einmal aufgerufen wurde. Ist das der Fall, wird ihr Dateioffset vom
FilePrintHelper geholt und die erste Zeile der Seite erneut eingelesen. Falls nicht, prft die Methode, ob berhaupt noch
weitere Daten vorhanden sind. In diesem Fall bergibt sie den Dateioffset zur Speicherung an den FilePrintHelper.
Andernfalls setzt es den Rckgabewert auf NO_SUCH_PAGE, und die Ausgabe der Seite ist beendet.
Falls die Seite existiert, wird sie nun ausgegeben (im Listing ab Zeile 072). Dazu wird der Grafikkontext nach Graphics2D
konvertiert und anschlieend auf den Kehrwert der Konstante RESMUL skaliert. Da RESMUL den Wert 4 hat, fhrt das dazu, da
alle Ausgaben um den Faktor 4 verkleinert werden. Dieser Kunstgriff wird angewendet, um bei der Ausgabe nicht mit der
groben Standardauflsung von 72 dpi arbeiten zu mssen. Die auf diese Weise simulierten 288 dpi lassen die Linie unter der
Kopfzeile hinreichend dnn erscheinen. Sie wre ansonsten mit einem viel zu krftigen 1/72 Zoll breiten Pixelstrich gezeichnet
worden. Da nun auch alle anderen Positions- und Lngenangaben um den Faktor 4 verkleinert werden, multiplizieren wir sie in
den folgenden Programmzeilen jeweils mit RESMUL und skalieren sie so auf ihre normale Gre zurck.
Ab Zeile 079 wird der Seitentitel ausgeben. Dazu wird die Schriftfarbe auf schwarz eingestellt und eine fette Schrift ausgewhlt.
Die Variable ypos reprsentiert den vertikalen Offset vom oberen Papierrand. Sie wird am Anfang auf das obere Ende des
bedruckbaren Bereichs gestellt und nach jeder Zeile um einen konstanten Wert erhht. Ab Zeile 091 werden die Textzeilen
ausgegeben. Mit readLine wird dazu in einer Schleife die jeweils nchste Zeile aus der Eingabedatei gelesen und - wenn
vorhanden - an der aktuellen y-Position ausgegeben. Falls keine weiteren Zeilen vorhanden sind oder das Ende des
bedruckbaren Bereichs erreicht ist, wird die Schleife beendet.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Das Abstract Windowing Toolkit von Java enthlt verschiedene Fensterklassen, die
ber eine gemeinsame Vererbungshierarchie miteinander in Verbindung stehen
(siehe Abbildung 27.1). Oberste Fensterklasse ist Component, daraus wurde
Container abgeleitet. Container ist die Oberklasse der beiden Klassen
Window und Panel. Whrend Window sich in die Unterklassen Frame und
Dialog verzweigt, wird aus Panel die Klasse Applet abgeleitet. Unterhalb von
Dialog gibt es noch den Standard-File-Dialog in der Klasse FileDialog.
Die Klasse Frame reprsentiert ein Top-Level-Window mit Rahmen, Titelleiste und
optionalem Men. Einem Frame kann ein Icon zugeordnet werden, das angezeigt
wird, wenn das Fenster minimiert wird. Es kann eingestellt werden, ob das Fenster
vom Anwender in der Gre verndert werden kann. Zustzlich besteht die
Mglichkeit, das Aussehen des Mauszeigers zu verndern.
Die zweite aus Window abgeleitete Klasse ist Dialog. Sie ist dafr vorgesehen,
modale oder nicht-modale Dialoge zu realisieren. Ein modaler Dialog ist ein Fenster,
das immer im Vordergrund des Fensters bleibt, von dem es erzeugt wurde, und das
alle brigen Fensteraktivitten und Ereignisse so lange blockiert, bis es geschlossen
wird. Ein nicht-modaler Dialog kann mit anderen Fenstern koexistieren und erlaubt
es, im aufrufenden Fenster weiterzuarbeiten.
Aufgrund von Bugs in der Windows-Portierung des AWT gab es bis zur
Version 1.0.2 des AWT keine vernnftige Mglichkeit, modale Dialoge
zu erzeugen. Dies war ein ziemlich schwerwiegendes Problem, denn
modale Dialoge kommen in der Programmentwicklung sehr hufig vor.
Sie werden immer dann bentigt, wenn das Programm auf die Eingabe
eines Anwenders warten mu, bevor es fortfahren kann. Leider
funktionierte gerade dieser Wartemechanismus nicht, und es wurden eine
Reihe aufwendiger Workarounds verffentlicht. Mit der Version 1.1 des
JDK war es erstmals auch unter Windows 95 mglich, echte modale
Dialoge in Java zu erstellen. Wir werden auf die Details in Kapitel 31
zurckkommen.
Hinweis
Die unterste Klasse in der Hierarchie der Fenster ist FileDialog. Sie stellt den
Standard-Dateidialog des jeweiligen Betriebssystems zur Verfgung. Dieser kann
beim Laden oder Speichern einer Datei zur Eingabe oder Auswahl eines Dateinamens
verwendet werden. Gegenber den Mglichkeiten des Standard-Dateidialogs, wie er
vom Windows-API zur Verfgung gestellt wird, sind die Fhigkeiten der Klasse
FileDialog allerdings etwas eingeschrnkt.
<
>
>>
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Ein Fenster besitzt eine Reihe von Eigenschaften, die sein Aussehen bestimmen. Dazu gehren die Art
des Rahmens, die Position und Gre des Fensters und die Anordnung des Fensters in Relation zu
anderen Fenstern auf dem Bildschirm.
Wie schon erwhnt, wird die Art des Rahmens durch die Klasse bestimmt, die zur Erzeugung eines
Fensters verwendet wird. Whrend die Klasse Window ein Fenster ohne Rahmen darstellt, besitzt ein
Frame einen Rahmen, eine Titelleiste und auf Wunsch ein Men.
Die Gre und Position eines Fensters knnen mit den Methoden setSize, setBounds und
setLocation bestimmt werden:
public void setSize(int width, int height)
public void setSize(Dimension d)
java.awt.Component
setSize verndert die Gre des Fensters auf den Wert (width, height), und setLocation
bewegt die linke obere Ecke an die Bildschirmposition (x,y). Die Methode setBounds kombiniert
die Funktionen von setSize und setLocation und positioniert ein Fenster der Gre
(width,height) an der Position (x,y). Mit getSize, getBounds und getLocation
knnen diese Eigenschaften auch abgefragt werden.
Mit den Methoden setEnabled und isEnabled kann auf den Aktivierungszustand einer
Komponente zugegriffen werden:
java.awt.Component
Ist die Komponente aktiv, kann sie Benutzereingaben empfangen und Nachrichten versenden. In
deaktiviertem Zustand geht das nicht. Dialogelemente wie Textfelder oder Buttons werden deaktiviert,
um dem Anwender anzuzeigen, da eine bestimmte Funktion oder Eingabemglichkeit derzeit nicht zur
Verfgung steht. Sie zeigen den Unterschied zwischen beiden Zustnden auch optisch an. Bei
Fensterkomponenten wird der Aktivierungszustand meist nicht verndert.
Das folgende Beispiel stellt eine sehr einfache Form eines (manuell zu aktivierenden)
Bildschirmschoners dar, der den gesamten Bildschirm dunkel schaltet und die Anmerkung Bitte eine
Taste drcken in die linke obere Ecke schreibt. Zustzlich gibt das Programm die aktuelle Auflsung
des Bildschirms aus, nachdem sie mit der Methode getScreenSize der Klasse Toolkit ermittelt
wurde. Nach Drcken einer Taste wird das Fenster geschlossen und das Programm beendet:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
/* Listing2702.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2702
extends Window
{
public static void main(String[] args)
{
final Listing2702 wnd = new Listing2702();
wnd.setLocation(new Point(0,0));
wnd.setSize(wnd.getToolkit().getScreenSize());
wnd.setVisible(true);
wnd.requestFocus();
wnd.addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent event)
{
wnd.setVisible(false);
wnd.dispose();
System.exit(0);
}
}
);
}
public Listing2702()
{
super(new Frame());
setBackground(Color.black);
}
public void paint(Graphics g)
{
Listing2702.java
036
037
038
039
040
041
042
043
044
}
045 }
g.setColor(Color.red);
g.drawString(
"Bildschirmgre ist "+
getSize().width+"*"+getSize().height,
10,
20
);
g.drawString("Bitte eine Taste drcken",10,40);
Hinweis
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
27.5 Fensterelemente
27.5 Fensterelemente
27.5.1 Der Fenstertitel
27.5.2 Das Icon des Fensters
27.5.3 Der Mauscursor
27.5.4 Die Vorder- und Hintergrundfarbe
27.5.5 Der Standard-Font
Neben den visuellen Eigenschaften eines Fensters gibt es noch eine Reihe weiterer Elemente, die
einem Fenster zugeordnet werden knnen. Hierzu zhlen die Titelleiste, das Men, ein Icon, ein
Mauscursor, eine bestimmte Vorder- und Hintergrundfarbe und ein Standard-Font zur Ausgabe von
Schriften. Bis auf die Definition und die Zuordnung von Mens, die in Kapitel 30 erlutert werden,
soll der Umgang mit diesen Fensterelementen in den folgenden Unterabschnitten erklrt werden.
java.awt.Frame
Ein Aufruf dieser Methode ndert die Beschriftung der Titelleiste in den als String bergebenen
Parameter title. Mit der Methode getTitle kann die Titelleiste abgefragt werden.
java.awt.Frame
Beim Design des Icons steht man nun vor dem Konflikt, entscheiden zu mssen, in welcher Gre
das Icon entworfen werden soll. Ein Windows-Programm hat meist ein Haupticon in der Gre
32*32 Pixel und ein kleineres Icon mit 16*16 Pixeln. Beide werden an unterschiedlichen Stellen im
Programm bentigt. Das JDK ist glcklicherweise in der Lage, die bergebenen Images so zu
skalieren, da sie die jeweils bentigte Gre annehmen. Die Ergebnisse sind im Falle des groen
Icons durchaus brauchbar (so hat z.B. das in Abbildung 27.3 gezeigte und in Listing 27.4 verwendete
Icon eine Originalgre von 60*56 Pixeln), im Falle des kleinen Icons sind die Ergebnisse in Pr-1.2JDKs jedoch nicht so befriedigend. Hier scheint die Skalierungsroutine lediglich ein schwarz-weies
Ergebnis zu erzeugen.
Hinweis
Die Klasse Cursor besitzt einen Konstruktor, der als einziges Argument eine ganzzahlige
Konstante erwartet, mit der der gewnschte Cursor aus der Liste der vordefinierten Cursortypen
ausgewhlt werden kann. Tabelle 27.1 gibt eine Auswahl der verfgbaren Cursortypen an.
Das freie Erstellen benutzerdefinierter Cursortypen wird seit dem JDK 1.2 untersttzt. JDK1.1-1.4
Dazu gibt es in der Klasse Toolkit die Methoden createCustomCursor,
getBestCursorSize und getMaximumCursorColors. Wir wollen darauf
nicht nher eingehen.
Konstante aus Frame
Cursorform
Cursor.CROSSHAIR_CURSOR
Fadenkreuz
Cursor.DEFAULT_CURSOR
Standardpfeil
Cursor.MOVE_CURSOR
Vierfachpfeil
Cursor.TEXT_CURSOR
Senkrechter Strich
Cursor.WAIT_CURSOR
Eieruhr
java.awt.Component
java.awt.Component
Das folgende Beispielprogramm erzeugt ein Fenster mit einer Titelleiste, gesetzter Vorder- und
Hintergrundfarbe und der Eieruhr als Cursor. Zustzlich besitzt das Programm das in Abbildung 27.3
gezeigte Icon, das beim Minimieren des Programms und in der Taskleiste angezeigt wird.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
/* Listing2704.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2704
extends Frame
{
public static void main(String[] args)
{
Listing2704 wnd = new Listing2704();
wnd.setSize(300,200);
wnd.setLocation(50,50);
wnd.setVisible(true);
Listing2704.java
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
}
public Listing2704()
{
super("");
assignTitle();
assignIcon();
assignCursor();
assignColors();
assignFont();
addWindowListener(new WindowClosingAdapter(true));
}
private void assignTitle()
{
setTitle("Vernderte Fensterelemente");
}
private void assignIcon()
{
Image img = getToolkit().getImage("testicon.gif");
MediaTracker mt = new MediaTracker(this);
mt.addImage(img, 0);
try {
//Warten, bis das Image vollstndig geladen ist,
mt.waitForAll();
} catch (InterruptedException e) {
//nothing
}
setIconImage(img);
}
private void assignCursor()
{
setCursor(new Cursor(Cursor.WAIT_CURSOR));
}
private void assignColors()
{
setForeground(Color.white);
setBackground(Color.black);
}
private void assignFont()
{
setFont(new Font("Serif", Font.PLAIN, 28));
}
public void paint(Graphics g)
065
{
066
g.drawString("Test in Vordergrundfarbe",10,70);
067
}
068 }
Listing 27.4: Ein Programm mit vernderten Fensterelementen
Die Programmausgabe ist wie folgt:
Inhalt Suchen
<
>
Index
DOC
>>
API
28.1.1 Grundlagen
Bei der Programmierung unter einer grafischen Oberflche erfolgt die
Kommunikation zwischen Betriebssystem und Anwendungsprogramm zu einem
wesentlichen Teil durch das Versenden von Nachrichten. Die Anwendung wird dabei
ber alle Arten von Ereignissen und Zustandsnderungen vom Betriebssystem
informiert. Dazu zhlen beispielsweise Mausklicks, Bewegungen des Mauszeigers,
Tastatureingaben oder Vernderungen an der Gre oder Lage des Fensters.
Bei der Verarbeitung des Nachrichtenverkehrs sind zwei verschiedene Arten von
Objekten beteiligt. Die Ereignisquellen (Event Sources) sind die Auslser der
Nachrichten. Eine Ereignisquelle kann beispielsweise ein Button sein, der auf einen
Mausklick reagiert, oder ein Fenster, das mitteilt, da es ber das Systemmen
geschlossen werden soll. Die Reaktion auf diese Nachrichten erfolgt in den speziellen
Ereignisempfngern (den EventListeners); das sind Objekte, die das zum Ereignis
passende Empfnger-Interface implementieren. Damit ein Ereignisempfnger die
Nachrichten einer bestimmten Ereignisquelle erhlt, mu er sich bei dieser
registrieren.
Dieses Kommunikationsmodell nennt sich Delegation Event Model oder Delegation
Based Event Handling und wurde mit der Version 1.1 des JDK eingefhrt. Im
Gegensatz zum alten Modell, bei dem jedes Ereignis die Verteilermethode
handleEvent der Klasse Component durchlaufen mute und von ihr an die
verschiedenen Empfnger verteilt wurde, hat dieses neue Modell zwei wesentliche
Vorteile:
Die Fensterklasse implementiert die erforderlichen EventListenerInterfaces, stellt die erforderlichen Callback-Methoden zur Verfgung und
registriert sich selbst bei den Ereignisquellen.
In der Fensterklasse werden lokale oder anonyme Klassen definiert, die einen
EventListener implementieren oder sich aus einer Adapterklasse ableiten
Wir werden uns jede dieser Varianten in den nachfolgenden Abschnitten ansehen und
ihre jeweiligen Einsatzmglichkeiten anhand eines Beispiels aufzeigen. Zunchst
sollen jedoch die verschiedenen Ereignistypen sowie die Ereignisempfnger und
Ereignisquellen nher beleuchtet werden. Wir wollen dabei (etwas unscharf) die
Begriffe Ereignis, Nachricht und Event in diesem Kapitel synonym verwenden, wenn
wir innerhalb eines GUI-Programms die ausgetauschten Nachrichten oder ihre
auslsenden Ereignisse meinen.
Das vorliegende Kapitel beschrnkt sich auf das Erlutern der
grundlegenden Eigenschaften des Event-Handlings im JDK 1.1. Die
Details einzelner Ereignisarten werden in den nachfolgenden Kapiteln
schrittweise erklrt und zusammen mit den zugehrigen Ereignisquellen
vorgestellt.
Hinweis
28.1.2 Ereignistypen
Im Gegensatz zur Version 1.0 werden im JDK 1.1 die Ereignistypen nicht mehr
durch eine einzige Klasse Event reprsentiert, sondern durch eine Hierarchie von
Ereignisklassen, die aus der Klasse java.util.EventObject abgeleitet sind.
Die Motivation der Java-Designer, diese Klasse in das Paket java.util zu legen,
resultierte wohl aus der berlegung, da der Transfer von Nachrichten nicht allein
auf den Oberflchenteil beschrnkt sein mu, sondern auch zwischen anderen
Elementen einer komplexen Anwendung sinnvoll sein kann. Die Klasse
java.util.EventObject fungiert damit als allgemeine Oberklasse aller Arten
von Ereignissen, die zwischen verschiedenen Programmteilen ausgetauscht werden
knnen. Ihre einzige nennenswerte Fhigkeit besteht darin, das Objekt zu speichern,
das die Nachricht ausgelst hat, und durch Aufruf der Methode getSource
anzugeben:
public Object getSource()
java.util.EventObject
Die Hierarchie der AWT-spezifischen Ereignisklassen beginnt eine Ebene tiefer mit
der Klasse AWTEvent, die aus EventObject abgeleitet wurde und sich im Paket
java.awt befindet. AWTEvent ist Oberklasse aller Ereignisklassen des AWT.
Diese befinden sich im Paket java.awt.event, das damit praktisch in jede
Klasse einzubinden ist, die sich mit dem Event-Handling von GUI-Anwendungen
beschftigt. Abbildung 28.1 gibt einen berblick ber die Vererbungshierarchie der
Ereignisklassen.
Hinweis
java.awt.AWTEvent
Falls das Programm eigene Eventklassen definieren will und Konstanten zur Vergabe
der Event-Ids vergeben mu, sollten diese oberhalb der symbolischen Konstante
RESERVED_ID_MAX liegen.
Die Eventklassen im JDK 1.1 enthalten keine frei zugnglichen Felder.
Hinweis
Statt dessen sind alle Eigenschaften durch set-/get-Methoden gekapselt,
die je nach Ereignisklasse unterschiedlich sind. So gibt es beispielsweise
in MouseEvent die Methode getPoint, mit der die
Mauszeigerposition abgefragt werden kann, in KeyEvent die Methode
getKeyChar zur Bestimmung der gedrckten Taste und in der
bergeordneten Klasse InputEvent die Methode getModifiers, mit
der sowohl fr Maus- als auch fr Tastaturevents der Zustand der
Sondertasten bestimmt werden kann. Wir werden bei der Besprechung der
einzelnen Ereignisarten auf die Details eingehen.
28.1.3 Ereignisempfnger
Damit ein Objekt Nachrichten empfangen kann, mu es eine Reihe von Methoden
implementieren, die von der Nachrichtenquelle, bei der es sich registriert hat,
aufgerufen werden knnen. Um sicherzustellen, da diese Methoden vorhanden sind,
mssen die Ereignisempfnger bestimmte Interfaces implementieren, die aus der
Klasse EventListener des Pakets java.util abgeleitet sind. Diese
EventListener-Interfaces befinden sich im Paket java.awt.events.
Je Ereignisklasse gibt es ein EventListener-Interface. Es definiert eine separate
28.1.4 Ereignisquellen
Die Ereignisse stammen von den Ereignisquellen, also von Fenstern,
Dialogelementen oder hheren Programmobjekten. Eine Ereignisquelle sendet aber
nur dann Ereignisse an einen Ereignisempfnger, wenn dieser sich bei der
Ereignisquelle registriert hat. Fehlt eine solche Registrierung, wird die
Ereignisquelle keine Ereignisse senden und der Empfnger folglich auch keine
erhalten.
Die Registrierung erfolgt mit speziellen Methoden, an die ein Objekt bergeben wird,
das das jeweilige EventListener-Interface implementiert. So gibt es
beispielsweise eine Methode addMouseListener in der Klasse Component, mit
der ein Objekt, das das Interface MouseListener implementiert, sich fr den
Empfang von Mausereignissen bei der Komponente registrieren lassen kann. Nach
erfolgter Registrierung wird bei jedem Mausereignis die entsprechende Methode
mouseClicked, mouseEntered, mouseExited, mousePressed oder
mouseReleased aufgerufen.
Die Ereignisquellen untersttzen das Multicasting von Ereignissen. Dabei Hinweis
kann eine Ereignisquelle nicht nur einen einzelnen EventListener mit
Nachrichten versorgen, sondern eine beliebige Anzahl von ihnen. Jeder
Aufruf von addXYZListener registriert dabei einen weiteren Listener
in der Ereignisquelle. Das AWT definiert nicht, in welcher Reihenfolge
die verschiedenen Ereignisempfnger beim Auftreten eines Ereignisses
aufgerufen werden, und empfiehlt den Programmen, hierber keine
Annahmen zu treffen.
28.1.5 Adapterklassen
Eine Adapterklasse in Java ist eine Klasse, die ein vorgegebenes Interface mit leeren
Methodenrmpfen implementiert. Adapterklassen knnen verwendet werden, wenn
aus einem Interface lediglich ein Teil der Methoden bentigt wird, der Rest aber
uninteressant ist. In diesem Fall leitet man einfach eine neue Klasse aus der
Adapterklasse ab, anstatt das zugehrige Interface zu implementieren, und berlagert
die bentigten Methoden. Alle brigen Methoden des Interfaces werden von der
Basisklasse zur Verfgung gestellt.
Zu jedem der Low-Level-Ereignisempfnger stellt das Paket java.awt.event
eine passende Adapterklasse zur Verfgung. So gibt es die Adapterklassen
FocusAdapter, KeyAdapter, MouseAdapter, MouseMotionAdapter,
ComponentAdapter, ContainerAdapter und WindowAdapter. Sie
implementieren die korrespondierenden Interfaces. Wir werden spter bei der
Beschreibung der lokalen und anonymen Klassen sehen, wie die Adapterklassen bei
der Realisierung der Ereignisempfnger hilfreich sein knnen.
28.1.6 Zusammenfassung
Der folgende berblick bndelt die bisherigen Ausfhrungen und gibt eine
Zusammenfassung aller Ereignisse nebst zugehrigen Ereignisempfngern und ihren
Methoden. Auerdem sind die Ereignisquellen und die Methoden zur Registrierung
der Ereignisse angegeben. Jeder Ereignistyp wird dabei durch zwei Tabellen
dargestellt. Die erste gibt die zugehrige Ereignisklasse, das Listener-Interface und
den Namen der Methode zur Registrierung von Ereignisempfngern an. Sie listet
auerdem die als Ereignisquelle in Frage kommenden Klassen auf. Die zweite
Tabelle enthlt alle Methoden des zugehrigen Listener-Interfaces und beschreibt
damit die zu diesem Ereignistyp gehrenden Elementarereignisse.
Genaugenommen nimmt dieser Abschnitt Informationen vorweg, die in
Hinweis
spteren Teilen des Buches konkretisiert werden. Obwohl zum jetzigen
Zeitpunkt nicht alle Ereignisse in ihrer vollen Bedeutung dargestellt
werden knnen, mag diese bersicht fr die weitere Arbeit mit dem AWT
und zum Nachschlagen hilfreich sein.
Focus-Ereignisse
Eigenschaft
Ereignisklasse
FocusEvent
Listener-Interface
FocusListener
Registrierungsmethode
addFocusListener
Mgliche Ereignisquellen
Component
Bedeutung
focusGained
focusLost
Ereignisklasse
KeyEvent
Listener-Interface
KeyListener
Registrierungsmethode
addKeyListener
Mgliche Ereignisquellen
Component
Bedeutung
keyPressed
keyReleased
keyTyped
Ereignisklasse
MouseEvent
Listener-Interface
MouseListener
Registrierungsmethode
addMouseListener
Mgliche Ereignisquellen
Component
Bedeutung
mouseClicked
mouseEntered
mouseExited
mousePressed
mouseReleased
Eigenschaft
Ereignisklasse
MouseEvent
Listener-Interface
MouseMotionListener
Registrierungsmethode
addMouseMotionListener
Mgliche Ereignisquellen
Component
Bedeutung
mouseDragged
mouseMoved
Ereignisklasse
ComponentEvent
Listener-Interface
ComponentListener
Registrierungsmethode
addComponentListener
Mgliche Ereignisquellen
Component
Bedeutung
componentHidden
componentMoved
componentResized
componentShown
Container-Ereignisse
Eigenschaft
Ereignisklasse
ContainerEvent
Listener-Interface
ContainerListener
Registrierungsmethode
addContainerListener
Mgliche Ereignisquellen
Container
Bedeutung
componentAdded
componentRemoved
Ereignisklasse
WindowEvent
Listener-Interface
WindowListener
Registrierungsmethode
addWindowListener
Mgliche Ereignisquellen
Dialog, Frame
Bedeutung
windowActivated
windowClosed
windowClosing
windowDeactivated
windowDeiconified
windowIconified
windowOpened
Ereignisklasse
ActionEvent
Listener-Interface
ActionListener
Registrierungsmethode
addActionListener
Mgliche Ereignisquellen
Bedeutung
actionPerformed
Ereignisklasse
AdjustmentEvent
Listener-Interface
AdjustmentListener
Registrierungsmethode
addAdjustmentListener
Mgliche Ereignisquellen
Scrollbar
Bedeutung
Ereignisklasse
ItemEvent
Listener-Interface
ItemListener
Registrierungsmethode
addItemListener
Mgliche Ereignisquellen
Bedeutung
itemStateChanged
Ereignisklasse
TextEvent
Listener-Interface
TextListener
Registrierungsmethode
addTextListener
Mgliche Ereignisquellen
TextField, TextArea
Bedeutung
textValueChanged
<
>
>>
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Wir wollen uns in diesem Abschnitt damit beschftigen, die oben erwhnten Entwurfsmuster fr die
Abwicklung des Nachrichtenverkehrs in Java-Programmen vorzustellen. Wie bereits erwhnt, hat jedes
dieser Verfahren seine ganz spezifischen Vor- und Nachteile und ist fr verschiedene Programmieraufgaben
unterschiedlich gut geeignet.
Als Basis fr unsere Experimente wollen wir ein einfaches Programm schreiben, das die folgenden
Anforderungen erfllt:
Nach dem Start soll das Programm ein Fenster mit dem Titel Nachrichtentransfer auf dem
Bildschirm anzeigen.
Das Fenster soll einen grauen Hintergrund haben und in der Client-Area die Meldung Zum Beenden
bitte ESC drcken ... anzeigen.
Nach Drcken der Taste [ESC] soll das Fenster geschlossen und das Programm beendet werden.
Andere Tastendrcke, Mausklicks oder hnliche Ereignisse werden ignoriert.
/* Listing2801.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2801
extends Frame
{
public static void main(String[] args)
{
Listing2801 wnd = new Listing2801();
}
public Listing2801()
{
Listing2801.java
016
017
018
019
020
021
022
023
024
025
026
027
028 }
super("Nachrichtentransfer");
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
}
public void paint(Graphics g)
{
g.setFont(new Font("Serif",Font.PLAIN,18));
g.drawString("Zum Beenden bitte ESC drcken...",10,50);
}
Hinweis
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
/* Listing2802.java */
Listing2802.java
import java.awt.*;
import java.awt.event.*;
public class Listing2802
extends Frame
implements KeyListener
{
public static void main(String[] args)
{
Listing2802 wnd = new Listing2802();
}
public Listing2802()
{
super("Nachrichtentransfer");
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
addKeyListener(this);
}
public void paint(Graphics g)
{
g.setFont(new Font("Serif",Font.PLAIN,18));
g.drawString("Zum Beenden bitte ESC drcken...",10,50);
}
public void keyPressed(KeyEvent event)
{
if (event.getKeyCode() == KeyEvent.VK_ESCAPE) {
setVisible(false);
dispose();
System.exit(0);
}
}
public void keyReleased(KeyEvent event)
{
}
public void keyTyped(KeyEvent event)
{
}
}
weitergeleitet und fhren zum Aufruf der Methoden keyPressed, keyReleased oder keyTyped des
Interfaces KeyListener. Diese Implementierung ist sehr naheliegend, denn sie ist einfach zu
implementieren und erfordert keine weiteren Klassen. Nachteilig ist dabei allerdings:
Es besteht keine Trennung zwischen GUI-Code und Applikationslogik. Dies kann groe Programme
unbersichtlich und schwer wartbar machen.
Fr jeden Ereignistyp mu eine passende Listener-Klasse registriert werden. Da viele der
EventListener-Interfaces mehr als eine Methode definieren, werden dadurch schnell viele leere
Methodenrmpfe in der Fensterklasse zu finden sein. In diesem Beispiel sind es schon
keyReleased und keyTyped, bei zustzlichen Interfaces wrden schnell weitere hinzukommen.
Es bleibt festzuhalten, da diese Technik bestenfalls fr kleine Programme geeignet ist, die nur begrenzt
erweitert werden mssen. Durch die Vielzahl leerer Methodenrmpfe knnen aber auch kleine Programme
schnell unbersichtlich werden.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
/* Listing2803.java */
Listing2803.java
import java.awt.*;
import java.awt.event.*;
public class Listing2803
extends Frame
{
public static void main(String[] args)
{
Listing2803 wnd = new Listing2803();
}
public Listing2803()
{
super("Nachrichtentransfer");
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
addKeyListener(new MyKeyListener());
}
public void paint(Graphics g)
{
g.setFont(new Font("Serif",Font.PLAIN,18));
g.drawString("Zum Beenden bitte ESC drcken...",10,50);
}
class MyKeyListener
extends KeyAdapter
{
public void keyPressed(KeyEvent event)
{
if (event.getKeyCode() == KeyEvent.VK_ESCAPE) {
setVisible(false);
dispose();
System.exit(0);
}
}
}
}
Klasse, die aus KeyAdapter abgeleitet wurde, als Ereignisempfnger. Zum Instanzierungszeitpunkt
erfolgt die Definition der berlagernden Methode keyPressed, in der der Code zur Reaktion auf das
Drcken der Taste [ESC] untergebracht wird.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
/* Listing2804.java */
Listing2804.java
import java.awt.*;
import java.awt.event.*;
public class Listing2804
extends Frame
{
public static void main(String[] args)
{
Listing2804 wnd = new Listing2804();
}
public Listing2804()
{
super("Nachrichtentransfer");
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent event)
{
if (event.getKeyCode() == KeyEvent.VK_ESCAPE) {
setVisible(false);
dispose();
System.exit(0);
}
}
}
);
}
public void paint(Graphics g)
{
g.setFont(new Font("Serif",Font.PLAIN,18));
g.drawString("Zum Beenden bitte ESC drcken...",10,50);
}
}
Hinweis
Das nachfolgende Beispiel zeigt diese Vorgehensweise, indem es unser Beispielprogramm in die drei
Klassen Listing2805, MainFrameCommand und MainFrameGUI aufteilt. Listing2805 enthlt
nur noch die main-Methode und dient lediglich dazu, die anderen beiden Klassen zu instanzieren.
MainFrameGUI realisiert die GUI-Funktionalitt und stellt das Fenster auf dem Bildschirm dar.
MainFrameCommand spielt die Rolle des Kommandointerpreters, der immer dann aufgerufen wird, wenn
im Fenster ein Tastaturereignis aufgetreten ist.
Die Verbindung zwischen beiden Klassen erfolgt durch Aufruf der Methode addKeyListener in
MainFrameGUI, an die das an den Konstruktor bergebene MainFrameCommand-Objekt weitergereicht
wird. Dazu ist es erforderlich, da das Hauptprogramm den Ereignisempfnger cmd zuerst instanziert, um
ihn bei der Instanzierung des GUI-Objekts gui bergeben zu knnen.
Umgekehrt bentigt natrlich auch das Kommando-Objekt Kenntnis ber das GUI-Objekt, denn es
Tip
soll ja das zugeordnete Fenster schlieen und das Programm beenden. Der scheinbare
Instanzierungskonflikt durch diese zirkulre Beziehung ist aber in Wirklichkeit gar keiner, denn bei
jedem Aufruf einer der Methoden von MainFrameCommand wird an das KeyEvent-Objekt der
Auslser der Nachricht bergeben, und das ist in diesem Fall stets das MainFrameGUI-Objekt gui.
So kann innerhalb des Kommando-Objekts auf alle ffentlichen Methoden des GUI-Objekts
zugegriffen werden.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
/* Listing2805.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2805
{
public static void main(String[] args)
{
MainFrameCommand cmd = new MainFrameCommand();
MainFrameGUI
gui = new MainFrameGUI(cmd);
}
}
class MainFrameGUI
extends Frame
{
Listing2805.java
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
spezialisierter Kommandoklassen). Empfehlenswert ist in diesem Zusammenhang die Lektre der JDKDokumentation, die ein hnliches Beispiel in leicht vernderter Form enthlt.
java.awt.Component
Warnung
Wenn ein passender Ereignisempfnger ber die zugehrige addEventListenerMethode registriert wurde.
Wenn der Ereignistyp explizit durch Aufruf der Methode enableEvents aktiviert
wurde.
Die Methode enableEvents erwartet als Argument eine Maske, die durch eine bitweise OderVerknpfung der passenden Maskenkonstanten aus der Klasse AWTEvent zusammengesetzt werden kann:
protected final void enableEvents(long eventsToEnable)
java.awt.Component
Die verfgbaren Masken sind analog zu den Ereignistypen benannt und heien ACTION_EVENT_MASK,
ADJUSTMENT_EVENT_MASK, COMPONENT_EVENT_MASK usw.
Das folgende Beispiel berlagert die Methode processKeyEvent in der Klasse Frame (die sie aus
Component geerbt hat). Durch Aufruf von enableEvents wird die Weiterleitung der Tastaturereignisse
aktiviert, und das Programm zeigt dasselbe Verhalten wie die vorigen Programme.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
/* Listing2806.java */
Listing2806.java
import java.awt.*;
import java.awt.event.*;
public class Listing2806
extends Frame
{
public static void main(String[] args)
{
Listing2806 wnd = new Listing2806();
}
public Listing2806()
{
super("Nachrichtentransfer");
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
enableEvents(AWTEvent.KEY_EVENT_MASK);
}
public void paint(Graphics g)
{
g.setFont(new Font("Serif",Font.PLAIN,18));
g.drawString("Zum Beenden bitte ESC drcken...",10,50);
}
public void processKeyEvent(KeyEvent event)
{
if (event.getID() == KeyEvent.KEY_PRESSED) {
if (event.getKeyCode() == KeyEvent.VK_ESCAPE) {
setVisible(false);
dispose();
System.exit(0);
}
}
super.processKeyEvent(event);
}
}
Das hier vorgestellte Verfahren umgeht das Delegation Event Model vollstndig und hat damit
die gleichen inhrenten Nachteile wie das Event-Handling des alten JDK. Die Dokumentation
zum JDK empfiehlt daher ausdrcklich, fr alle normalen Anwendungsflle das Delegation
Event Model zu verwenden und die Anwendungen nach einem der in den ersten drei Beispielen
genannten Entwurfsmuster zu implementieren.
Hinweis
28.2.5 Ausblick
Die hier vorgestellten Entwurfsmuster geben einen berblick ber die wichtigsten Designtechniken fr das
Event-Handling in Java-Programmen. Whrend die ersten beiden Beispiele fr kleine bis mittelgroe
Programme gut geeignet sind, kommen die Vorteile der in Variante 3 vorgestellten Trennung zwischen GUICode und Anwendungslogik vor allem bei greren Programmen zum Tragen. Die vierte Variante ist
vornehmlich fr Spezialflle geeignet und sollte entsprechend umsichtig eingesetzt werden.
Wir werden in den nachfolgenden Kapiteln vorwiegend die ersten beiden Varianten einsetzen.
Hinweis
Wenn es darum geht, Ereignishandler fr die Beispielprogramme zu implementieren, werden wir
also entweder die erforderlichen Listener-Interfaces in der Fensterklasse selbst implementieren
oder sie in lokalen oder anonymen Klassen unterbringen. Da das Event-Handling des JDK 1.1
eine Vielzahl von Designvarianten erlaubt, werden wir uns nicht immer sklavisch an die
vorgestellten Entwurfsmuster halten, sondern teilweise leicht davon abweichen oder
Mischformen verwenden. Dies ist beabsichtigt und soll den mglichen Formenreichtum
demonstrieren. Wo ntig, werden wir auf spezielle Implementierungsdetails gesondert eingehen.
Kapitel 29 widmet sich den wichtigsten Low-Level-Events und demonstriert den genauen Einsatz ihrer
Listener- und Event-Methoden anhand vieler Beispiele. In spteren Kapiteln werden die meisten der HighLevel-Events erlutert. Sie werden in der Regel dort eingefhrt, wo ihr Einsatz durch das korrespondierende
Dialogelement motiviert wird. So erlutert Kapitel 30 in Zusammenhang mit der Vorstellung von Mens die
Action-Ereignisse, und in Kapitel 32 werden Ereignisse erlutert, die von den dort vorgestellten
Dialogelementen ausgelst werden.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
29.2 Component-Events
29.2 Component-Events
Ein Component-Event wird generiert, wenn eine Komponente verschoben oder ihre Gre verndert wurde
oder wenn sich der Anzeigezustand einer Komponente verndert hat. Da sowohl Fenster als auch alle
Dialogelemente aus der Klasse Component abgeleitet sind, haben die hier erwhnten Ereignisse fr nahezu
alle GUI-Elemente des AWT Gltigkeit.
Ein Empfnger fr Component-Events mu das Interface ComponentListener implementieren und
bekommt Events des Typs ComponentEvent bergeben. ComponentEvent erweitert die Klasse
AWTEvent und stellt neben getID und getSource die Methode getComponent zur Verfgung, mit der
die Komponente ermittelt werden kann, die die Nachricht ausgelst hat.
public Component getComponent()
java.awt.event.ComponentEvent
Die Registrierung der Empfngerklasse erfolgt mit der Methode addComponentListener, die in allen aus
Component abgeleiteten Klassen zur Verfgung steht:
public void addComponentListener(ComponentListener l)
java.awt.Component
Tabelle 29.2 gibt eine bersicht der Methoden von ComponentListener und erklrt ihre Bedeutung:
Ereignismethode
Bedeutung
componentShown
componentHidden
componentMoved
componentResized
/* Listing2902.java */
import java.awt.*;
import java.awt.event.*;
class ComponentRepaintAdapter
extends ComponentAdapter
{
public void componentMoved(ComponentEvent event)
{
event.getComponent().repaint();
}
public void componentResized(ComponentEvent event)
{
event.getComponent().repaint();
}
}
class BirdsEyeFrame
extends Frame
{
public BirdsEyeFrame()
{
super("BirdsEyeFrame");
addWindowListener(new WindowClosingAdapter(true));
addComponentListener(new ComponentRepaintAdapter());
setBackground(Color.lightGray);
}
public void paint(Graphics g)
{
Dimension screensize = getToolkit().getScreenSize();
Dimension framesize = getSize();
double qx = framesize.width / (double)screensize.width;
double qy = framesize.height / (double)screensize.height;
g.setColor(Color.white);
g.fillRect(
(int)(qx * getLocation().x),
(int)(qy * getLocation().y),
(int)(qx * framesize.width),
(int)(qy * framesize.height)
);
g.setColor(Color.darkGray);
g.fillRect(
(int)(qx * getLocation().x),
(int)(qy * getLocation().y),
(int)(qx * framesize.width),
(int)(qy * getInsets().top)
Listing2902.java
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
);
g.drawRect(
(int)(qx *
(int)(qy *
(int)(qx *
(int)(qy *
);
getLocation().x),
getLocation().y),
framesize.width),
framesize.height)
}
}
public class Listing2902
{
public static void main(String[] args)
{
BirdsEyeFrame wnd = new BirdsEyeFrame();
wnd.setSize(300,200);
wnd.setLocation(200,100);
wnd.setVisible(true);
}
}
Abbildung 29.1: Das Fenster sieht sich selbst aus der Vogelperspektive
In vielen Beispielen in diesem Buch wird der Einfachheit halber die in Abschnitt 23.2.4 vorgestellte Hinweis
Klasse WindowClosingAdapter verwendet, um einen Listener zum Schlieen des Fensters zu
registrieren. Damit ein solches Beispiel sich kompilieren lt, mu die Datei
WindowClosingAdapter.java im aktuellen Verzeichnis vorhanden sein. Sie befindet sich auf der CDROM zum Buch oder in Listing 23.2.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
29.3 Mouse-Events
29.3 Mouse-Events
Ein Mouse-Event entsteht, wenn der Anwender innerhalb der Client-Area des Fensters eine der
Maustasten drckt oder loslt. Dabei reagiert das Programm sowohl auf Klicks der linken als auch falls vorhanden - der rechten Maustaste und zeigt an, welche der Umschalttasten [STRG], [ALT],
[UMSCHALT] oder [META] whrend des Mausklicks gedrckt waren. Des weiteren ist es mglich,
zwischen einfachen und doppelten Mausklicks zu unterscheiden.
Ein Empfnger fr Mouse-Events mu das Interface MouseListener implementieren und
bekommt Events des Typs MouseEvent bergeben. MouseEvent erweitert die Klasse
InputEvent und stellt neben getID und getSource eine Reihe zustzlicher Methoden zur
Verfgung, die wichtige Informationen liefern. Die Registrierung der Empfngerklasse erfolgt mit der
Methode addMouseListener, die in allen Klassen zur Verfgung steht, die aus Component
abgeleitet wurden:
public void addMouseListener(MouseListener l)
java.awt.Component
Tabelle 29.3 gibt eine bersicht der Methoden von MouseListener und erklrt ihre Bedeutung:
Ereignismethode
Bedeutung
mousePressed
mouseReleased
mouseClicked
mouseEntered
mouseExited
Damit ein Programm auf Mausklicks angemessen reagieren kann, bentigt es zustzliche
Informationen, die es sich mit den Methoden der Klasse MouseEvent bzw. ihrer
Vaterklasse InputEvent beschaffen kann. Zunchst kann mit getX, getY und
getPosition die Position des Mauszeigers zum Zeitpunkt des Ereignisses ermittelt
werden:
public int getX()
public int getY()
Hinweis
java.awt.event.MouseEvent
getX liefert die x- und getY die y-Koordinate des Punktes, an dem der Mauszeiger sich beim
Auftreten des Ereignisses befindet. getPoint liefert dieselbe Information zusammengefat als
Point-Objekt.
Die Koordinatenwerte werden relativ zum Ursprung der auslsenden Komponente angegeben.
Bei einem Fenster des Typs Frame bedeutet dies, da bei einem Klick in der oberen linken
Ecke nicht (0,0) zurckgegeben wird, sondern (getInsets().left,
getInsets().top). Dies stimmt mit dem Ursprung des Koordinatensystems berein, das
auch beim Aufruf der Grafikroutinen zugrunde gelegt wird.
Tip
Des weiteren gibt es in MouseEvent die Methode isPopupTrigger, mit der abgefragt werden
kann, ob das Klickereignis den Aufruf eines Popup-Mens anzeigen soll. Wir werden darauf in
Kapitel 30 zurckkommen.
Die Methode getClickCount liefert die Anzahl der Mausklicks, die dem aktuellen Ereignis
zugeordnet ist:
public int getClickCount()
java.awt.event.MouseEvent
Normalerweise hat dieser Zhler den Wert 1, bei Mehrfachklicks gibt es aber auch MouseEvents
mit dem Wert 2 oder (je nach Schnelligkeit der Klicks) noch hheren Werten. Die Abfrage von
getClickCount kann dazu verwendet werden, auf Doppelklicks zu reagieren. Hierzu ist lediglich
beim Aufruf von mousePressed oder mouseClicked zu berprfen, ob getClickCount den
Wert 2 liefert. In diesem Fall handelt es sich um einen Doppelklick. Zu beachten ist, da bei einem
Doppelklick zwei aufeinanderfolgende mousePressed-mouseReleased-mouseClickedSequenzen gesendet werden. In der ersten hat der Zhler den Wert 1, um den ersten (einfachen)
Mausklick zu signalisieren, und erst in der zweiten steht er auf 2. Vor einem Doppelklick wird also
immer erst der zugehrige Einzelklick bertragen.
Eine alternative Methode, Doppelklicks zu erkennen, besteht darin, die Zeitspanne
Hinweis
zwischen zwei Klicks und den Abstand der beiden Koordinatenpaare voneinander zu
messen und bei hinreichend kleinen Differenzen einen Doppelklick anstelle zweier
Einfachklicks zu melden. Dazu wird mit der Methode getWhen der Klasse InputEvent
der Zeitpunkt (in Millisekunden) und mit getPoint oder getX und getY die
Mausposition zweier aufeinanderfolgender Events bestimmt:
java.awt.event.InputEvent
Diese Vorgehensweise hat den Vorteil, da die zeitliche und positionelle Toleranz fr Doppelklicks
selbst beeinflut werden kann, was bei dem oben beschriebenen Standardverfahren nicht mglich ist.
Neben den bisher besprochenen Methoden stehen die aus InputEvent geerbten Methoden zur
Verfgung. InputEvent ist die gemeinsame Basisklasse von MouseEvent und KeyEvent und
stellt Methoden zur Verfgung, die generelle Informationen ber den Zustand der Umschalttasten
[STRG], [ALT], [UMSCHALT] oder [META] zum Zeitpunkt des Ereignisses liefern:
public
public
public
public
boolean
boolean
boolean
boolean
isShiftDown()
isControlDown()
isMetaDown()
isAltDown()
java.awt.event.InputEvent
/* Listing2903.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2903
extends Frame
{
public static void main(String[] args)
{
Listing2903 wnd = new Listing2903();
wnd.setSize(300,200);
wnd.setLocation(200,100);
wnd.setVisible(true);
}
public Listing2903()
{
super("Mausklicks");
addWindowListener(new WindowClosingAdapter(true));
addMouseListener(new MyMouseListener());
}
class MyMouseListener
Listing2903.java
025
extends MouseAdapter
026
{
027
int cnt = 0;
028
029
public void mousePressed(MouseEvent event)
030
{
031
Graphics g = getGraphics();
032
int x = event.getX();
033
int y = event.getY();
034
if (event.getClickCount() == 1) { //Gesicht
035
++cnt;
036
//Kopf und Augen
037
g.drawOval(x-10,y-10,20,20);
038
g.fillRect(x-6,y-5,4,5);
039
g.fillRect(x+3,y-5,4,5);
040
//Mund
041
if (event.isMetaDown()) { //grimmig
042
g.drawLine(x-5,y+7,x+5,y+7);
043
} else {
//lcheln
044
g.drawArc(x-7,y-7,14,14,225,100);
045
}
046
//Zhler
047
g.drawString(""+cnt,x+10,y-10);
048
} else if (event.getClickCount() == 2) { //Brille
049
g.drawLine(x-9,y-3,x+9,y-3);
050
}
051
}
052
}
053 }
Listing 29.3: Reaktion auf Mausklicks
Beim Drcken der linken Maustaste lchelt das Gesicht, bei der rechten sieht es grimmig aus. Bei
einem Doppelklick bekommt der Smiley zustzlich eine Brille aufgesetzt. Die Ausgabe des
Programms sieht beispielsweise so aus:
Hinweis
Leider hat das Beispielprogramm eine gravierende konzeptionelle Schwche, denn die gezeichneten
Smileys sind nicht dauerhaft. Wird das Fenster in den Hintergrund gestellt, nachdem einige
Mausklicks durchgefhrt wurden, sind bei erneuter Anzeige des Fensters die zuvor gezeichneten
Smileys wieder verschwunden. Der Grund dafr ist, da wir in unserem Beispiel nicht die paintMethode berlagert haben, sondern die Ausgaben als direkte Reaktion auf ein Mausereignis
erledigten. Da Windows nicht dafr sorgt, den Inhalt eines zuvor verdeckten Fensters zu
rekonstruieren, ist die Anwendung selbst dafr verantwortlich, dies in ihrer paint-Methode zu tun.
Eine bessere Implementierung dieses Programms wrde also darin bestehen, die Koordinaten und
Eigenschaften aller gezeichneten Objekte zu speichern und sie beim Aufruf von paint spter selbst
zu rekonstruieren. Wir werden diese Vorgehensweise in einem spteren Beispiel genauer
kennenlernen.
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
29.4 MouseMotion-Events
29.4 MouseMotion-Events
Im JDK 1.1 gibt es eine klare Trennung zwischen Mouse-Events und MouseMotion-Events. Whrend die
Mouse-Events fr Mausklicks und das Betreten oder Verlassen der Komponente zustndig sind, geben
MouseMotion-Events Auskunft ber die Bewegung des Mauszeigers. Neben der verbesserten Modularisierung
(sehr viele Programme wollen lediglich von Mausklicks, nicht aber von Mausbewegungen unterrichtet werden)
wurde die Trennung vor allem deshalb vorgenommen, um Performance-Verbesserungen zu erzielen. Durch die
Entkopplung der Ereignishandler fr Mausbewegungen wird die Anzahl der Events, mit denen die meisten
Event-Handler beschossen werden, im Vergleich zum JDK 1.0 drastisch reduziert.
Ein Empfnger fr MouseMotion-Events mu das Interface MouseMotionListener implementieren. Er
wird mit der Methode addMouseMotionListener registriert, die in allen Objekten der Klasse
Component oder daraus abgeleiteten Klassen zur Verfgung steht.
public void addMouseMotionListener(MouseListener l)
java.awt.Component
Warnung
java.awt.event.MouseMotionListener
mouseMoved wird aufgerufen, wenn die Maus bewegt wird, ohne da dabei eine der Maustasten gedrckt ist.
mouseDragged wird dagegen aufgerufen, wenn die Maus bei gedrckter linker oder rechter Maustaste
bewegt wird.
Das folgende Listing zeigt den Einsatz von mouseDragged am Beispiel eines Programms, mit dem
Rechtecke gezeichnet werden knnen. Das Drcken der linken Maustaste legt den Anfangspunkt des Rechtecks
fest, und durch Ziehen der Maus wird seine Gre bestimmt. Nach dem Loslassen der Maustaste wird das
Rechteck in die Liste der gezeichneten Objekte eingetragen und beim nchsten Aufruf von paint gezeichnet.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
/* Listing2904.java */
Listing2904.java
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class Listing2904
extends Frame
{
private Vector drawlist;
private Rectangle actrect;
public static void main(String[] args)
{
Listing2904 wnd = new Listing2904();
wnd.setLocation(200,200);
wnd.setSize(400,300);
wnd.setVisible(true);
}
public Listing2904()
{
super("Rechtecke zeichnen");
drawlist = new Vector();
actrect = new Rectangle(0,0,0,0);
addWindowListener(new MyWindowListener());
addMouseListener(new MyMouseListener());
addMouseMotionListener(new MyMouseMotionListener());
}
public void paint(Graphics g)
{
Rectangle r;
Enumeration e;
for (e = drawlist.elements(); e.hasMoreElements(); ) {
r = (Rectangle)e.nextElement();
g.drawRect(r.x, r.y, r.width, r.height);
}
if (actrect.x > 0 || actrect.y > 0) {
g.drawRect(
actrect.x,
actrect.y,
actrect.width,
actrect.height
);
}
}
class MyMouseListener
extends MouseAdapter
{
public void mousePressed(MouseEvent event)
{
actrect = new Rectangle(event.getX(),event.getY(),0,0);
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092 }
}
public void mouseReleased(MouseEvent event)
{
if (actrect.width > 0 || actrect.height > 0) {
drawlist.addElement(actrect);
}
repaint();
}
}
class MyMouseMotionListener
extends MouseMotionAdapter
{
public void mouseDragged(MouseEvent event)
{
int x = event.getX();
int y = event.getY();
if (x > actrect.x && y > actrect.y) {
actrect.width = x - actrect.x;
actrect.height = y - actrect.y;
}
repaint();
}
}
class MyWindowListener
extends WindowAdapter
{
public void windowClosing(WindowEvent event)
{
setVisible(false);
dispose();
System.exit(0);
}
}
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
29.5 Focus-Events
29.5 Focus-Events
Der Fokus zeigt an, welches Fenster die Tastatureingaben erhlt. Sind mehrere Fenster gleichzeitig
geffnet, so kann immer nur eines von ihnen den Fokus beanspruchen. Sind auf einem aktiven
Fenster mehrere Dialogelemente aktiv, so kann ebenfalls nur eines davon den Fokus erhalten, denn
jedes Dialogelement wird ebenfalls durch ein (meist unsichtbares) Fenster dargestellt.
Ein Empfnger fr Focus-Events mu das Interface FocusListener implementieren und
bekommt Events des Typs FocusEvent bergeben. FocusEvent erweitert die Klasse
ComponentEvent und stellt neben getID und getSource die Methode isTemporary zur
Verfgung, die anzeigt, ob der Fokuswechsel temporr oder permanent ist:
public boolean isTemporary()
java.awt.event.FocusEvent
Die Registrierung von Focus-Events erfolgt mit der Methode addFocusListener, die auf allen
Objekten des Typs Component oder daraus abgeleiteten Objekten zur Verfgung steht:
public void addFocusListener(FocusListener l)
java.awt.Component
java.awt.event.FocusListener
focusGained wird aufgerufen, wenn die Komponente den Fokus erhlt, und focusLost, wenn
sie ihn wieder abgibt. Eine Komponente erhlt den Fokus beispielsweise, wenn sie mit der Maus
angeklickt oder (unter Windows) mit Hilfe der Tasten [TAB] oder [UMSCHALT]+[TAB] oder
ber einen Beschleuniger angesprungen wurde. Auerdem gibt es die Mglichkeit, den Fokus
programmgesteuert zu verndern. Dazu gibt es die Methode requestFocus der Klasse
Component, mit der eine Komponente den Fokus fr sich selbst beanspruchen bzw. ihn einer
anderen Komponente zuweisen kann:
java.awt.Component
Der explizite Umgang mit Focus-Events ist etwa bei Dialogelementen sinnvoll. Dadurch
kann ein Edit-Control beispielsweise feststellen, da das nchste Dialogelement
angesprungen werden soll und ein eventuell genderter Text zuvor gespeichert werden
mu. Focus-Events sind oft schwierig zu debuggen, denn durch den Wechsel zwischen
Debug-Window und Anwendung werden meist zustzliche Fokuswechsel ausgelst, die
den Fehler verschleiern oder die Fehlerstelle unerreichbar machen. Wird innerhalb von
Fokus-Handlern die Methode requestFocus aufgerufen, kann es zudem leicht zu
Endlosschleifen kommen.
Hinweis
/* Listing2905.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2905
extends Frame
implements FocusListener
{
boolean havefocus = false;
public static void main(String[] args)
{
Listing2905 wnd = new Listing2905();
}
public Listing2905()
{
super("Focus-Listener");
addFocusListener(this);
addWindowListener(new WindowClosingAdapter(true));
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
}
public void paint(Graphics g)
{
if (havefocus) {
Listing2905.java
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052 }
g.setColor(Color.black);
g.drawString("Fokus erhalten",10,50);
} else {
g.setColor(Color.darkGray);
g.drawString("Kein Fokus",10,50);
}
}
public void focusGained(FocusEvent event)
{
havefocus = true;
setBackground(Color.yellow);
repaint();
}
public void focusLost(FocusEvent event)
{
havefocus = false;
setBackground(Color.lightGray);
repaint();
}
Titel
<<
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
29.6 Key-Events
29.6 Key-Events
Unter Windows werden alle Tastatureingaben an die fokussierte Komponente gesendet. Ein Empfnger fr KeyEvents mu das Interface KeyListener implementieren und bekommt Events des Typs KeyEvent
bergeben. KeyEvent erweitert die Klasse InputEvent, die ihrerseits aus ComponentEvent abgeleitet ist,
und stellt neben getID und getSource eine ganze Reihe von Methoden zur Verfgung, mit denen die
Erkennung und Bearbeitung der Tastencodes vereinfacht wird.
Die Registrierung von Key-Events erfolgt mit der Methode addKeyListener, die auf allen Objekten des
Typs Component oder daraus abgeleiteten Klassen zur Verfgung steht:
public void addKeyListener(KeyListener l)
java.awt.Component
java.awt.event.KeyListener
Um die Funktionsweise dieser Methoden im Zusammenspiel mit den Methoden der Klasse
KeyEvent besser verstehen zu knnen, wollen wir zwischen Zeichentasten und Funktionstasten
unterscheiden. Zeichentasten sind dabei solche Tasten, mit denen Buchstaben, Ziffern oder sonstige
gltige Unicode-Zeichen eingegeben werden, wie z.B. [a], [A], [B], [1], [2], [%], [+], aber
auch [ESC], [LEER] oder [TAB]. Zu den Funktionstasten gehren beispielsweise [F1], [F2],
[POS1] oder [CURSORLINKS], aber auch die Umschalttasten [STRG], [ALT] und
[UMSCHALT].
Hinweis
Die Methode keyTyped wird immer dann aufgerufen, wenn eine Zeichentaste gedrckt wurde. Beim Drcken
einer Funktionstaste wird sie dagegen nicht aufgerufen. Im Gegensatz dazu wird keyPressed bei jedem
Tastendruck aufgerufen, unabhngig davon, ob es sich um eine Zeichentaste oder eine Funktionstaste handelt.
Mit keyPressed knnen sogar in beschrnktem Umfang die Feststelltasten wie [NUMLOCK] oder
[CAPSLOCK] erkannt werden. Beide Methoden erhalten auch Tastatur-Repeats, werden also bei lngerem
Festhalten einer Taste wiederholt aufgerufen. Die Methode keyReleased wird aufgerufen, wenn eine
gedrckte Taste losgelassen wurde, unabhngig davon, ob es sich um eine Zeichen- oder Funktionstaste handelt.
Um beim Auftreten eines Tastatur-Events zu erkennen, welche Taste gedrckt wurde, stellt die Klasse
KeyEvent die Methoden getKeyCode und getKeyChar und zustzlich die aus InputEvent geerbten
Methoden isShiftDown, isControlDown, isMetaDown und isAltDown zur Verfgung:
java.awt.event.KeyEvent
boolean
boolean
boolean
boolean
isShiftDown()
isControlDown()
isMetaDown()
isAltDown()
getKeyChar liefert das Zeichen, das der gedrckten Zeichentaste entspricht, also ein 'a', wenn die Taste [A]
gedrckt wurde, und ein 'A', wenn die Tastenkombination [UMSCHALT]+[A] gedrckt wurde. getKeyCode
liefert dagegen virtuelle Tastencodes, die in KeyEvent als symbolische Konstanten definiert wurden. Hier wird
beim Drcken der Taste [A] immer der Code VK_A geliefert, unabhngig davon, ob [UMSCHALT] gedrckt
wurde oder nicht. Tabelle 29.4 gibt eine bersicht der wichtigsten virtuellen Keycodes der Klasse KeyEvent.
Symbolischer Name
Bedeutung
VK_ENTER
[ENTER]
VK_SPACE
[LEER]
VK_TAB
[TAB]
VK_ESCAPE
[ESC]
VK_BACK_SPACE
[RCK]
VK_HOME, VK_END
[HOME], [END]
VK_INSERT, VK_DELETE
[EINFG], [ENTF]
VK_PAGE_UP, VK_PAGE_DOWN
[BILDHOCH], [BILDRUNTER]
VK_DOWN, VK_UP
[CURSORHOCH], [CURSORRUNTER]
VK_LEFT, VK_RIGHT
[CURSORLINKS], [CURSORRECHTS]
Insgesamt ist das Handling von Tastatur-Events nicht ganz trivial und erfordert ein wenig Aufwand bei der
Unterscheidung von Zeichen-, Funktions-, Umschalt- oder Feststelltasten. Tabelle 29.5 fat die bisherigen
Ausfhrungen noch einmal zusammen. Die erste Zeile zeigt das Verhalten beim Aufruf der Listener-Methode
keyTyped an, die zweite beim Aufruf von keyPressed. Die erste Spalte liefert dazu den Rckgabewert von
getKeyCode, die zweite den von getKeyChar. Jedes Element beschreibt in der oberen Hlfte den
Rckgabewert beim Drcken einer Zeichentaste und in der unteren den beim Drcken einer Funktionstaste.
keyTyped
getKeyCode
getKeyChar
Zeichentaste: VK_UNDEFINED
Funktionstaste: --
/* Listing2906.java */
import java.awt.*;
import java.awt.event.*;
public class Listing2906
extends Frame
implements KeyListener
{
String msg1 = "";
String msg2 = "";
public static void main(String[] args)
{
Listing2906 wnd = new Listing2906();
}
public Listing2906()
{
super("Tastaturereignisse");
addKeyListener(this);
addWindowListener(new WindowClosingAdapter(true));
setBackground(Color.lightGray);
setSize(300,200);
setLocation(200,100);
setVisible(true);
}
public void paint(Graphics g)
Listing2906.java
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
{
if (msg1.length() > 0) {
draw3DRect(g,20,50,250,30);
g.setColor(Color.black);
g.drawString(msg1,30,70);
}
if (msg2.length() > 0) {
draw3DRect(g,20,100,250,30);
g.setColor(Color.black);
g.drawString(msg2,30,120);
}
}
void draw3DRect(Graphics g,int x,int y,int width,int height)
{
g.setColor(Color.darkGray);
g.drawLine(x,y,x,y+height);
g.drawLine(x,y,x+width,y);
g.setColor(Color.white);
g.drawLine(x+width,y+height,x,y+height);
g.drawLine(x+width,y+height,x+width,y);
}
public void keyPressed(KeyEvent event)
{
msg1 = "";
System.out.println(
"key pressed: " +
"key char = " + event.getKeyChar() + " " +
"key code = " + event.getKeyCode()
);
if (event.getKeyChar() == KeyEvent.CHAR_UNDEFINED) {
int key = event.getKeyCode();
//Funktionstaste abfragen
if (key == KeyEvent.VK_F1) {
msg1 = "F1";
} else if (key == KeyEvent.VK_F2) {
msg1 = "F2";
} else if (key == KeyEvent.VK_F3) {
msg1 = "F3";
}
//Modifier abfragen
if (msg1.length() > 0) {
if (event.isAltDown()) {
msg1 = "ALT + " + msg1;
}
if (event.isControlDown()) {
msg1 = "STRG + " + msg1;
}
if (event.isShiftDown()) {
msg1 = "UMSCHALT + " + msg1;
}
}
}
repaint();
}
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109 }
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
30.4 Meneintrge
30.4 Meneintrge
30.4.1 Einfache Meneintrge
30.4.2 CheckboxMenuItem
30.4.3 Beschleunigertasten
30.4.4 Untermens
java.awt.MenuItem
Auch nach der Konstruktion eines Meneintrags ist ein Zugriff auf seinen Namen mglich. Mit der
Methode getLabel kann der Name des Meneintrags abgefragt und mit setLabel sogar
verndert werden:
public String getLabel()
java.awt.MenuItem
Neben einem Namen besitzt ein Meneintrag eine interne Zustandsvariable, die anzeigt, ob er aktiv
ist oder nicht. Nur ein aktiver Eintrag kann vom Anwender ausgewhlt werden und so eine Nachricht
auslsen. Ein inaktiver Eintrag dagegen wird im Men grau dargestellt, kann vom Anwender nicht
mehr ausgewhlt werden und daher auch keine Nachricht mehr auslsen.
Nach dem Aufruf des Konstruktors ist ein Meneintrag zunchst aktiviert. Er kann durch Aufruf von
setEnabled(false) deaktiviert und mit setEnabled(true) aktiviert werden. Durch
Aufruf von isEnabled kann der aktuelle Zustand abgefragt werden:
java.awt.MenuItem
30.4.2 CheckboxMenuItem
Neben der Klasse MenuItem gibt es mit der Klasse CheckboxMenuItem eine zweite Klasse zum
Erzeugen von Meneintrgen. CheckboxMenuItem ist aus MenuItem abgeleitet und bietet als
zustzliches Feature eine interne Zustandsvariable, die zwischen true und false umgeschaltet
werden kann. Die visuelle Darstellung der Zustandsvariablen erfolgt durch Anfgen oder Entfernen
eines Hkchens neben dem Meneintrag. Der Nutzen der Klasse CheckboxMenuItem besteht
darin, da eine logische Programmvariable durch Auswhlen des Menpunkts abwechselnd an- und
ausgeschaltet werden kann.
Die Instanzierung eines CheckboxMenuItem erfolgt wie bei einem MenuItem. Zustzlich
stehen die beiden Methoden setState und getState zum Setzen und Abfragen des Zustands
zur Verfgung:
public void setState(boolean state)
java.awt.CheckboxMenuItem
Das folgende Programm stellt alle bisher erwhnten Eigenschaften in einem Beispiel dar. Es leitet
dazu die Klasse MainMenu1 aus MenuBar ab und erzeugt im Konstruktor die Mens und
Meneintrge. Gegenber der einfachen Instanzierung von MenuBar bietet die Ableitung den
Vorteil, da die neue Klasse Methoden zur Verfgung stellen kann, die zum Zugriff auf Mens oder
Meneintrge verwendet werden knnen.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
/* Listing3001.java */
import java.awt.*;
import java.awt.event.*;
class MainMenu1
extends MenuBar
{
private MenuItem miRueck;
private CheckboxMenuItem miFarbe;
public MainMenu1()
{
Menu m;
//Datei
m = new Menu("Datei");
m.add(new MenuItem("Neu"));
Listing3001.java
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
m.add(new MenuItem("Laden"));
m.add(new MenuItem("Speichern"));
m.addSeparator();
m.add(new MenuItem("Beenden"));
add(m);
//Bearbeiten
m = new Menu("Bearbeiten");
m.add((miRueck = new MenuItem("Rueckgaengig")));
m.addSeparator();
m.add(new MenuItem("Ausschneiden"));
m.add(new MenuItem("Kopieren"));
m.add(new MenuItem("Einfuegen"));
m.add(new MenuItem("Loeschen"));
add(m);
//Optionen
m = new Menu("Optionen");
m.add(new MenuItem("Einstellungen"));
m.add((miFarbe = new CheckboxMenuItem("Farbe")));
add(m);
//Rueckgaengig deaktivieren
enableRueckgaengig(false);
//Farbe anschalten
setFarbe(true);
}
public void enableRueckgaengig(boolean ena)
{
if (ena) {
miRueck.setEnabled(true);
} else {
miRueck.setEnabled(false);
}
}
public void setFarbe(boolean on)
{
miFarbe.setState(on);
}
}
public class Listing3001
extends Frame
{
public static void main(String[] args)
{
Listing3001 wnd = new Listing3001();
}
public Listing3001()
{
069
070
071
072
073
074
075
}
076 }
super("Mens");
setLocation(100,100);
setSize(400,300);
setMenuBar(new MainMenu1());
setVisible(true);
addWindowListener(new WindowClosingAdapter(true));
30.4.3 Beschleunigertasten
In den meisten Programmen lassen sich Mens nicht nur mit der Maus bedienen,
Warnung
sondern ber Beschleunigertasten auch mit der Tastatur. Im JDK 1.0 konnten
Beschleunigertasten unter Windows 95 ganz einfach dadurch eingefgt werden, da an
beliebiger Stelle im Mentext das Zeichen & eingefgt und so die nachfolgende Taste
als Beschleuniger definiert wurde. Dies war natrlich nicht portabel, funktionierte nur
unter Windows und wurde folglich als Bug angesehen und eliminiert.
Das JDK 1.1 implementiert nun ein eigenes Beschleunigerkonzept, das ber Plattformgrenzen
hinweg funktioniert. Dazu wurde die Klasse MenuShortcut eingefhrt, mit deren Hilfe
Beschleunigertasten definiert und an einzelne Meneintrge angehngt werden knnen. Eine
Beschleunigertaste ist dabei immer ein einzelnes Zeichen der Tastatur, das zusammen mit der
java.awt.MenuShortcut
Der erste Konstruktor erwartet den virtuellen Tastencode der gewnschten Beschleunigertaste (siehe
Kapitel 29). Fr einfache alphanumerische Zeichen kann hier auch das Zeichen selbst bergeben
werden. Die bergabe einer Funktionstaste ist leider nicht ohne weiteres mglich, denn deren
virtuelle Tastencodes berschneiden sich mit den ASCII-Codes der Kleinbuchstaben.
Funktionstasten knnen daher nur dann als Beschleuniger verwendet werden, wenn ihre virtuellen
Tastencodes die Umwandlung in Grobuchstaben unverndert berstehen (z.B. VK_DELETE). Der
zweite Konstruktor erlaubt zustzlich die bergabe eines booleschen Parameters
useShiftModifier, der dafr sorgt, da der Beschleuniger nur dann greift, wenn neben der
systemspezifischen Umschalttaste fr Beschleuniger zustzlich die Taste [UMSCHALT] gedrckt
wird.
Um einen Beschleuniger an einen Menpunkt zu binden, ist das MenuShortcut-Objekt als
zweites Argument an den Konstruktor von MenuItem zu bergeben:
public MenuItem(String label, MenuShortcut s)
java.awt.MenuItem
java.awt.MenuItem
Durch Aufruf von deleteShortCut kann der einem Meneintrag zugeordnete Beschleuniger
gelscht werden:
public void deleteShortcut()
java.awt.MenuItem
Aufgrund eines Bugs im AWT (der auch im JDK 1.2 noch enthalten war) mu nach der Definition
eines Beschleunigers zustzlich die Methode setActionCommand aufgerufen werden, um den
String, der beim Auslsen des Beschleunigers an den ActionListener gesendet werden soll,
festzulegen:
public void setActionCommand(String command)
java.awt.MenuItem
Ohne diesen Aufruf wrde ein null-Objekt gesendet werden. Eine beispielhafte Aufrufsequenz zur
Erzeugung eines Meneintrags mit Beschleuniger sieht damit so aus:
001
002
003
004
005
006
007
008
009
010
011
012
Menu m;
MenuItem mi;
MenuShortcut ms;
//Datei
m = new Menu("Datei");
ms = new MenuShortcut(KeyEvent.VK_N);
mi = new MenuItem("Neu",ms);
mi.setActionCommand("Neu");
mi.addActionListener(listener);
m.add(mi);
/* MainMenu2.inc */
class MainMenu2
extends MenuBar
{
public MainMenu2()
{
Menu m;
MenuItem mi;
MenuShortcut ms;
//Datei
m = new Menu("Datei");
ms = new MenuShortcut(KeyEvent.VK_N);
mi = new MenuItem("Neu",ms);
mi.setActionCommand("Neu");
m.add(mi);
ms = new MenuShortcut(KeyEvent.VK_L);
mi = new MenuItem("Laden",ms);
mi.setActionCommand("Laden");
m.add(mi);
ms = new MenuShortcut(KeyEvent.VK_S);
mi = new MenuItem("Speichern",ms);
MainMenu2.inc
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
}
055 }
mi.setActionCommand("Speichern");
m.add(mi);
ms = new MenuShortcut(KeyEvent.VK_E);
mi = new MenuItem("Beenden",ms);
mi.setActionCommand("Beenden");
m.add(mi);
add(m);
//Bearbeiten
m = new Menu("Bearbeiten");
ms = new MenuShortcut(KeyEvent.VK_X);
mi = new MenuItem("Ausschneiden",ms);
mi.setActionCommand("Ausschneiden");
m.add(mi);
ms = new MenuShortcut(KeyEvent.VK_C);
mi = new MenuItem("Kopieren",ms);
mi.setActionCommand("Kopieren");
m.add(mi);
ms = new MenuShortcut(KeyEvent.VK_V);
mi = new MenuItem("Einfgen",ms);
mi.setActionCommand("Einfgen");
m.add(mi);
add(m);
30.4.4 Untermens
Mens lassen sich auf einfache Art und Weise schachteln. Dazu ist beim Aufruf der add-Methode
anstelle einer Instanz der Klasse MenuItem ein Objekt der Klasse Menu zu bergeben, das das
gewnschte Untermen reprsentiert. Das folgende Beispiel erweitert das Men Optionen der
Klasse MainMenu1 um den Meneintrag Schriftart, der auf ein Untermen mit den verfgbaren
Schriftarten verzweigt (der Code zur Erzeugung des Untermens steht in den Zeilen 034 bis 041):
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
/* MainMenu3.inc */
class MainMenu3
extends MenuBar
{
private MenuItem miRueck;
private CheckboxMenuItem miFarbe;
public MainMenu3()
{
Menu m;
//Datei
m = new Menu("Datei");
m.add(new MenuItem("Neu"));
m.add(new MenuItem("Laden"));
m.add(new MenuItem("Speichern"));
m.addSeparator();
m.add(new MenuItem("Beenden"));
add(m);
//Bearbeiten
m = new Menu("Bearbeiten");
m.add((miRueck = new MenuItem("Rueckgaengig")));
m.addSeparator();
m.add(new MenuItem("Ausschneiden"));
m.add(new MenuItem("Kopieren"));
m.add(new MenuItem("Einfuegen"));
m.add(new MenuItem("Loeschen"));
add(m);
//Optionen
m = new Menu("Optionen");
m.add(new MenuItem("Einstellungen"));
//Untermen Schriftart
Menu m1 = new Menu("Schriftart");
m1.add(new MenuItem("Arial"));
m1.add(new MenuItem("TimesRoman"));
m1.add(new MenuItem("Courier"));
m1.add(new MenuItem("System"));
m.add(m1);
MainMenu3.inc
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064 }
Titel
<<
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
30.5 Action-Events
30.5 Action-Events
Ein Action-Event wird generiert, wenn der Anwender einen Menpunkt selektiert und ausgewhlt hat. Das
Programm kann den auslsenden Meneintrag bestimmen und so geeignet darauf reagieren. Action-Events werden
von der Klasse MenuItem und drei weiteren Klassen (auf die wir in den folgenden Kapiteln zurckkommen)
gesendet:
Ein Empfnger fr Action-Events mu das Interface ActionListener implementieren und bekommt Events des
Typs ActionEvent bergeben. ActionEvent erweitert die Klasse AWTEvent und stellt neben getID und
getSource vor allem die Methode getActionCommand zur Verfgung, mit der die verschiedenen
Ereignisquellen unterschieden werden knnen:
public String getActionCommand()
java.awt.event.ActionEvent
Wird das Action-Event durch ein MenuItem ausgelst, liefert dessen Methode getActionCommand
die Bezeichnung des Menpunktes, wie sie an den Konstruktor bergeben wurde. Durch einen expliziten
Aufruf von setActionCommand kann dieser String auch unabhngig von der Beschriftung des
Menpunkts gendert werden. Ein Aufruf von getActionCommand liefert den aktuellen Inhalt des
Menpunkts bzw. seine Beschriftung, falls setActionCommand noch nicht aufgerufen wurde:
public void setActionCommand(String command)
Hinweis
java.awt.MenuItem
Die Registrierung der Empfngerklasse erfolgt mit der Methode addActionListener, die in den Klassen
MenuItem, Button, List und TextField zur Verfgung steht:
public void addActionListener(ActionListener l)
java.awt.Button
Das Interface ActionListener stellt lediglich die Methode actionPerformed zur Verfgung, die beim
Aufruf ein ActionEvent bergeben bekommt:
public abstract void actionPerformed(ActionEvent e)
java.awt.event.ActionListener
Tip
Das folgende Programm zeigt die Reaktion auf Action-Events. Das Programm ffnet ein Fenster, das mit Hilfe von
Meneintrgen auf dem Bildschirm verschoben oder in der Gre verndert werden kann:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
/* Listing3005.java */
import java.awt.*;
import java.awt.event.*;
class MainMenu4
extends MenuBar
{
private MenuItem miRueck;
private CheckboxMenuItem miFarbe;
private static void
addNewMenuItem(Menu menu, String name, ActionListener listener)
{
int pos = name.indexOf('&');
MenuShortcut shortcut = null;
MenuItem mi;
if (pos != -1) {
if (pos < name.length() - 1) {
char c = name.charAt(pos + 1);
shortcut=new MenuShortcut(Character.toLowerCase(c));
name=name.substring(0,pos)+name.substring(pos + 1);
}
}
if (shortcut != null) {
mi = new MenuItem(name, shortcut);
} else {
mi = new MenuItem(name);
}
mi.setActionCommand(name);
mi.addActionListener(listener);
menu.add(mi);
}
public MainMenu4(ActionListener listener)
{
Menu m;
//Men "Gre"
m = new Menu("Gre");
addNewMenuItem(m, "&Grer", listener);
addNewMenuItem(m, "&Kleiner", listener);
m.addSeparator();
addNewMenuItem(m, "B&eenden", listener);
add(m);
//Men "Position"
m = new Menu("Position");
addNewMenuItem(m, "&Links", listener);
addNewMenuItem(m, "&Rechts", listener);
addNewMenuItem(m, "&Oben", listener);
Listing3005.java
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
}
118 }
} else if (cmd.equals("Rechts")) {
setLocation(getLocation().x+10, getLocation().y);
} else if (cmd.equals("Oben")) {
setLocation(getLocation().x, getLocation().y-10);
} else if (cmd.equals("Unten")) {
setLocation(getLocation().x, getLocation().y+10);
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
30.6 Kontextmens
30.6 Kontextmens
Ein wichtiger Bestandteil grafischer Oberflchen, der in den letzten Jahren verstrkt in die
Programme Einzug gehalten hat, sind die Kontext- oder Popup-Mens. Sie liefern auf rechten
Mausklick ein Men mit den wichtigsten Aktionen, die innerhalb der ausgewhlten Komponente zur
Verfgung stehen. Auf diese Weise steht eine Vielzahl von Funktionen dort zur Verfgung, wo sie
bentigt wird, anstatt umstndlich aus dem Hauptmen des Programms ausgewhlt oder per
Kommando eingegeben werden zu mssen.
Auch im JDK 1.1 gibt es Kontextmens, die so funktionieren. Sie werden durch die Klasse
PopupMenu, die aus Menu abgeleitet ist, implementiert. PopupMenu ist genauso zu bedienen wie
Menu und wird daher vor allem mittels geeigneter Aufrufe von add mit Meneintrgen bestckt.
Diesen kann ein ActionListener zugeordnet werden, der bei Auslsen des Menpunkts
aufgerufen wird. Gegenber der Klasse Menu besitzt PopupMenu eine zustzliche Methode show,
mit der das Kontextmen angezeigt wird:
public void show(Component origin, int x, int y)
java.awt.PopupMenu
Der erste Parameter origin ist die Komponente, an die das Kontextmen gebunden wird. Diese
Komponente hat lediglich administrative Aufgaben, spielt aber beim Aufruf des Kontextmens keine
Rolle. Die Argumente x und y geben die Position des Kontextmens relativ zum Ursprung von
origin an.
Um ein Kontextmen aufzurufen, sind mehrere Dinge zu tun. Zunchst mu das instanzierte
Kontextmen durch Aufruf von add an die Komponente gebunden werden, die auf Mausereignisse
fr den Aufruf reagieren soll. Dies kann beispielsweise das Fenster sein, in dem die Komponente
untergebracht ist, oder die Komponente selbst. Anschlieend mu in der Komponente durch Aufruf
von enableEvents die Behandlung von Maus-Events freigeschaltet werden. Drittens mu die
Methode processMouseEvent berlagert werden, und es mu bei jedem Mausereignis mit
isPopupTrigger abgefragt werden, ob es sich um das Ereignis zum Aufruf des Kontextmens
handelte. In diesem Fall kann das Kontextmen durch Aufruf von show angezeigt werden.
Kontextmens sind von Plattform zu Plattform leicht unterschiedlich implementiert, und Hinweis
insbesondere die Art des Aufrufs unterscheidet sich voneinander (zweite oder dritte
Maustaste, Aufruf beim Drcken oder Loslassen usw.). Um das Look-and-Feel des
jeweiligen Systems beizubehalten, sollte processMouseEvent berlagert werden, um
bei jeder Art von Mausereignis feststellen zu knnen, ob der PopupMenu-Trigger
ausgelst wurde. Der einfache Aufruf von show aus einem mousePressed- oder
mouseReleased-Ereignis heraus ist nicht portabel und sollte daher vermieden werden.
Das folgende Beispiel zeigt ein Programm mit einem Kontextmen, das die Punkte Rckgngig,
Ausschneiden, Kopieren und Einfgen enthlt. Das Kontextmen wird an das Hauptfenster
gehngt und von Mausereignissen dieses Fensters aufgerufen. Beim Auslsen einer Option des
Kontextmens wird eine entsprechende Meldung auf die Systemkonsole geschrieben.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
/* Listing3006.java */
import java.awt.*;
import java.awt.event.*;
class MyPopupMenu
extends PopupMenu
{
public MyPopupMenu(ActionListener listener)
{
MenuItem mi;
mi = new MenuItem("Rueckgaengig");
mi.addActionListener(listener);
add(mi);
addSeparator();
mi = new MenuItem("Ausschneiden");
mi.addActionListener(listener);
add(mi);
mi = new MenuItem("Kopieren");
mi.addActionListener(listener);
add(mi);
mi = new MenuItem("Einfuegen");
mi.addActionListener(listener);
add(mi);
}
}
public class Listing3006
extends Frame
implements ActionListener
{
MyPopupMenu popup;
Listing3006.java
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073 }
Titel
<<
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt Suchen
<
>
Index
>>
DOC
API
In diesem Kapitel soll das Erzeugen von Fenstern mit eingebetteten Dialogelementen vorgestellt
werden. Derartige Fenster werden in der Praxis sehr viel hufiger bentigt als Fenster, deren
Ausgabe mit primitiven Grafikoperationen erzeugt wurde, wie sie in den Kapiteln 23, 24 und 25
vorgestellt wurden. Der Einfachheit halber wollen wir derartige Fenster in diesem Kapitel als
Dialoge bezeichnen. Sie dienen dazu, Programmdaten anzuzeigen, und geben dem Anwender die
Mglichkeit, diese zu ndern.
Das Erstellen eines Dialogs erfolgt in vier Schritten:
Da Java prinzipiell keinen Unterschied zwischen Fenstern zur Ausgabe eines Dialogs und Hinweis
solchen zur Anzeige von Grafiken macht, ist es mglich, ein Dialogfenster wahlweise aus
Frame oder Dialog abzuleiten. Die Klasse Dialog erlaubt es, das Verndern der
Fenstergre durch den Anwender zu unterbinden, und bietet die Mglichkeit, den Dialog
modal zu machen. Dadurch wird die Interaktion des Anwenders mit anderen Fenstern der
Anwendung bis zum Schlieen des Dialogfensters blockiert. Im Gegensatz zu Frame
fehlt jedoch die Mglichkeit, eine Menleiste zu erzeugen oder dem Fenster ein Icon
zuzuordnen. Wir werden in den nachfolgenden Beispielen meist die Klasse Frame
verwenden, um Dialoge zu erzeugen. Die Klasse Dialog werden wir am Ende dieses
Kapitels vorstellen. Dabei werden wir insbesondere das Erzeugen modaler Dialoge und
die Rckgabe von Ergebniswerten aufzeigen.
java.awt.Container
java.awt.Container
Bei der ersten Variante wird lediglich die einzufgende Komponente bergeben und vom
Layoutmanager an der dafr vorgesehenen Position untergebracht. Die zweite Variante erlaubt das
Einfgen der aktuellen Komponente an beliebiger Stelle in der Liste der Komponenten.
Die dritte Variante erwartet zustzlich ein Constraints-Objekt, der bei bestimmten Layoutmanagern
weitere Informationen zur Positionierung der Komponente angibt. Wird beispielsweise die Klasse
BorderLayout zur Anordnung der Dialogelemente verwendet, kann hier eine der Konstanten
SOUTH, NORTH, WEST, EAST oder CENTER bergeben werden, um anzuzeigen, an welcher Stelle
des Fensters das Element plaziert werden soll.
Sollen Komponenten, die bereits an das Fenster bergeben wurden, wieder daraus entfernt werden,
so kann dazu die Methode remove verwendet werden. Als Parameter ist dabei das zu lschende
Objekt zu bergeben:
public void remove(Component comp)
java.awt.Container
Container stellt auch Methoden zur Verfgung, um auf die bereits eingefgten Dialogelemente
zuzugreifen:
public int getComponentCount()
public Component getComponent(int n)
public Component[] getComponents()
java.awt.Container
Mit getComponentCount kann die Anzahl aller eingefgten Komponenten ermittelt werden.
getComponent liefert die Komponente mit dem angegebenen Index, und getComponents gibt
ein Array mit allen eingefgten Komponenten zurck.
Wir wollen uns ein einfaches Beispiel ansehen, das diese vier Schritte demonstriert:
java.awt.Window
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
Listing3101.java
/* Listing3101.java */
import java.awt.*;
import java.awt.event.*;
public class Listing3101
extends Frame
{
public static void main(String[] args)
{
Listing3101 wnd = new Listing3101();
wnd.setVisible(true);
}
public Listing3101()
{
super("Dialogtest");
addWindowListener(new WindowClosingAdapter(true));
setLayout(new FlowLayout());
add(new Button("Abbruch"));
add(new Button("OK"));
pack();
}
}
Inhalt Suchen
<
>
Index
DOC
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
In vielen grafischen Oberflchen wird die Anordnung der Elemente eines Dialoges durch Angabe absoluter
Koordinaten vorgenommen. Dabei wird fr jede Komponente manuell oder mit Hilfe eines Ressourcen-Editors
pixelgenau festgelegt, an welcher Stelle im Dialog sie zu erscheinen hat.
Da Java-Programme auf vielen unterschiedlichen Plattformen mit unterschiedlichen Ausgabegerten laufen sollen,
war eine solche Vorgehensweise fr die Designer des AWT nicht akzeptabel. Sie whlten statt dessen den Umweg
ber einen Layoutmanager, der fr die Anordnung der Dialogelemente verantwortlich ist. Um einen
Layoutmanager verwenden zu knnen, wird dieser dem Fenster vor der bergabe der Dialogelemente mit der
Methode setLayout zugeordnet. Er ordnet dann die per add bergebenen Elemente auf dem Fenster an.
Jeder Layoutmanager implementiert seine eigene Logik bezglich der optimalen Anordnung der Komponenten:
Das FlowLayout ordnet Dialogelemente nebeneinander in einer Zeile an. Wenn keine weiteren Elemente
in die Zeile passen, wird mit der nchsten Zeile fortgefahren.
Das GridLayout ordnet die Dialogelemente in einem rechteckigen Gitter an, dessen Zeilen- und
Spaltenzahl beim Erstellen des Layoutmanagers angegeben wird.
Das BorderLayout verteilt die Dialogelemente nach Vorgabe des Programms auf die vier Randbereiche
und den Mittelbereich des Fensters.
Das CardLayout ist in der Lage, mehrere Unterdialoge in einem Fenster unterzubringen und jeweils
einen davon auf Anforderung des Programms anzuzeigen.
Das GridBagLayout ist ein komplexer Layoutmanager, der die Fhigkeiten von GridLayout
erweitert und es ermglicht, mit Hilfe von Bedingungsobjekten sehr komplexe Layouts zu erzeugen.
Neben den gestalterischen Fhigkeiten eines Layoutmanagers bestimmt in der Regel die Reihenfolge der Aufrufe
der add-Methode des Fensters die tatschliche Anordnung der Komponenten auf dem Bildschirm. Wenn nicht wie es z.B. beim BorderLayout mglich ist - zustzliche Positionierungsinformationen an das Fenster
bergeben werden, ordnet der jeweilige Layoutmanager die Komponenten in der Reihenfolge ihres Eintreffens an.
Um komplexere Layouts realisieren zu knnen, als die Layoutmanager sie in ihren jeweiligen Grundausprgungen
bieten, gibt es die Mglichkeit, Layoutmanager zu schachteln. Auf diese Weise kann auch ohne Vorgabe fester
Koordinaten fast jede gewnschte Komponentenanordnung realisiert werden. Sollte auch diese Variante nicht
genau genug sein, so bietet sich schlielich durch Verwendung eines Null-Layouts die Mglichkeit an,
Komponenten durch Vorgabe fester Koordinaten zu plazieren.
31.2.1 FlowLayout
Die Klasse FlowLayout stellt den einfachsten Layoutmanager dar. Alle Elemente werden so lange nacheinander
in einer Zeile angeordnet, bis kein Platz mehr vorhanden ist und in der nchsten Zeile fortgefahren wird.
Das FlowLayout wird einem Fenster durch folgende Anweisung zugeordnet:
setLayout(new FlowLayout());
Neben dem parameterlosen gibt es weitere Konstruktoren, die die Mglichkeit bieten, die Anordnung der
Elemente und ihre Abstnde voneinander vorzugeben:
public FlowLayout(int align)
java.awt.FlowLayout
Der Parameter align gibt an, ob die Elemente einer Zeile linksbndig, rechtsbndig oder zentriert angeordnet
werden. Hierzu stehen die Konstanten FlowLayout.CENTER, FlowLayout.LEFT und
FlowLayout.RIGHT zur Verfgung, als Voreinstellung wird FlowLayout.CENTER verwendet. Mit hgap
und vgap knnen die horizontalen und vertikalen Abstnde zwischen den Komponenten vorgegeben werden. Die
Voreinstellung ist 5.
Das folgende Listing zeigt die Verwendung der Klasse FlowLayout am Beispiel von fnf Buttons, die in einem
Grafikfenster angezeigt werden. Anstelle der normalen zentrierten Anordnung werden die Elemente linksbndig
angeordnet, und der Abstand zwischen den Buttons betrgt 20 Pixel:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
/* Listing3102.java */
import java.awt.*;
import java.awt.event.*;
public class Listing3102
extends Frame
{
public static void main(String[] args)
{
Listing3102 wnd = new Listing3102();
wnd.setVisible(true);
}
public Listing3102()
{
super("Test FlowLayout");
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
setLayout(new FlowLayout(FlowLayout.LEFT,20,20));
add(new Button("Button 1"));
add(new Button("Button 2"));
add(new Button("Button 3"));
add(new Button("Button 4"));
add(new Button("Button 5"));
pack();
}
}
Listing3102.java
31.2.2 GridLayout
Ein GridLayout bietet eine grere Kontrolle ber die Anordnung der Elemente als ein FlowLayout. Hier
werden die Komponenten nicht einfach nacheinander auf dem Bildschirm positioniert, sondern innerhalb eines
rechteckigen Gitters angeordnet, dessen Elemente eine feste Gre haben.
Das Programm bergibt dazu beim Aufruf des Konstruktors zwei Parameter, rows und columns, mit denen die
vertikale und horizontale Anzahl an Elementen festgelegt wird:
public void GridLayout(int rows, int columns)
java.awt.GridLayout
Beim Aufruf von add werden die Komponenten dann nacheinander in die einzelnen Zellen der Gittermatrix
gelegt. Analog zum FlowLayout wird dabei zunchst die erste Zeile von links nach rechts gefllt, dann die
zweite usw.
hnlich wie beim FlowLayout steht ein zustzlicher Konstruktor zur Verfgung, der es erlaubt, die Gre der
horizontalen und vertikalen Lcken zu verndern:
public void GridLayout(int rows, int columns, int hgap, int vgap)java.awt.GridLayout
Die grere Kontrolle des Programms ber das Layout besteht nun darin, da der Umbruch in die nchste Zeile
genau vorhergesagt werden kann. Anders als beim FlowLayout erfolgt dieser nicht erst dann, wenn keine
weiteren Elemente in die Zeile passen, sondern wenn dort so viele Elemente plaziert wurden, wie das Programm
vorgegeben hat.
Das folgende Beispiel zeigt ein Fenster mit einem Gitter der Gre 4*2 Elemente, das ingesamt sieben Buttons
anzeigt:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
/* Listing3103.java */
Listing3103.java
import java.awt.*;
import java.awt.event.*;
public class Listing3103
extends Frame
{
public static void main(String[] args)
{
Listing3103 wnd = new Listing3103();
wnd.setVisible(true);
}
public Listing3103()
{
super("Test GridLayout");
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
setLayout(new GridLayout(4,2));
add(new Button("Button 1"));
add(new Button("Button 2"));
add(new Button("Button 3"));
add(new Button("Button 4"));
add(new Button("Button 5"));
add(new Button("Button 6"));
add(new Button("Button 7"));
pack();
}
}
31.2.3 BorderLayout
Das BorderLayout verfolgt einen anderen Ansatz als die beiden vorigen Layoutmanager, denn die
Positionierung der Komponenten wird nicht mehr primr durch die Reihenfolge der Aufrufe von add bestimmt.
Statt dessen teilt das BorderLayout den Bildschirm in fnf Bereiche auf, und zwar in die vier Rnder und das
Zentrum. Durch Angabe eines Himmelsrichtungs-Constraints wird beim Aufruf von add angegeben, auf welchem
dieser Bereiche die Komponente plaziert werden soll. BorderLayout stellt dazu folgende Konstanten zur
Verfgung:
Zur bergabe dieses Parameters gibt es die Methode add der Klasse Container in einer Variante mit einem
Object als zweiten Parameter:
public void add(Component comp, Object constraints)
java.awt.Container
Das folgende Beispiel zeigt die Anordnung von fnf Buttons in einem BorderLayout. Jeweils einer der Buttons
wird auf die vier Randbereiche verteilt, und der fnfte Button steht in der Mitte. Die Gre des Fensters wird fest
auf 300*200 Pixel eingestellt:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
/* Listing3104.java */
import java.awt.*;
import java.awt.event.*;
public class Listing3104
extends Frame
{
public static void main(String[] args)
{
Listing3104 wnd = new Listing3104();
wnd.setVisible(true);
}
public Listing3104()
{
super("Test BorderLayout");
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
setSize(300,200);
setLayout(new BorderLayout());
add(new Button("Button 1"), BorderLayout.NORTH);
add(new Button("Button 2"), BorderLayout.SOUTH);
add(new Button("Button 3"), BorderLayout.WEST);
add(new Button("Button 4"), BorderLayout.EAST);
add(new Button("Button 5"), BorderLayout.CENTER);
}
}
Listing3104.java
Nord- und Sdelement behalten ihre gewnschte Hhe, werden aber auf die volle Fensterbreite skaliert.
Ost- und Westelement behalten ihre gewnschte Breite, werden aber in der Hhe so skaliert, da sie genau
zwischen Nord- und Sdelement passen.
Das Mittelelement wird in der Hhe und Breite so angepat, da es den verbleibenden freien Raum
einnimmt.
Auch beim BorderLayout kann die Gre der Lcken zwischen den Elementen an den Konstruktor bergeben
werden:
public BorderLayout(int hgap, int vgap)
java.awt.BorderLayout
Wenn das vorige Beispiel ein BorderLayout mit einer vertikalen und horizontalen Lcke von 10 Pixeln
definieren wrde, wre die Ausgabe des Programms wie folgt:
31.2.4 GridBagLayout
Das GridBagLayout ist der aufwendigste Layoutmanager in Java. Er erlaubt eine sehr flexible Gestaltung der
Oberflche und bietet viele Mglichkeiten, die in den anderen Layoutmanagern nicht zu finden sind. Der Preis
dafr ist eine etwas kompliziertere Bedienung und ein hherer Einarbeitungsaufwand. Wir wollen in diesem
Zunchst ist ein Objekt des Typs GridBagLayout zu instanzieren und durch Aufruf von setLayout
dem Fenster zuzuweisen.
Fr jedes einzufgende Dialogelement ist nun ein Objekt des Typs GridBagConstraints anzulegen,
um ber dessen Membervariablen die spezifischen Layouteigenschaften des Dialogelements zu
beschreiben.
Sowohl das Dialogelement als auch das Eigenschaftenobjekt werden durch Aufruf der Methode
setConstraints an den Layoutmanager bergeben.
Schlielich wird das Dialogelement mit add an das Fenster bergeben.
...
GridBagLayout gbl = new GridBagLayout();
GridBagConstraints gbc = new GridBagConstraints();
setLayout(gbl);
List list = new List();
gbc.gridx = 0;
gbc.gridy = 0;
gbc.gridwidth = 1;
gbc.gridheight = 1;
gbc.weightx = 100;
gbc.weighty = 100;
gbc.fill = GridBagConstraints.BOTH;
gbl.setConstraints(list, gbc);
add(list);
...
java.awt.GridBagConstraints
Ein GridBagLayout unterteilt das Fenster hnlich wie das GridLayout in ein rechteckiges Gitter von
Zellen, in denen die Dialogelemente plaziert werden. Im Gegensatz zum GridLayout knnen die Zellen
allerdings unterschiedliche Gren haben, und die Dialogelemente knnen auf verschiedene Weise
innerhalb der Zellen plaziert werden. Zudem kann ein Dialogelement sich in beiden Richtungen ber mehr
als eine einzige Zelle erstrecken.
Der Parameter gridx gibt an, in welcher Spalte des logischen Gitters der linke Rand des Dialogelements
liegen soll. Die erste Spalte hat den Wert 0. gridy gibt analog die logische Zeile des oberen Rands des
Dialogelements an. Beide Werte werden nicht etwa in Pixeln angegeben, sondern bezeichnen die Zellen des
logischen Gitternetzes. (0, 0) ist die linke obere Ecke.
Die Parameter gridwidth und gridheight geben die horizontale und vertikale Ausdehnung des
Dialogelements an. Soll ein Dialogelement beispielsweise zwei Zellen breit sein, so ist fr gridwidth
der Wert 2 anzugeben.
Mit dem Parameter fill wird definiert, wie sich die Abmessungen des Dialogelements verndern, wenn
die Gre des Fensters verndert wird. Wird hier GridBagConstraints.NONE angegeben, bleibt das
Element immer in seiner ursprnglichen Gre. Wird einer der Werte
GridBagConstraints.HORIZONTAL, GridBagConstraints.VERTICAL oder
GridBagConstraints.BOTH angegeben, skaliert der Layoutmanager das Dialogelement automatisch
in horizontaler, vertikaler oder in beiden Richtungen.
Der Parameter anchor bestimmt, an welcher Kante der Zelle das Dialogelement festgemacht wird, wenn
nach dem Skalieren noch Platz in der Zelle verbleibt. Hier knnen die folgenden Konstanten angegeben
werden:
GridBagConstraints.CENTER
GridBagConstraints.NORTH
GridBagConstraints.NORTHEAST
GridBagConstraints.EAST
GridBagConstraints.SOUTHEAST
GridBagConstraints.SOUTH
GridBagConstraints.SOUTHWEST
GridBagConstraints.WEST
GridBagConstraints.NORTHWEST
Die Parameter weightx und weighty sind etwas trickreich. Sie bestimmen das Verhltnis, in dem
berschssiger Platz auf die Zellen einer Zeile bzw. einer Spalte verteilt wird. Ist der Wert 0, bekommt die
Zelle nichts von eventuell berschssigem Platz ab. Bedeutsam ist dabei nur das relative Verhltnis, der
absolute Wert dieses Parameters spielt keine Rolle. Die Werte sollten allerdings nicht negativ sein.
Mit dem Parameter insets kann ein Rand gesetzt werden. Er wird um das Dialogelement herum auf
jeden Fall freigelassen.
Mit ipadx und ipady kann ein konstanter Wert zur minimalen Breite und Hhe der Komponente
hinzugefgt werden.
Um die Anwendung der Parameter zu veranschaulichen, wollen wir uns ein Beispiel ansehen. Das zu erstellende
Programm soll ein Fenster mit sechs Dialogelementen entsprechend Abbildung 31.8 aufbauen. Die Liste auf der
linken Seite soll beim Skalieren in beide Richtungen vergrert werden. Die Textfelder sollen dagegen lediglich in
der Breite wachsen, ihre ursprngliche Hhe aber beibehalten. Bei vertikaler Vergrerung des Fensters sollen sie
untereinander stehen bleiben. Die Beschriftungen sollen ihre anfngliche Gre beibehalten und - unabhngig von
der Fenstergre - direkt vor den Textfeldern stehen bleiben. Auch der Button soll seine ursprngliche Gre
beibehalten, wenn das Fenster skaliert wird. Zudem soll er immer in der rechten unteren Ecke stehen. Zwischen
den Dialogelementen soll ein Standardabstand von zwei Pixeln eingehalten werden.
/* Listing3106.java */
import java.awt.*;
import java.awt.event.*;
public class Listing3106
extends Frame
{
public static void main(String[] args)
{
Listing3106 wnd = new Listing3106();
wnd.setVisible(true);
}
public Listing3106()
{
super("Test GridBagLayout");
setBackground(Color.lightGray);
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
GridBagLayout gbl = new GridBagLayout();
GridBagConstraints gbc;
setLayout(gbl);
//List hinzufgen
Listing3106.java
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074 }
JDK1.1-1.4
31.2.5 NULL-Layout
Ein Null-Layout wird erzeugt, indem die Methode setLayout mit dem Argument null aufgerufen wird. In
diesem Fall verwendet das Fenster keinen Layoutmanager, sondern berlt die Positionierung der Komponenten
der Anwendung. Fr jedes einzufgende Dialogelement sind dann drei Schritte auszufhren:
Der erste und letzte Schritt unterscheiden sich nicht von unseren bisherigen Versuchen, bei denen wir vordefinierte
Layoutmanager verwendet haben. Im zweiten Schritt ist allerdings etwas Handarbeit notwendig. Gre und
Position des Dialogelements knnen mit den Methoden move und setSize oder - noch einfacher - mit
setBounds festgelegt werden:
public void setBounds(
int x, int y, int width, int height
)
java.awt.Component
Der Punkt (x,y) bestimmt die neue Anfangsposition des Dialogelements und (width, height) seine Gre.
Das folgende Listing demonstriert diese Vorgehensweise am Beispiel einer treppenartigen Anordnung von fnf
Buttons:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
/* Listing3107.java */
Listing3107.java
import java.awt.*;
import java.awt.event.*;
public class Listing3107
extends Frame
{
public static void main(String[] args)
{
Listing3107 wnd = new Listing3107();
wnd.setVisible(true);
}
public Listing3107()
{
super("Dialogelemente ohne Layoutmanager");
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
setSize(300,250);
setLayout(null);
for (int i = 0; i < 5; ++i) {
Button button = new Button("Button"+(i+1));
button.setBounds(10+i*35,40+i*35,100,30);
add(button);
}
}
}
/* Listing3108.java */
import java.awt.*;
import java.awt.event.*;
public class Listing3108
extends Frame
{
public static void main(String[] args)
{
Listing3108 wnd = new Listing3108();
wnd.setVisible(true);
}
public Listing3108()
{
super("Geschachtelte Layoutmanager");
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
//Panel 1
Panel panel1 = new Panel();
panel1.setLayout(new GridLayout(3,1));
panel1.add(new Button("Button1"));
panel1.add(new Button("Button2"));
panel1.add(new Button("Button3"));
//Panel 2
Panel panel2 = new Panel();
panel2.setLayout(new BorderLayout());
panel2.add(new Button("Button4"), BorderLayout.NORTH);
panel2.add(new Button("Button5"), BorderLayout.SOUTH);
panel2.add(new Button("Button6"), BorderLayout.WEST);
panel2.add(new Button("Button7"), BorderLayout.EAST);
panel2.add(new Button("Button8"), BorderLayout.CENTER);
//Hauptfenster
setLayout(new GridLayout(1,2));
add(panel1);
add(panel2);
pack();
}
}
Listing3108.java
/* Listing3109.java */
import java.awt.*;
import java.awt.event.*;
public class Listing3109
extends Frame
{
public static void main(String[] args)
{
Listing3109 wnd = new Listing3109();
wnd.setVisible(true);
}
public Listing3109()
{
super("Geschachtelte Layoutmanager, Teil II");
addWindowListener(new WindowClosingAdapter(true));
//Layout setzen und Komponenten hinzufgen
setSize(300,200);
//Panel 1
Panel panel1 = new Panel();
panel1.setLayout(new GridLayout(3,2));
panel1.add(new Button("Button1"));
panel1.add(new Button("Button2"));
panel1.add(new Button("Button3"));
panel1.add(new Button("Button4"));
panel1.add(new Button("Button5"));
panel1.add(new Button("Button6"));
//Panel 2
Panel panel2 = new Panel();
panel2.setLayout(new FlowLayout(FlowLayout.RIGHT));
panel2.add(new Button("Abbruch"));
panel2.add(new Button("OK"));
//Hauptfenster
setLayout(new BorderLayout());
add(panel1, BorderLayout.CENTER);
add(panel2, BorderLayout.SOUTH);
}
Listing3109.java
040 }
Listing 31.9: Eine weitere Anwendung fr geschachtelte Layoutmanager
Die Ausgabe des Programms ist:
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
Modale Dialoge sind solche, die alle Benutzereingaben des Programmes beanspruchen und andere Fenster erst dann
wieder zum Zuge kommen lassen, wenn das Dialogfenster geschlossen wird. Eine wichtige Eigenschaft modaler
Dialoge ist es, da im Programm der Aufruf zur Anzeige des Dialogs so lange blockiert, bis der Dialog beendet ist.
Auf diese Weise kann an einer bestimmten Stelle im Programm auf eine Eingabe gewartet werden und erst dann mit
der Bearbeitung fortgefahren werden, wenn die Eingabe erfolgt ist.
Im AWT des JDK 1.0 gab es einen schwerwiegenden Fehler, durch den das Erzeugen modaler Dialoge unmglich
gemacht wurde. Der Fehler hielt sich bis zur Version 1.0.2 und wurde erst mit Erscheinen des JDK 1.1 behoben. Da
viele Anwenderdialoge von Natur aus modalen Charakter haben, wurde dieser Fehler von vielen als schwerwiegend
angesehen, und die Java-Gemeinde entwickelte eine Reihe von Workarounds, die aber allesamt nicht voll
zufriedenstellen konnten. Glcklicherweise wurden die Probleme mit dem JDK 1.1 behoben, und wir wollen in
diesem Kapitel aufzeigen, wie modale Dialoge in Java erzeugt werden knnen.
Ein modaler Dialog mu immer aus der Klasse Dialog abgeleitet werden. Nur sie bietet die Mglichkeit, an den
Konstruktor einen booleschen Wert zu bergeben, der festlegt, da die brigen Fenster der Anwendung whrend
der Anzeige des Dialogs suspendiert werden. Dialog besitzt folgende Konstruktoren:
public Dialog(Frame owner)
java.awt.Dialog
Als erstes Argument mu in jedem Fall ein Frame- oder Dialog-Objekt als Vaterfenster bergeben werden (bis
zur Version 1.1 waren nur Frame-Objekte erlaubt). Mit title kann der Inhalt der Titelzeile vorgegeben werden,
und der Parameter modal entscheidet, ob der Dialog modal dargestellt wird oder nicht.
Dialog bietet die Methoden isModal und setModal, mit denen auf die Modalitt des Dialogs zugegriffen
werden kann:
public boolean isModal()
public void setModal(boolean b)
java.awt.Dialog
Der Rckgabewert von isModal ist true, falls der Dialog modal ist. Andernfalls ist er false.
Die Methode setModal, deren Fhigkeit darin besteht, einen bestehenden Dialog zwischen den
Warnung
Zustnden modal und nicht-modal umzuschalten, ist mit Vorsicht zu genieen. Unter Windows 95 hat
ein Aufruf im JDK 1.1 mitunter dazu gefhrt, da beim Schlieen des Fensters die Nachrichtenschleife
des Aufrufers deaktiviert blieb und das Programm sich aufhngte. Am besten, man entscheidet schon
im Konstruktor, ob der Dialog modal sein soll oder nicht.
Ein zustzliches Feature der Klasse Dialog besteht darin, die Vernderbarkeit der Gre eines Fensters durch den
Anwender zu unterbinden:
public void setResizable(boolean resizable)
java.awt.Dialog
Nach einem Aufruf von setResizable mit false als Argument kann die Gre des Fensters nicht mehr vom
Anwender verndert werden. Nach einem Aufruf von setResizable(true) ist dies wieder mglich. Mit
isResizable kann der aktuelle Zustand dieses Schalters abgefragt werden.
Auch die Methode setResizable ist nicht ganz unkritisch, denn sie hat auf einigen UNIXSystemen zu Problemen gefhrt. Sowohl unter SUN Solaris als auch unter LINUX kam es im JDK 1.1
zu Hngern bei Programmen, die diese Methode benutzten. Falls sich die nachfolgenden
Beispielprogramme auf Ihrem System nicht so verhalten wie angegeben (typischerweise wird der
Dialog gar nicht erst angezeigt), sollten Sie versuchsweise den Aufruf von setResizable
auskommentieren.
Warnung
Das folgende Beispiel demonstriert die Anwendung der Klasse Dialog. Es zeigt einen Frame, aus dem per
Buttonklick ein modaler Dialog aufgerufen werden kann. Der Dialog fragt den Anwender, ob die Anwendung
beendet werden soll, und wartet, bis einer der Buttons Ja oder Nein gedrckt wurde. In diesem Fall wird ein
boolescher Rckgabewert generiert, der nach dem Schlieen des Dialogs an das Vaterfenster zurckgegeben wird.
Falls der Rckgabewert true (entprechend dem Button Ja) ist, wird die Anwendung beendet, andernfalls luft
sie weiter:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
/* Listing3110.java */
import java.awt.*;
import java.awt.event.*;
class YesNoDialog
extends Dialog
implements ActionListener
{
boolean result;
public YesNoDialog(Frame owner, String msg)
{
super(owner, "Ja-/Nein-Auswahl", true);
//Fenster
setBackground(Color.lightGray);
setLayout(new BorderLayout());
setResizable(false); //Hinweis im Text beachten
Point parloc = owner.getLocation();
setLocation(parloc.x + 30, parloc.y + 30);
//Message
Listing3110.java
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
}
089
}
090 }
Hinweis
Nach dem Start zeigt das Programm zunchst das in Abbildung 31.14 dargestellte Fenster an:
Ausstattung mit Buttons variabel ist und zum Zeitpunkt der Instanzierung festgelegt werden kann:
public ModalDialog(
Frame owner,
String title,
String msg,
String buttons
);
Der Konstruktor erwartet neben dem Vater-Frame drei weitere Parameter, title, msg und buttons. In title
wird der Inhalt der Titelzeile bergeben, und msg spezifiziert den Text innerhalb des Dialogs. Der Parameter
buttons erwartet eine Liste von Button-Bezeichnern, die zur Festlegung der Anzahl und Beschriftung der
Buttons dienen. Die einzelnen Elemente sind durch Kommata zu trennen und werden innerhalb des Dialogs mit
einem StringTokenizer zerlegt. Der in getResult gelieferte Rckgabewert des Dialogs ist - anders als im
vorigen Beispiel - ein String und entspricht der Beschriftung des zum Schlieen verwendeten Buttons.
ModalDialog enthlt einige statische Methoden, mit denen Dialoge mit einer festen Buttonstruktur einfach
erzeugt werden knnen. So erzeugt OKButton lediglich einen Button mit der Beschriftung OK,
YesNoDialog zwei Buttons, Ja und Nein, und YesNoCancelDialog erzeugt einen Dialog mit drei
Buttons, Ja, Nein und Abbruch. Das folgende Listing zeigt die Klasse ModalDialog und ein
Rahmenprogramm zum Testen:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
/* Listing3111.java */
import java.awt.*;
import java.awt.event.*;
import java.util.*;
class ModalDialog
extends Dialog
implements ActionListener
{
String result;
public static String OKDialog(Frame owner, String msg)
{
ModalDialog dlg;
dlg = new ModalDialog(owner,"Nachricht",msg,"OK");
dlg.setVisible(true);
return dlg.getResult();
}
public static String YesNoDialog(Frame owner, String msg)
{
ModalDialog dlg;
dlg = new ModalDialog(owner,"Frage",msg,"Ja,Nein");
dlg.setVisible(true);
return dlg.getResult();
}
public static String YesNoCancelDialog(Frame owner,String msg)
{
ModalDialog dlg;
dlg = new ModalDialog(owner,"Frage",msg,"Ja,Nein,Abbruch");
dlg.setVisible(true);
return dlg.getResult();
Listing3111.java
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
}
public ModalDialog(
Frame owner,
String title,
String msg,
String buttons
)
{
super(owner, title, true);
//Fenster
setBackground(Color.lightGray);
setLayout(new BorderLayout());
setResizable(false);
Point parloc = owner.getLocation();
setLocation(parloc.x + 30, parloc.y + 30);
//Message
add(new Label(msg), BorderLayout.CENTER);
//Buttons
Panel panel = new Panel();
panel.setLayout(new FlowLayout(FlowLayout.CENTER));
StringTokenizer strtok = new StringTokenizer(buttons,",");
while (strtok.hasMoreTokens()) {
Button button = new Button(strtok.nextToken());
button.addActionListener(this);
panel.add(button);
}
add(panel, BorderLayout.SOUTH);
pack();
}
public void actionPerformed(ActionEvent event)
{
result = event.getActionCommand();
setVisible(false);
dispose();
}
public String getResult()
{
return result;
}
}
public class Listing3111
extends Frame
implements ActionListener
{
public static void main(String[] args)
{
Listing3111 wnd = new Listing3111();
wnd.setVisible(true);
}
public Listing3111()
{
super("Drei modale Standarddialoge");
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129 }
setLayout(new FlowLayout());
setBackground(Color.lightGray);
Button button = new Button("OKDialog");
button.addActionListener(this);
add(button);
button = new Button("YesNoDialog");
button.addActionListener(this);
add(button);
button = new Button("YesNoCancelDialog");
button.addActionListener(this);
add(button);
setLocation(100,100);
setSize(400,200);
setVisible(true);
}
public void actionPerformed(ActionEvent event)
{
String cmd = event.getActionCommand();
if (cmd.equals("OKDialog")) {
ModalDialog.OKDialog(this,"Dream, dream, dream, ...");
} else if (cmd.equals("YesNoDialog")) {
String ret = ModalDialog.YesNoDialog(
this,
"Programm beenden?"
);
if (ret.equals("Ja")) {
setVisible(false);
dispose();
System.exit(0);
}
} else if (cmd.equals("YesNoCancelDialog")) {
String msg = "Verzeichnis erstellen?";
String ret = ModalDialog.YesNoCancelDialog(this,msg);
ModalDialog.OKDialog(this,"Rckgabe: " + ret);
}
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
32.1 Rahmenprogramm
32.1 Rahmenprogramm
Nachdem in Kapitel 31 die grundstzliche Vorgehensweise beim Anlegen eines Dialogs besprochen
wurde, behandelt dieses Kapitel nun die verschiedenen Dialogelemente. Zu jedem Dialogelement
werden die Konstruktoren und die verschiedenen Methoden zur Steuerung seines Verhaltens
vorgestellt. Falls ein Dialogelement auch Nachrichten sendet, werden diese erlutert und ihre
Anwendung demonstriert.
Jedes Dialogelement wird in Java durch eine eigene Klasse reprsentiert, die dessen Verhalten und
Eigenschaften kapselt. Zur Aufnahme eines neuen Dialogelements in einen Dialog wird eine neue
Instanz der gewnschten Klasse angelegt und das resultierende Objekt mit add in den Dialog
eingefgt. Die Methoden des Dialogelements knnen dann zu einem beliebigen Zeitpunkt aufgerufen
werden, um dessen Verhalten zu beeinflussen. Alle Dialogelemente sind aus der Klasse Component
abgeleitet. Sie verfgen ber die grundlegenden Eigenschaften eines Fensters, besitzen eine Gre und
Position und sind in der Lage, Nachrichten zu empfangen und zu bearbeiten.
Damit nicht jedesmal ein komplettes Programm abgedruckt werden mu, wollen wir die
Hinweis
Beispiele in ein vordefiniertes Rahmen-Programm einbetten. Dieses erzeugt ein Fenster mit
zwei Buttons, die zum Aufrufen des Dialogs bzw. zum Beenden des Programms verwendet
werden knnen:
ein Panel plaziert, das an die Methode customizeLayout weitergegeben wird, die darin die
Beispielkomponenten plaziert. In der Basisversion ist diese Methode leer, und der Dialog hat folgendes
Aussehen:
/* DialogBeispiel.java */
import java.awt.*;
import java.awt.event.*;
class MyDialog
extends Dialog
implements ActionListener
{
public MyDialog(Frame parent)
{
super(parent,"MyDialog",true);
Point parloc = parent.getLocation();
setBounds(parloc.x + 30, parloc.y + 30,400,300);
setBackground(Color.lightGray);
setLayout(new BorderLayout());
//Panel
Panel panel = new Panel();
customizeLayout(panel);
add(panel, BorderLayout.CENTER);
//Ende-Button
Button button = new Button("Ende");
button.addActionListener(this);
add(button, BorderLayout.SOUTH);
//Window-Listener
addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent event)
{
endDialog();
}
}
);
pack();
}
DialogBeispiel.java
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
}
098 }
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
>
>>
API
32.2 Label
32.2 Label
Ein Label dient zur Beschriftung von Dialogboxen. Es enthlt eine Zeile Text, die
auf dem Bildschirm angezeigt wird und vom Programm verndert werden kann.
public Label()
java.awt.Label
Der parameterlose Konstruktor erzeugt ein Label ohne Text. Wird der Parameter
text bergeben, verwendet das Label diesen als Beschriftung. Der Parameter align
bestimmt die Ausrichtung des Texts. Hier kann eine der Konstanten Label.LEFT,
Label.RIGHT oder Label.CENTER bergeben werden.
public void setText(String text)
java.awt.Label
setText und getText erlauben den Zugriff auf den Text des Labels und
setAlignment und getAlignment auf die Ausrichtung des Texts. Die Parameter
dieser Methoden haben dieselbe Bedeutung wie im Konstruktor.
001
002
003
004
005
006
007
008
009
010
Label.inc
/* Label.inc */
private void customizeLayout(Panel panel)
{
panel.setLayout(new GridLayout(4,1));
panel.add(new Label("Default"));
panel.add(new Label("Links",Label.LEFT));
panel.add(new Label("Zentriert",Label.CENTER));
panel.add(new Label("Rechts",Label.RIGHT));
}
Titel
<<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
32.4 Checkbox
32.4 Checkbox
Eine Checkbox ist ein Eingabeelement, das eine Zustandsvariable besitzt, die zwischen den Werten true
und false umgeschaltet werden kann. Der aktuelle Zustand wird durch ein Hkchen oder Kreuz in der
Checkbox angezeigt.
public Checkbox()
java.awt.Checkbox
Der parameterlose Konstruktor erzeugt eine Checkbox ohne Beschriftung mit dem Anfangszustand false.
Wird der String label angegeben, bekommt die Checkbox die angegebene Beschriftung. Durch bergabe
des booleschen Parameters state ist es mglich, den anfnglichen Zustand der Checkbox vorzugeben. Der
in den letzten beiden Konstruktoren verwendete Parameter cbg dient zur Gruppierung von Radiobuttons und
sollte bei einer Checkbox stets null sein.
public String getLabel()
java.awt.Checkbox
Die Methoden ermglichen den Zugriff auf die Beschriftung und den aktuellen Zustand der Checkbox.
Oft reprsentiert eine Checkbox einen logischen Schalter, dessen Zustand abgefragt wird, nachdem der
Dialog beendet wurde. Zustzlich kann aber auch unmittelbar auf eine Zustandsnderung reagiert werden,
denn eine Checkbox generiert ein Item-Event, wenn die Markierung vom Anwender gesetzt oder
zurckgenommen wird. Um auf dieses Event zu reagieren, ist durch Aufruf von addItemListener ein
Objekt, das das Interface ItemListener implementiert, bei der Checkbox zu registrieren:
java.awt.Checkbox
Ein Item-Event wird immer dann gesendet, wenn sich der Zustand einer Checkbox verndert hat. In diesem
Fall wird im Ereignisempfnger die Methode itemStateChanged mit einem Argument vom Typ
ItemEvent aufgerufen:
public abstract void itemStateChanged(ItemEvent e)
java.awt.event.ItemListener
Das ItemEvent stellt die Methode getItemSelectable zur Verfgung, mit der ermittelt werden kann,
durch welche Checkbox das Ereignis ausgelst wurde:
public ItemSelectable getItemSelectable()
java.awt.event.ItemEvent
Der Rckgabewert kann dann in ein Objekt des Typs Checkbox konvertiert werden. Durch Aufruf von
getState kann der aktuelle Zustand bestimmt werden.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
/* Checkbox1.inc */
Checkbox1.inc
001
002
003
004
005
006
007
Checkbox2.inc
/* Checkbox2.inc */
public void itemStateChanged(ItemEvent event)
{
Checkbox cb = (Checkbox) event.getItemSelectable();
System.out.println(cb.getLabel() + ": " + cb.getState());
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
32.5 CheckboxGroup
32.5 CheckboxGroup
Eine CheckboxGroup ist die Java-Variante einer Gruppe von Radiobuttons, also einer Kollektion von
Buttons, von denen immer genau einer aktiviert ist. Wird ein anderer Button aktiviert, so ndert er seinen
internen Status auf true, und der zuvor gesetzte wird false.
Eine CheckboxGroup ist nichts anderes als eine Checkbox, deren CheckboxGroup-Parameter gesetzt
ist.
public Checkbox(String label, CheckboxGroup cbg, boolean state)java.awt.Checkbox
public Checkbox(String label, boolean state, CheckboxGroup cbg)
Anders als bei einer gewhnlichen Checkbox stehen jetzt nur noch zwei Konstruktoren zur Verfgung. An
diese werden die Beschriftung, der Anfangszustand und ein Objekt der Klasse CheckboxGroup bergeben.
Die CheckboxGroup sorgt dabei fr den Gruppierungseffekt und die Logik beim Umschalten der
Radiobuttons. Fr jede zusammenhngende Gruppe von Radiobuttons ist daher ein eigenes Objekt der Klasse
CheckboxGroup zu instanzieren und an den Konstruktor zu bergeben.
Die CheckboxGroup bietet alle Methoden, die auch bei einer Checkbox verfgbar sind. setState
funktioniert allerdings nur dann, wenn als Parameter true bergeben wird. In diesem Fall wird der Zustand
der zugehrigen Checkbox gesetzt und der aller anderen Checkboxes derselben Gruppe zurckgenommen.
Bei der bergabe von false an setState passiert gar nichts. Zustzlich gibt es zwei Methoden
getCheckboxGroup und setCheckboxGroup, die den Zugriff auf die zugeordnete CheckboxGroup
erlauben:
public void setCheckboxGroup(CheckboxGroup cbg)
java.awt.CheckboxGroup
Mit setCheckboxGroup kann die Zuordnung der Checkboxes zu einer CheckboxGroup auch nach der
Konstruktion gendert werden. Das beim Aufruf von getCheckboxGroup zurckgegebene Objekt kann
dazu verwendet werden, mit Hilfe der Methoden getCurrent und setCurrent der Klasse
CheckboxGroup auf das selektierte Element der CheckboxGroup zuzugreifen:
java.awt.CheckboxGroup
getCurrent liefert die Checkbox, deren Zustand true ist. Um mit setCurrent eine Checkbox zu
aktivieren, mu diese als Parameter bergeben werden. Alle anderen Checkboxes derselben Gruppe
bekommen dann den Zustand false.
Die einzelnen Checkboxes einer CheckboxGroup senden ein ITEM-Event, wenn die Checkbox selektiert
wird. Dagegen wird kein Ereignis gesendet, wenn die Checkbox deselektiert wird oder wenn ihr Zustand
nicht vom Anwender, sondern vom Programm verndert wird.
Das folgende Beispiel zeigt die Definition von zwei Objekten des Typs CheckboxGroup mit jeweils drei
Elementen. In jeder der beiden Gruppen ist immer genau ein Element markiert, das unabhngig von den
Elementen der anderen Gruppe ausgewhlt werden kann:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
CheckboxGroup.inc
/* CheckboxGroup.inc */
private void customizeLayout(Panel panel)
{
panel.setLayout(new GridLayout(3,2));
CheckboxGroup cbg1 = new CheckboxGroup();
CheckboxGroup cbg2 = new CheckboxGroup();
panel.add(new Checkbox("rot",cbg1,true));
panel.add(new Checkbox("eckig",cbg2,true));
panel.add(new Checkbox("blau",cbg1,false));
panel.add(new Checkbox("rund",cbg2,false));
panel.add(new Checkbox("gelb",cbg1,false));
panel.add(new Checkbox("schief",cbg2,false));
}
Titel
Inhalt
Suchen
Index
DOC
<<
<
>
>>
API
Titel
<<
Inhalt
<
Suchen
>
Index
>>
DOC
API
32.6 TextField
32.6 TextField
Ein TextField dient zur Darstellung und zur Eingabe von Text. Sowohl der Anwender als auch das
Programm knnen den dargestellten Text auslesen und verndern.
public TextField()
java.awt.TextField
Der parameterlose Konstruktor erzeugt ein leeres Textf