Java ist auch eine Insel

Christian Ullenboom
Java ist auch eine Insel
Programmieren mit der Java Platform, Standard Edition 6
Auf einen Blick
1
Java ist auch eine Sprache ....................................................................
55
2
Sprachbeschreibung .............................................................................
85
3
Klassen und Objekte ............................................................................
177
4
Der Umgang mit Zeichenketten ...........................................................
233
5
Mathematisches ...................................................................................
291
6
Eigene Klassen schreiben .....................................................................
319
7
Angewandte Objektorientierung .........................................................
439
8
Exceptions ............................................................................................
465
9
Die Funktionsbibliothek .......................................................................
491
10
Threads und nebenläufige Programmierung ........................................
543
11
Raum und Zeit ......................................................................................
623
12
Datenstrukturen und Algorithmen .......................................................
655
13
Dateien und Datenströme ....................................................................
731
14
Die eXtensible Markup Language (XML) .............................................
843
15
Grafische Oberflächen mit Swing .........................................................
895
16
Grafikprogrammierung ......................................................................... 1069
17
Netzwerkprogrammierung ................................................................... 1143
18
Verteilte Programmierung mit RMI
und Web-Services ................................................................................ 1205
19
JavaServer Pages und Servlets ............................................................. 1229
20
Applets ................................................................................................. 1267
21
Midlets und die Java ME ...................................................................... 1281
22
Datenbankmanagement mit JDBC ....................................................... 1289
23
Reflection und Annotationen ............................................................... 1339
24
Logging und Monitoring ...................................................................... 1385
25
Sicherheitskonzepte ............................................................................. 1401
26
Java Native Interface (JNI) ................................................................... 1423
27
Dienstprogramme für die Java-Umgebung .......................................... 1435
A
Die Begleit-DVD ................................................................................... 1455
Inhalt
1
Vorwort ...............................................................................................................
39
Java ist auch eine Sprache ...................................................................
55
1.1
1.2
1.3
55
55
57
57
58
59
59
60
61
61
62
62
63
64
64
65
65
66
66
66
68
68
68
70
70
71
72
72
73
73
74
74
75
75
76
78
1.4
1.5
1.6
1.7
1.8
Der erste Kontakt .....................................................................................
Historischer Hintergrund ..........................................................................
Eigenschaften von Java .............................................................................
1.3.1
Bytecode und die virtuelle Maschine .........................................
1.3.2
Objektorientierung in Java .........................................................
1.3.3
Java-Security-Modell .................................................................
1.3.4
Zeiger und Referenzen ...............................................................
1.3.5
Bring den Müll raus, Garbage-Collector! ....................................
1.3.6
Ausnahmebehandlung ...............................................................
1.3.7
Kein Präprozessor für Textersetzungen .......................................
1.3.8
Keine überladenen Operatoren ..................................................
1.3.9
Java als Sprache, Laufzeitumgebung und Bibliothek ...................
1.3.10 Wofür sich Java nicht eignet ......................................................
1.3.11 Java im Vergleich zu anderen Sprachen ......................................
1.3.12 Java ist Open Source ..................................................................
Die Rolle von Java im Web .......................................................................
1.4.1
Vollwertige Applikationen statt Applets .....................................
Die Java Platform Standard Edition (Java SE) .............................................
1.5.1
JDK und JRE ..............................................................................
1.5.2
Java-Versionen ..........................................................................
1.5.3
Java für die Kleinen ....................................................................
1.5.4
Java für die Großen ....................................................................
1.5.5
Installationsanleitung für Java SE ...............................................
Das erste Programm compilieren und testen .............................................
1.6.1
Ein Quadratzahlen-Programm ....................................................
1.6.2
Der Compilerlauf .......................................................................
1.6.3
Die Laufzeitumgebung ...............................................................
1.6.4
Häufige Compiler- und Interpreterprobleme ..............................
Entwicklungsumgebungen im Allgemeinen ...............................................
1.7.1
Die Entwicklungsumgebung Eclipse ...........................................
1.7.2
NetBeans von Sun .....................................................................
1.7.3
Ein Wort zu Microsoft, Java und zu J++ ......................................
Eclipse im Speziellen ................................................................................
1.8.1
Eclipse starten ...........................................................................
1.8.2
Das erste Projekt anlegen ..........................................................
1.8.3
Eine Klasse hinzufügen ..............................................................
5
Inhalt
1.8.4
Übersetzen und Ausführen .........................................................
1.8.5
JDK statt JRE .............................................................................
1.8.6
Start eines Programms ohne Speicheraufforderung .....................
1.8.7
Projekt einfügen oder Workspace für die Aufgaben wechseln ....
1.8.8
Plugins für Eclipse ......................................................................
1.8.9
Eclipse Web Tools Platform (WTP) .............................................
Zum Weiterlesen ......................................................................................
79
80
80
81
82
82
83
Sprachbeschreibung ............................................................................
85
1.9
2
2.1
2.2
2.3
2.4
6
Elemente der Programmiersprache Java ....................................................
2.1.1
Textkodierung durch Unicode-Zeichen .......................................
2.1.2
Literale ......................................................................................
2.1.3
Bezeichner .................................................................................
2.1.4
Reservierte Schlüsselwörter ........................................................
2.1.5
Token ........................................................................................
2.1.6
Kommentare ..............................................................................
Anweisungen formen Programme .............................................................
2.2.1
Anweisungen .............................................................................
2.2.2
Eine Klasse bildet den Rahmen ..................................................
2.2.3
Die Reise beginnt am main() ......................................................
2.2.4
Programme übersetzen und starten ............................................
2.2.5
Funktionsaufrufe als Ausdrücke und Anweisungen .....................
2.2.6
print(), println() und printf() für Bildschirmausgaben ..................
2.2.7
Modifizierer ...............................................................................
2.2.8
Anweisungen und Blöcke ...........................................................
Datentypen ..............................................................................................
2.3.1
Primitive Datentypen im Überblick ............................................
2.3.2
Wahrheitswerte .........................................................................
2.3.3
Variablendeklarationen ..............................................................
2.3.4
Ganzzahlige Datentypen ............................................................
2.3.5
Die Fließkommazahlen float und double ....................................
2.3.6
Alphanumerische Zeichen ..........................................................
Ausdrücke, Operanden und Operatoren ...................................................
2.4.1
Zuweisungsoperator ..................................................................
2.4.2
Arithmetische Operatoren .........................................................
2.4.3
Unäres Minus und Plus ..............................................................
2.4.4
Zuweisung mit Operation ..........................................................
2.4.5
Präfix- oder Postfix-Inkrement und -Dekrement .........................
2.4.6
Die relationalen Operatoren und die Gleichheitsoperatoren .......
2.4.7
Logische Operatoren Und, Oder, Xor, Nicht ..............................
2.4.8
Rang der Operatoren in der Auswertungsreihenfolge .................
2.4.9
Die Typanpassung (das Casting) .................................................
85
85
88
88
89
90
91
92
92
93
94
95
95
95
98
99
100
100
102
102
106
108
109
110
111
112
115
115
116
118
119
120
122
Inhalt
2.5
2.6
2.7
2.8
2.9
2.10
3
2.4.10 Überladenes Plus für Strings .......................................................
2.4.11 Was C(++)-Programmierer vermissen könnten ...........................
Bedingte Anweisungen oder Fallunterscheidungen ...................................
2.5.1
Die if-Anweisung .......................................................................
2.5.2
Die Alternative mit einer if/else-Anweisung wählen ...................
2.5.3
Die switch-Anweisung bietet die Alternative .............................
Schleifen ..................................................................................................
2.6.1
Die while-Schleife ......................................................................
2.6.2
Schleifenbedingungen und Vergleiche mit == ............................
2.6.3
Die do-while-Schleife ................................................................
2.6.4
Die for-Schleife ..........................................................................
2.6.5
Ausbruch planen mit break und Wiedereinstieg mit continue ....
2.6.6
break und continue mit Sprungmarken ......................................
Methoden einer Klasse .............................................................................
2.7.1
Bestandteil einer Funktion .........................................................
2.7.2
Beschreibungen in der Java-API .................................................
2.7.3
Aufruf einer Methode ................................................................
2.7.4
Methoden ohne Parameter ........................................................
2.7.5
Statische Funktionen (Klassenmethoden) ...................................
2.7.6
Parameter, Argument und Wertübergabe ..................................
2.7.7
Methoden vorzeitig mit return beenden ....................................
2.7.8
Nicht erreichbarer Quellcode bei Funktionen .............................
2.7.9
Rückgabewerte ..........................................................................
2.7.10 Methoden überladen .................................................................
2.7.11 Vorgegebener Wert für nicht aufgeführte Argumente ................
2.7.12 Finale lokale Variablen ...............................................................
2.7.13 Rekursive Funktionen ................................................................
2.7.14 Die Türme von Hanoi .................................................................
Weitere Operatoren .................................................................................
2.8.1
Bits und Bytes ............................................................................
2.8.2
Operationen auf Bit-Ebene ........................................................
2.8.3
Die Verschiebeoperatoren .........................................................
2.8.4
Ein Bit setzen, löschen, umdrehen und testen ............................
2.8.5
Bit-Funktionen der Integer- und Long-Klasse .............................
2.8.6
Der Bedingungsoperator ............................................................
Einfache Benutzereingaben .......................................................................
Zum Weiterlesen ......................................................................................
127
128
128
129
130
133
136
136
137
138
140
143
146
147
148
148
150
150
151
152
153
154
154
158
160
160
162
164
166
166
167
169
171
171
172
174
175
Klassen und Objekte ........................................................................... 177
3.1
Objektorientierte Programmierung ........................................................... 177
3.1.1
Warum überhaupt OOP? ........................................................... 177
3.1.2
Wiederverwertbarkeit ................................................................ 178
7
Inhalt
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
8
Eigenschaften einer Klasse ........................................................................
3.2.1
Die Klasse Point .........................................................................
Die UML (Unified Modeling Language) .....................................................
3.3.1
Hintergrund und Geschichte zur UML ........................................
3.3.2
Wichtige Diagrammtypen der UML ............................................
Neue Objekte erzeugen ............................................................................
3.4.1
Anlegen eines Exemplars einer Klasse mit dem new-Operator ....
3.4.2
Deklarieren von Referenzvariablen .............................................
3.4.3
Zugriff auf Variablen und Methoden mit dem ».« .......................
3.4.4
Konstruktoren nutzen ................................................................
3.4.5
Die API-Dokumentation ............................................................
Import und Pakete ...................................................................................
Mit Referenzen arbeiten ...........................................................................
3.6.1
Die null-Referenz .......................................................................
3.6.2
Zuweisungen bei Referenzen .....................................................
3.6.3
Funktionen mit nicht-primitiven Parametern ..............................
Identität und Gleichheit ...........................................................................
3.7.1
Identität von Objekten ..............................................................
3.7.2
Gleichheit und die Methode equals() .........................................
Wrapper-Klassen und Autoboxing ............................................................
3.8.1
Die Basisklasse Number für numerische Wrapper-Objekte .........
3.8.2
Die Klasse Integer ......................................................................
3.8.3
Unterschiedliche Ausgabeformate ..............................................
3.8.4
Autoboxing: Boxing und Unboxing ............................................
3.8.5
Die Boolean-Klasse ....................................................................
3.8.6
Die Klassen Double und Float für Fließkommazahlen .................
Arrays .......................................................................................................
3.9.1
Deklaration von Arrays ..............................................................
3.9.2
Arrays mit Inhalt ........................................................................
3.9.3
Die Länge eines Arrays über das Attribut length .........................
3.9.4
Zugriff auf die Elemente über den Index ....................................
3.9.5
Array-Objekte erzeugen .............................................................
3.9.6
Fehler bei Arrays ........................................................................
3.9.7
Vorinitialisierte Arrays ................................................................
3.9.8
Die erweiterte for-Schleife .........................................................
3.9.9
Arrays mit nicht-primitiven Elementen .......................................
3.9.10 Mehrdimensionale Arrays ..........................................................
3.9.11 Die Wahrheit über die Array-Initialisierung ................................
3.9.12 Mehrere Rückgabewerte ............................................................
3.9.13 Methode mit variabler Argumentanzahl (Vararg) ........................
3.9.14 Klonen kann sich lohnen – Arrays vermehren .............................
3.9.15 Feldinhalte kopieren ..................................................................
3.9.16 Die Klasse Arrays zum Vergleichen, Füllen und Suchen ..............
179
179
180
180
181
181
182
183
183
186
186
187
188
188
190
191
193
193
193
195
197
198
199
200
202
203
204
205
205
206
206
207
209
210
211
212
213
215
216
217
218
219
220
Inhalt
3.10
3.11
3.12
4
Der Einstiegspunkt für das Laufzeitsystem main() ......................................
3.10.1 Kommandozeilen-Argumente verarbeiten ..................................
3.10.2 Der Rückgabewert von main() und System.exit() ........................
Eigene Pakete schnüren ............................................................................
3.11.1 Die package-Anweisung ............................................................
3.11.2 Importieren von Klassen mit import ...........................................
3.11.3 Hierarchische Strukturen und das Default-Package .....................
3.11.4 Paketnamen ...............................................................................
3.11.5 Klassen mit gleichen Namen in unterschiedlichen Paketen .........
3.11.6 Statisches Import .......................................................................
3.11.7 Eine Verzeichnisstruktur für eigene Projekte ..............................
Zum Weiterlesen ......................................................................................
227
227
228
228
229
229
229
230
231
231
232
232
Der Umgang mit Zeichenketten .......................................................... 233
4.1
4.2
4.3
4.4
4.5
4.6
Einzelne Zeichen mit der Character-Klasse behandeln ...............................
Strings und deren Anwendung .................................................................
4.2.1
String-Literale als String-Objekte für konstante Zeichenketten ...
4.2.2
String-Länge und Test auf Leerstring ..........................................
4.2.3
Nach enthaltenen Zeichen und Zeichenfolgen suchen ................
4.2.4
Gut, dass wir verglichen haben ..................................................
4.2.5
String-Teile extrahieren ..............................................................
4.2.6
Strings anhängen, Groß-/Kleinschreibung und Leerraum ............
4.2.7
Suchen und ersetzen ..................................................................
4.2.8
String-Objekte mit Konstruktoren neu anlegen ..........................
Konvertieren zwischen Primitiven und Strings ..........................................
4.3.1
Unterschiedliche Typen in Zeichenketten konvertieren ..............
4.3.2
String in primitives Element konvertieren ...................................
Veränderbare Zeichenketten mit StringBuffer/StringBuilder ......................
4.4.1
Anlegen von StringBuffer/StringBuilder-Objekten ......................
4.4.2
Die Länge eines StringBuffer/-Builder-Objekts ...........................
4.4.3
Daten anhängen ........................................................................
4.4.4
Zeichen(folgen) setzen, erfragen, löschen und umdrehen ...........
4.4.5
Vergleichen von String/StringBuffer/StringBuilder ......................
4.4.6
hashCode() bei StringBuffer/StringBuilder ..................................
Sprachabhängiges Vergleichen und Normalisierung ..................................
4.5.1
Die Klasse Collator .....................................................................
4.5.2
Effiziente interne Speicherung für die Sortierung ........................
4.5.3
Normalisierung ..........................................................................
Reguläre Ausdrücke ..................................................................................
4.6.1
Die Klassen Pattern und Matcher ...............................................
4.6.2
Mit MatchResult alle Ergebnisse einsammeln .............................
233
234
236
238
238
240
242
244
246
248
250
250
251
252
252
253
254
255
256
257
257
258
260
262
262
262
264
9
Inhalt
4.7
4.8
4.9
4.10
5
266
266
267
268
273
275
278
278
279
279
280
281
281
284
285
287
289
Mathematisches .................................................................................. 291
5.1
5.2
5.3
5.4
5.5
5.6
10
Zerlegen von Zeichenketten ......................................................................
4.7.1
Splitten von Zeichenketten mit split() ........................................
4.7.2
split() in Pattern .........................................................................
4.7.3
Die Klasse Scanner .....................................................................
4.7.4
StringTokenizer ..........................................................................
4.7.5
BreakIterator als Zeichen-, Wort-, Zeilen- und Satztrenner .........
Zeichenkodierungen und Base64 ..............................................................
4.8.1
Über die Klasse String Kodierungen vornehmen .........................
4.8.2
Konvertieren mit OutputStreamWriter-Klassen ..........................
4.8.3
Das Paket java.nio.charset .........................................................
4.8.4
Base64-Kodierung .....................................................................
Formatieren von Ausgaben .......................................................................
4.9.1
Formatieren mit format() aus String ...........................................
4.9.2
Die Format-Klassen im Überblick ...............................................
4.9.3
Zahlen, Prozente und Währungen mit NumberFormat und
DecimalFormat formatieren .......................................................
4.9.4
Ausgaben mit MessageFormat formatieren ................................
Zum Weiterlesen ......................................................................................
Repräsentation ganzer Zahlen – das Zweierkomplement ...........................
Fließkommaarithmetik in Java ...................................................................
5.2.1
Mantisse und Exponent .............................................................
5.2.2
Spezialwerte Unendlich, Null, NaN ............................................
Wertebereich eines Typs und Überlaufkontrolle ........................................
5.3.1
Behandlung des Überlaufs ..........................................................
Die Eigenschaften der Klasse Math ...........................................................
5.4.1
Attribute ....................................................................................
5.4.2
Absolutwerte und Maximum/Minimum .....................................
5.4.3
Winkelfunktionen ......................................................................
5.4.4
Runden von Werten ..................................................................
5.4.5
Wurzel und Exponentialfunktionen ............................................
5.4.6
Der Logarithmus ........................................................................
5.4.7
Rest der ganzzahligen Division ...................................................
5.4.8
Zufallszahlen ..............................................................................
Mathe bitte strikt .....................................................................................
5.5.1
Strikt Fließkomma mit strictfp ....................................................
5.5.2
Die Klassen Math und StrictMath ..............................................
Die Random-Klasse ..................................................................................
5.6.1
Objekte aufbauen und der Seed .................................................
5.6.2
Zufallszahlen erzeugen ...............................................................
5.6.3
Pseudo-Zufallszahlen in der Normalverteilung ............................
291
291
292
293
295
296
297
297
298
299
300
302
303
303
304
305
305
305
306
306
307
307
Inhalt
5.7
5.8
6
Große Zahlen ............................................................................................
5.7.1
Die Klasse BigInteger .................................................................
5.7.2
Funktionen von BigInteger .........................................................
5.7.3
Ganz lange Fakultäten ...............................................................
5.7.4
Große Fließkommazahlen mit BigDecimal ..................................
5.7.5
Mit MathContext komfortabel die Rechengenauigkeit setzen ....
Zum Weiterlesen ......................................................................................
308
308
310
312
313
315
317
Eigene Klassen schreiben .................................................................... 319
6.1
6.2
6.3
6.4
6.5
Eigene Klassen mit Eigenschaften deklarieren ...........................................
6.1.1
Attribute deklarieren .................................................................
6.1.2
Methoden deklarieren ...............................................................
6.1.3
Die this-Referenz .......................................................................
Privatsphäre und Sichtbarkeit ...................................................................
6.2.1
Für die Öffentlichkeit: public .....................................................
6.2.2
Paketsichtbar .............................................................................
6.2.3
Kein Public Viewing – Passwörter sind privat .............................
6.2.4
Wieso nicht freie Methoden und Variablen für alle? ...................
6.2.5
Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht .......
6.2.6
Zugriffsmethoden für Attribute deklarieren ................................
6.2.7
Setter und Getter nach der JavaBeans-Spezifikation ...................
Statische Methoden und statische Attribute .............................................
6.3.1
Warum statische Eigenschaften sinnvoll sind ..............................
6.3.2
Statische Eigenschaften mit static ..............................................
6.3.3
Statische Eigenschaften über Referenzen nutzen? .......................
6.3.4
Warum die Groß- und Kleinschreibung wichtig ist .....................
6.3.5
Statische Eigenschaften und Objekteigenschaften ......................
6.3.6
Statische Variablen zum Datenaustausch ....................................
6.3.7
Statische Blöcke als Klasseninitialisierer .....................................
Konstanten und Aufzählungen ..................................................................
6.4.1
Konstanten über öffentliche statische finale Variablen ...............
6.4.2
Eincompilierte Belegungen der Klassenvariablen ........................
6.4.3
Typ(un)sicherere Aufzählungen ..................................................
6.4.4
Aufzählungen mit enum .............................................................
Objekte anlegen und zerstören .................................................................
6.5.1
Konstruktoren schreiben ............................................................
6.5.2
Der Standard-Konstruktor ..........................................................
6.5.3
Parametrisierte und überladene Konstruktoren ..........................
6.5.4
Konstruktor nimmt ein Objekt vom eigenen Typ an
(Copy-Konstruktor) ....................................................................
6.5.5
Einen anderen Konstruktor der gleichen Klasse aufrufen ............
6.5.6
Initialisierung der Objekt- und Klassenvariablen .........................
319
319
320
322
324
324
324
325
327
327
328
329
330
331
331
332
333
333
334
335
336
337
337
338
339
342
342
343
344
346
347
350
11
Inhalt
6.6
6.7
6.8
6.9
6.10
12
6.5.7
Finale Werte im Konstruktor und in statischen Blöcken setzen ...
6.5.8
Exemplarinitialisierer (Instanzinitialisierer) ..................................
6.5.9
Ihr fehlt uns nicht – der Garbage-Collector .................................
6.5.10 Implizit erzeugte String-Objekte ................................................
6.5.11 Private Konstruktoren, Utility-Klassen, Singleton, Fabriken ........
Assoziationen zwischen Objekten .............................................................
6.6.1
Unidirektionale 1:1-Beziehung ...................................................
6.6.2
Bidirektionale 1:1-Beziehungen .................................................
6.6.3
Unidirektionale 1:n-Beziehung ...................................................
Vererbung ................................................................................................
6.7.1
Vererbung in Java ......................................................................
6.7.2
Spielobjekte modelliert ..............................................................
6.7.3
Einfach- und Mehrfachvererbung ...............................................
6.7.4
Sichtbarkeit protected ...............................................................
6.7.5
Konstruktoren in der Vererbung und super ................................
6.7.6
Automatische und explizite Typanpassung .................................
6.7.7
Das Substitutionsprinzip ............................................................
6.7.8
Typen mit dem binären Operator instanceof testen ....................
6.7.9
Methoden überschreiben ...........................................................
6.7.10 Mit super an die Eltern ..............................................................
6.7.11 Kovariante Rückgabetypen ........................................................
6.7.12 Array-Typen und Kovarianz ........................................................
6.7.13 Zusammenfassung zur Sichtbarkeit .............................................
Dynamisches Binden ................................................................................
6.8.1
Unpolymorph bei privaten, statischen und finalen Methoden ....
6.8.2
Polymorphie bei Konstruktoraufrufen ........................................
6.8.3
Finale Klassen ............................................................................
6.8.4
Nicht überschreibbare (finale) Methoden ...................................
Abstrakte Klassen und abstrakte Methoden ..............................................
6.9.1
Abstrakte Klassen ......................................................................
6.9.2
Abstrakte Methoden ..................................................................
Schnittstellen ............................................................................................
6.10.1 Deklarieren von Schnittstellen ...................................................
6.10.2 Implementieren von Schnittstellen .............................................
6.10.3 Markierungsschnittstellen ..........................................................
6.10.4 Ein Polymorphie-Beispiel mit Schnittstellen ...............................
6.10.5 Die Mehrfachvererbung bei Schnittstellen ..................................
6.10.6 Keine Kollisionsgefahr bei Mehrfachvererbung ...........................
6.10.7 Erweitern von Interfaces – Subinterfaces ....................................
6.10.8 Vererbte Konstanten bei Schnittstellen ......................................
6.10.9 Schnittstellenmethoden, die nicht implementiert werden
müssen ......................................................................................
6.10.10 Abstrakte Klassen und Schnittstellen im Vergleich .....................
352
353
355
356
357
359
360
360
361
363
363
364
365
366
367
371
373
375
376
378
380
381
382
383
386
387
389
390
391
391
392
395
395
396
398
398
399
402
403
404
406
406
Inhalt
6.11
6.12
6.13
6.14
7
Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen ....................
6.11.1 Statische innere Klassen und Schnittstellen ................................
6.11.2 Mitglieds- oder Elementklassen .................................................
6.11.3 Lokale Klassen ...........................................................................
6.11.4 Anonyme innere Klassen ............................................................
6.11.5 this und Vererbung ....................................................................
Generische Datentypen ............................................................................
6.12.1 Einfache Klassenschablonen .......................................................
6.12.2 Einfache Methodenschablonen ..................................................
6.12.3 Umsetzen der Generics, Typlöschung und Raw-Types ................
6.12.4 Einschränken der Typen .............................................................
6.12.5 Generics und Vererbung, Invarianz ............................................
6.12.6 Wildcards ..................................................................................
Die Spezial-Oberklasse Enum ...................................................................
6.13.1 Methoden auf Enum-Objekten ..................................................
6.13.2 enum mit eigenen Konstruktoren und Methoden ......................
Dokumentationskommentare mit JavaDoc ................................................
6.14.1 Einen Dokumentationskommentar setzen ..................................
6.14.2 Mit javadoc eine Dokumentation erstellen .................................
6.14.3 HTML-Tags in Dokumentationskommentaren ............................
6.14.4 Generierte Dateien ....................................................................
6.14.5 Dokumentationskommentare im Überblick ................................
6.14.6 JavaDoc und Doclets .................................................................
6.14.7 Veraltete (deprecated) Klassen, Konstruktoren und Methoden ....
407
408
409
413
413
416
418
419
420
420
422
424
425
426
426
428
430
431
433
433
433
434
435
436
Angewandte Objektorientierung ........................................................ 439
7.1
7.2
7.3
Schnittstellen in der Anwendung ..............................................................
7.1.1
CharSequence als Beispiel einer Schnittstelle .............................
7.1.2
Die Schnittstelle Iterable ............................................................
7.1.3
Funktionszeiger .........................................................................
7.1.4
Implementierung einer verketteten Liste ....................................
Design-Pattern (Entwurfsmuster) ..............................................................
7.2.1
Design-Pattern ..........................................................................
7.2.2
Das Beobachter-Pattern (Observer/Observable) .........................
7.2.3
Ereignisse über Listener .............................................................
7.2.4
Multicast und Unicast ................................................................
JavaBean ..................................................................................................
7.3.1
Properties (Eigenschaften) .........................................................
7.3.2
Einfache Eigenschaften ..............................................................
7.3.3
Indizierte Eigenschaften .............................................................
7.3.4
Gebundene Eigenschaften ..........................................................
7.3.5
Veto-Eigenschaften – dagegen! ..................................................
439
439
441
443
445
446
447
448
451
454
455
455
456
456
457
459
13
Inhalt
8
Exceptions ........................................................................................... 465
8.1
8.2
8.3
8.4
8.5
9
465
465
466
468
468
469
472
475
476
477
477
478
479
480
481
481
483
484
485
486
486
487
488
489
490
Die Funktionsbibliothek ...................................................................... 491
9.1
9.2
9.3
14
Problembereiche einzäunen ......................................................................
8.1.1
Exceptions in Java mit try und catch ..........................................
8.1.2
Eine Datei mit RandomAccessFile auslesen ................................
8.1.3
Ablauf einer Ausnahmesituation ................................................
8.1.4
Wiederholung abgebrochener Bereiche .....................................
8.1.5
throws im Methodenkopf angeben ............................................
8.1.6
Abschlussbehandlung mit finally ................................................
8.1.7
Nicht erreichbare catch-Klauseln ...............................................
Die Klassenhierarchie der Fehler ...............................................................
8.2.1
Die Exception-Hierarchie ...........................................................
8.2.2
Oberausnahmen auffangen ........................................................
8.2.3
Alles geht als Exception durch ...................................................
8.2.4
RuntimeException muss nicht aufgefangen werden ....................
8.2.5
Harte Fehler: Error .....................................................................
Auslösen eigener Exceptions .....................................................................
8.3.1
Mit throw Ausnahmen auslösen .................................................
8.3.2
Neue Exception-Klassen deklarieren ..........................................
8.3.3
Abfangen und Weiterleiten ........................................................
8.3.4
Geschachtelte Ausnahmen .........................................................
8.3.5
Rückgabewerte bei ausgelösten Ausnahmen ..............................
Der Stack-Trace ........................................................................................
8.4.1
Stack-Trace erfragen ..................................................................
Assertions .................................................................................................
8.5.1
Assertions in eigenen Programmen nutzen .................................
8.5.2
Assertions aktivieren ..................................................................
Die Java-Klassenphilosophie .....................................................................
9.1.1
Übersicht über die Pakete der Standardbibliothek ......................
Object ist die Mutter aller Oberklassen .....................................................
9.2.1
Klassenobjekte ...........................................................................
9.2.2
Objektidentifikation mit toString() .............................................
9.2.3
Objektgleichheit mit equals() und Identität ................................
9.2.4
Klonen eines Objekts mit clone() ...............................................
9.2.5
Hashcodes über hashCode() liefern ............................................
9.2.6
Aufräumen mit finalize() ............................................................
9.2.7
Synchronisation .........................................................................
Klassenlader (Class Loader) .......................................................................
9.3.1
Woher die kleinen Klassen kommen ..........................................
9.3.2
Setzen des Klassenpfades ...........................................................
491
491
498
498
498
500
504
507
510
512
512
513
514
Inhalt
9.4
9.5
9.6
9.7
9.8
9.9
9.3.3
Die wichtigsten drei Typen von Klassenladern ............................
9.3.4
Der java.lang.ClassLoader ..........................................................
9.3.5
Hot Deployment mit dem URL-ClassLoader ...............................
9.3.6
Das jre/lib/endorsed-Verzeichnis ...............................................
9.3.7
getContextClassLoader() vom Thread .........................................
Die Utility-Klasse System und Properties ..................................................
9.4.1
Systemeigenschaften der Java-Umgebung ..................................
9.4.2
line.separator .............................................................................
9.4.3
Browser-Version abfragen ..........................................................
9.4.4
Property von der Konsole aus setzen .........................................
9.4.5
Umgebungsvariablen des Betriebssystems ..................................
9.4.6
Einfache Zeitmessung und Profiling ............................................
Ausführen externer Programme und Skripte .............................................
9.5.1
ProcessBuilder und Prozesskontrolle mit Process .......................
9.5.2
Einen Browser/E-Mail-Client/Editor aufrufen .............................
9.5.3
Ausführen von Skripten .............................................................
Benutzereinstellungen ..............................................................................
9.6.1
Benutzereinstellungen in Windows-Registry oder
XML-Dokumenten .....................................................................
9.6.2
Einträge einfügen, auslesen und löschen ....................................
9.6.3
Auslesen der Daten und Schreiben in anderem Format ..............
9.6.4
Auf Ereignisse horchen ..............................................................
9.6.5
Zugriff auf die gesamte Windows-Registry .................................
Musik abspielen .......................................................................................
9.7.1
Die Arbeit mit AudioClip ...........................................................
9.7.2
Java Sound API ..........................................................................
Annotationen ...........................................................................................
9.8.1
Annotationstypen @Override, @Deprecated,
@SuppressWarnings ..................................................................
9.8.2
Common Annotations ................................................................
9.8.3
Annotationen für Web-Services .................................................
9.8.4
Annotationen für XML-Mapping ................................................
Zum Weiterlesen ......................................................................................
515
515
517
519
520
520
521
522
523
523
524
525
526
526
529
530
532
532
534
536
536
536
537
537
538
539
540
541
542
542
542
10 Threads und nebenläufige Programmierung ....................................... 543
10.1
10.2
Nebenläufigkeit ........................................................................................
10.1.1 Threads und Prozesse ................................................................
10.1.2 Wie parallele Programme die Geschwindigkeit steigern
können ......................................................................................
10.1.3 Was Java für Nebenläufigkeit alles bietet ...................................
Threads erzeugen .....................................................................................
10.2.1 Threads über die Schnittstelle Runnable implementieren ...........
543
543
544
546
546
546
15
Inhalt
10.3
10.4
10.5
10.6
16
10.2.2 Thread mit Runnable starten ......................................................
10.2.3 Der Name eines Threads ............................................................
10.2.4 Die Klasse Thread erweitern ......................................................
10.2.5 Wer bin ich? ..............................................................................
Die Zustände eines Threads ......................................................................
10.3.1 Threads schlafen ........................................................................
10.3.2 Mit yield() auf Rechenzeit verzichten .........................................
10.3.3 Das Ende eines Threads .............................................................
10.3.4 UncaughtExceptionHandler für unbehandelte Ausnahmen .........
10.3.5 Einen Thread höflich mit Interrupt beenden ...............................
10.3.6 Der stop() von außen und die Rettung mit ThreadDeath ............
10.3.7 Ein Rendezvous mit join() ..........................................................
10.3.8 Barrier und Austausch mit Exchanger .........................................
10.3.9 Arbeit niederlegen und wieder aufnehmen ................................
10.3.10 Priorität .....................................................................................
10.3.11 Der Thread ist ein Dämon ..........................................................
Der Ausführer (Executor) kommt ..............................................................
10.4.1 Die Schnittstelle Executor ..........................................................
10.4.2 Die Thread-Pools .......................................................................
10.4.3 Threads mit Rückgabe über Callable ..........................................
10.4.4 Mehrere Callable abarbeiten ......................................................
10.4.5 Mit ScheduledExecutorService wiederholende Ausgaben
und Zeitsteuerungen ..................................................................
Synchronisation über kritische Abschnitte .................................................
10.5.1 Gemeinsam genutzte Daten .......................................................
10.5.2 Probleme beim gemeinsamen Zugriff und kritische Abschnitte ...
10.5.3 Punkte parallel initialisieren .......................................................
10.5.4 i++ sieht atomar aus, ist es aber nicht ........................................
10.5.5 Kritische Abschnitte schützen ....................................................
10.5.6 Schützen mit ReentrantLock ......................................................
10.5.7 Synchronisieren mit synchronized ..............................................
10.5.8 Synchronized-Methoden der Klasse StringBuffer ........................
10.5.9 Mit synchronized synchronisierte Blöcke ....................................
10.5.10 Dann machen wir doch gleich alles synchronisiert! .....................
10.5.11 Lock-Freigabe im Fall von Exceptions .........................................
10.5.12 Mit synchronized nachträglich synchronisieren ..........................
10.5.13 Monitore sind reentrant – gut für die Geschwindigkeit ...............
10.5.14 Synchronisierte Methodenaufrufe zusammenfassen ....................
10.5.15 Deadlocks ..................................................................................
Synchronisation über Warten und Benachrichtigen ...................................
10.6.1 Die Schnittstelle Condition ........................................................
10.6.2 Beispiel: Erzeuger-Verbraucher-Programm .................................
547
549
550
552
553
553
555
555
556
557
559
560
562
563
563
564
566
566
568
569
572
572
573
573
573
574
576
577
578
582
583
584
585
586
587
588
589
590
592
593
596
Inhalt
10.6.3 Warten mit wait() und Aufwecken mit notify() ...........................
10.6.4 Falls der Lock fehlt: IllegalMonitorStateException ......................
10.6.5 Semaphor ..................................................................................
10.7 Atomare Operationen und frische Werte mit volatile ................................
10.7.1 Der Modifizierer volatile bei Objekt-/Klassenvariablen ...............
10.7.2 Das Paket java.util.concurrent.atomic ........................................
10.8 Mit dem Thread verbundene Variablen ....................................................
10.8.1 ThreadLocal ...............................................................................
10.8.2 InheritableThreadLocal ..............................................................
10.9 Gruppen von Threads in einer Thread-Gruppe ..........................................
10.9.1 Aktive Threads in der Umgebung ...............................................
10.9.2 Etwas über die aktuelle Thread-Gruppe herausfinden ................
10.9.3 Threads in einer Thread-Gruppe anlegen ...................................
10.9.4 Methoden von Thread und ThreadGroup im Vergleich ...............
10.10 Zeitgesteuerte Abläufe .............................................................................
10.10.1 Die Klassen Timer und TimerTask ..............................................
10.10.2 Job-Scheduler Quartz ................................................................
10.11 Einen Abbruch der virtuellen Maschine erkennen .....................................
10.12 Zum Weiterlesen ......................................................................................
600
601
603
606
606
607
608
609
610
612
612
613
615
618
619
619
621
621
622
11 Raum und Zeit ..................................................................................... 623
11.1
11.2
11.3
11.4
11.5
11.6
11.7
11.8
Weltzeit ...................................................................................................
Wichtige Datum-Klassen im Überblick ......................................................
Sprachen der Länder .................................................................................
11.3.1 Sprachen und Regionen über Locale-Objekte .............................
Internationalisierung und Lokalisierung ....................................................
11.4.1 ResourceBundle-Objekte und Ressource-Dateien ......................
11.4.2 Ressource-Dateien zur Lokalisierung ..........................................
11.4.3 Die Klasse ResourceBundle ........................................................
11.4.4 Ladestrategie für ResourceBundle-Objekte ................................
Zeitzonen .................................................................................................
11.5.1 Zeitzonen durch die Klasse TimeZone repräsentieren .................
Die Klasse Date ........................................................................................
11.6.1 Objekte erzeugen und Methoden nutzen ...................................
Calendar und GregorianCalendar ..............................................................
11.7.1 Die abstrakte Klasse Calendar ....................................................
11.7.2 Der gregorianische Kalender ......................................................
11.7.3 Ostertage ...................................................................................
11.7.4 Abfragen und Setzen von Datumselementen ..............................
Formatieren und Parsen von Datumsangaben ...........................................
11.8.1 Ausgaben mit printf() .................................................................
11.8.2 Mit DateFormat und SimpleDateFormat formatieren .................
623
624
624
625
628
629
629
630
631
632
632
634
634
635
636
636
639
641
647
647
647
17
Inhalt
11.9
11.8.3 Parsen von Datumswerten ......................................................... 652
Zum Weiterlesen ...................................................................................... 654
12 Datenstrukturen und Algorithmen ..................................................... 655
12.1
12.2
12.3
12.4
12.5
12.6
18
Datenstrukturen und die Collection-API ...................................................
12.1.1 Designprinzip mit Schnittstellen, abstrakten Klassen,
konkreten Klassen ......................................................................
12.1.2 Die Basis-Schnittstellen Collection und Map ..............................
12.1.3 Das erste Programm mit Container-Klassen ................................
12.1.4 Die Schnittstelle Collection ........................................................
12.1.5 Schnittstellen, die Collection erweitern, und Map ......................
12.1.6 Konkrete Container-Klassen .......................................................
12.1.7 Welche Klasse nehmen? ............................................................
12.1.8 Generische Datentypen in der Collection-API ............................
12.1.9 Die Schnittstelle Iterable und das erweiterte for .........................
Mit einem Iterator durch die Daten wandern ...........................................
12.2.1 Die Schnittstellen Enumeration und Iterator ..............................
12.2.2 Iteratoren von Sammlungen und das erweiterte for ....................
12.2.3 Fail-Fast Iterator und die ConcurrentModificationException .......
Listen .......................................................................................................
12.3.1 ArrayList oder LinkedList? Speicherung im Feld oder in einer
verketteten Liste ........................................................................
12.3.2 Die Schnittstelle List ..................................................................
12.3.3 ArrayList ....................................................................................
12.3.4 LinkedList ..................................................................................
12.3.5 Der Feld-Adapter Arrays.asList() ................................................
12.3.6 toArray() von Collection verstehen – die Gefahr einer Falle
erkennen ...................................................................................
12.3.7 Primitive Elemente in den Collection-Datenstrukturen ...............
Vergleichen von Objekten ........................................................................
12.4.1 Die Schnittstellen Comparator und Comparable .........................
12.4.2 Algorithmen mit Such- und Sortiermöglichkeiten .......................
12.4.3 Den größten und kleinsten Wert einer Collection finden ............
12.4.4 Sortieren ....................................................................................
Mengen (Sets) ..........................................................................................
12.5.1 HashSet .....................................................................................
12.5.2 TreeSet – die Menge durch Bäume .............................................
12.5.3 LinkedHashSet ...........................................................................
Stack (Kellerspeicher, Stapel) ....................................................................
12.6.1 Die Methoden von Stack ...........................................................
12.6.2 Ein Stack ist ein Vector – aha! ....................................................
655
656
657
657
658
660
662
663
663
664
665
665
667
669
669
670
670
677
680
681
682
684
685
685
687
688
689
692
694
695
698
698
699
699
Inhalt
12.7
Queues (Schlangen) und Deques ..............................................................
12.7.1 Die Schnittstelle Queue .............................................................
12.7.2 Blockierende Queues und Prioritätswarteschlangen ...................
12.7.3 Deque-Klassen ...........................................................................
12.8 Assoziative Speicher .................................................................................
12.8.1 Die Klassen HashMap und TreeMap ..........................................
12.8.2 Einfügen und Abfragen der Datenstruktur ..................................
12.8.3 Die Bedeutung von equals(), hashCode() und
IdentityHashMap .......................................................................
12.8.4 Elemente im Assoziativspeicher müssen unveränderbar
bleiben ......................................................................................
12.8.5 Aufzählungen und Sichten auf den Assoziativspeicher ................
12.8.6 Der Gleichheitstest, Hash-Wert und Klon einer Hash-Tabelle .....
12.8.7 Die Arbeitsweise einer Hash-Tabelle ..........................................
12.8.8 Multi-Maps ...............................................................................
12.9 Die Properties-Klasse ...............................................................................
12.9.1 Properties setzen und lesen .......................................................
12.9.2 Properties verketten ..................................................................
12.9.3 Eigenschaften ausgeben .............................................................
12.9.4 Hierarchische Eigenschaften .......................................................
12.9.5 Properties speichern ..................................................................
12.9.6 Klassenbeziehungen: Properties und Hashtable ..........................
12.10 Algorithmen in Collections .......................................................................
12.10.1 Listenoperationen: Ersetzen, Kopieren, Füllen, Umdrehen,
Rotieren, Durchmischen ............................................................
12.10.2 Mit der Halbierungssuche nach Elementen fahnden ...................
12.10.3 Nicht-änderbare Datenstrukturen ..............................................
12.10.4 Häufigkeit eines Elements ..........................................................
12.10.5 nCopies() ...................................................................................
12.10.6 Singletons ..................................................................................
12.11 Synchronisation der Datenstrukturen ........................................................
12.11.1 Lock-Free-Algorithmen aus java.util.concurrent .........................
12.11.2 Wrapper zur Synchronisation .....................................................
12.11.3 CopyOnWriteArrayList und CopyOnWriteArraySet .....................
12.12 Die Klasse BitSet für Bitmengen ................................................................
12.12.1 Ein BitSet anlegen, füllen und erfragen .......................................
12.12.2 Mengenorientierte Operationen ................................................
12.12.3 Funktionsübersicht ....................................................................
12.12.4 Primzahlen in einem BitSet verwalten ........................................
700
700
701
702
702
702
704
707
709
709
712
712
715
715
715
715
717
717
717
719
719
720
721
723
723
723
724
725
725
726
727
727
727
728
729
730
19
Inhalt
13 Dateien und Datenströme ................................................................... 731
13.1
13.2
13.3
13.4
20
Datei und Verzeichnis ...............................................................................
13.1.1 Dateien und Verzeichnisse mit der Klasse File ............................
13.1.2 Verzeichnis oder Datei? Existiert es? ..........................................
13.1.3 Verzeichnis- und Dateieigenschaften/-attribute .........................
13.1.4 Wurzelverzeichnis, Laufwerksnamen, Plattenspeicher ................
13.1.5 Umbenennen und Verzeichnisse anlegen ...................................
13.1.6 Verzeichnisse listen und Dateien filtern ......................................
13.1.7 Dateien berühren, neue Dateien anlegen, temporäre Dateien ....
13.1.8 Dateien und Verzeichnisse löschen ............................................
13.1.9 Verzeichnisse nach Dateien iterativ durchsuchen .......................
13.1.10 URL- und URI-Objekte aus einem File-Objekt ableiten ..............
13.1.11 Mit Locking Dateien sperren ......................................................
13.1.12 Sicherheitsprüfung .....................................................................
13.1.13 Mime-Typen mit dem JavaBeans Activation Framework (JAF) ....
13.1.14 Zugriff auf SMB-Server mit jCIFS ................................................
Dateien mit wahlfreiem Zugriff .................................................................
13.2.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen ............
13.2.2 Aus dem RandomAccessFile lesen ..............................................
13.2.3 Schreiben mit RandomAccessFile ...............................................
13.2.4 Die Länge des RandomAccessFile ...............................................
13.2.5 Hin und her in der Datei ............................................................
13.2.6 Wahlfreier Zugriff und Pufferung mit Unified I/O .......................
Stream-Klassen und Reader/Writer am Beispiel von Dateien .....................
13.3.1 Mit dem FileWriter Texte in Dateien schreiben ..........................
13.3.2 Zeichen mit der Klasse FileReader lesen .....................................
13.3.3 Kopieren mit FileOutputStream und FileInputStream .................
13.3.4 Das FileDescriptor-Objekt ..........................................................
Basisklassen für die Ein-/Ausgabe .............................................................
13.4.1 Die abstrakten Basisklassen ........................................................
13.4.2 Übersicht über Ein-/Ausgabeklassen ..........................................
13.4.3 Die abstrakte Basisklasse OutputStream .....................................
13.4.4 Die Schnittstellen Closeable und Flushable ................................
13.4.5 Ein Datenschlucker ....................................................................
13.4.6 Die abstrakte Basisklasse InputStream ........................................
13.4.7 Ressourcen wie Grafiken aus dem Klassenpfad
und aus Jar-Archiven laden ........................................................
13.4.8 Ströme mit SequenceInputStream zusammensetzen ...................
13.4.9 Die abstrakte Basisklasse Writer .................................................
13.4.10 Die Schnittstelle Appendable .....................................................
13.4.11 Die abstrakte Basisklasse Reader ................................................
732
732
734
735
737
740
740
743
745
746
747
747
748
748
749
750
751
751
754
754
754
755
755
756
758
759
762
762
762
763
764
766
766
767
768
769
770
772
773
Inhalt
13.5
Formatierte Textausgaben ........................................................................
13.5.1 Die Klassen PrintWriter und PrintStream ...................................
13.5.2 System.out, System.err und System.in ........................................
13.5.3 Geschützte Passwort-Eingaben mit der Klasse Console ...............
13.6 Schreiben und Lesen aus Strings und Byte-Feldern ...................................
13.6.1 Mit dem StringWriter ein String-Objekt füllen ...........................
13.6.2 CharArrayWriter ........................................................................
13.6.3 StringReader und CharArrayReader ............................................
13.6.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben .............
13.6.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen ................
13.7 Datenströme filtern und verketten ............................................................
13.7.1 Streams als Filter verketten ........................................................
13.7.2 Gepufferte Ausgaben mit BufferedWriter und
BufferedOutputStream ...............................................................
13.7.3 Gepufferte Eingaben mit BufferedReader und
BufferedInputStream ..................................................................
13.7.4 LineNumberReader zählt automatisch Zeilen mit .......................
13.7.5 Daten mit der Klasse PushbackReader zurücklegen ....................
13.7.6 DataOutputStream/DataInputStream .........................................
13.7.7 Basisklassen für Filter .................................................................
13.7.8 Die Basisklasse FilterWriter ........................................................
13.7.9 Ein LowerCaseWriter .................................................................
13.7.10 Eingaben mit der Klasse FilterReader filtern ...............................
13.8 Vermittler zwischen Byte-Streams und Unicode-Strömen .........................
13.8.1 Datenkonvertierung durch den OutputStreamWriter .................
13.8.2 Automatische Konvertierungen mit dem InputStreamReader .....
13.9 Kommunikation zwischen Threads mit Pipes ............................................
13.9.1 PipedOutputStream und PipedInputStream ...............................
13.9.2 PipedWriter und PipedReader ...................................................
13.10 Datenkompression ...................................................................................
13.10.1 Java-Unterstützung beim Komprimieren und
Zusammenpacken ......................................................................
13.10.2 Datenströme komprimieren .......................................................
13.10.3 Zip-Archive ................................................................................
13.10.4 Jar-Archive ................................................................................
13.11 Prüfsummen .............................................................................................
13.11.1 Die Schnittstelle Checksum ........................................................
13.11.2 Die Klasse CRC32 ......................................................................
13.11.3 Die Adler32-Klasse ....................................................................
13.12 Persistente Objekte und Serialisierung ......................................................
13.12.1 Objekte mit der Standard-Serialisierung speichern und lesen .....
13.12.2 Zwei einfache Anwendungen der Serialisierung ..........................
13.12.3 Die Schnittstelle Serializable ......................................................
774
775
779
781
781
782
783
784
785
786
786
787
787
789
791
792
795
795
795
796
798
799
799
800
801
801
803
805
806
806
810
816
816
817
818
819
820
821
823
824
21
Inhalt
13.12.4 Nicht serialisierbare Attribute aussparen ....................................
13.12.5 Das Abspeichern selbst in die Hand nehmen ..............................
13.12.6 Tiefe Objektkopien ....................................................................
13.12.7 Versionenverwaltung und die SUID ...........................................
13.12.8 Wie die ArrayList serialisiert .......................................................
13.12.9 Probleme mit der Serialisierung .................................................
13.12.10 Serialisieren in XML-Dateien ......................................................
13.12.11 JavaBeans Persistence ................................................................
13.12.12 XStream .....................................................................................
13.13 Tokenizer .................................................................................................
13.13.1 StreamTokenizer ........................................................................
13.13.2 CSV-(Comma Separated Values-)Dateien verarbeiten .................
13.14 Zum Weiterlesen ......................................................................................
826
827
831
832
834
835
835
836
838
838
838
841
842
14 Die eXtensible Markup Language (XML) ............................................ 843
14.1
14.2
14.3
14.4
14.5
22
Auszeichnungssprachen ............................................................................
14.1.1 Die Standard Generalized Markup Language (SGML) .................
14.1.2 Extensible Markup Language (XML) ...........................................
Eigenschaften von XML-Dokumenten .......................................................
14.2.1 Elemente und Attribute .............................................................
14.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten ...
14.2.3 Schema – eine Alternative zu DTD .............................................
14.2.4 Namensraum (Namespace) ........................................................
14.2.5 XML-Applikationen ...................................................................
Die Java-APIs für XML ..............................................................................
14.3.1 Das Document Object Model (DOM) ........................................
14.3.2 Simple API for XML Parsing (SAX) ..............................................
14.3.3 Pull-API StAX ............................................................................
14.3.4 Java Document Object Model (JDOM) ......................................
14.3.5 JAXP als Java-Schnittstelle zu XML .............................................
14.3.6 DOM-Bäume einlesen mit JAXP .................................................
Serielle Verarbeitung mit StAX ..................................................................
14.4.1 Unterschiede der Verarbeitungsmodelle ....................................
14.4.2 XML-Dateien mit dem Cursor-Verfahren lesen ...........................
14.4.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten ................
14.4.4 Mit Filtern arbeiten ....................................................................
14.4.5 XML-Dokumente schreiben .......................................................
Serielle Verarbeitung von XML mit SAX ....................................................
14.5.1 Schnittstellen von SAX ...............................................................
14.5.2 SAX-Parser erzeugen ..................................................................
14.5.3 Die wichtigsten Methoden der Schnittstelle ContentHandler .....
14.5.4 ErrorHandler und EntityResolver ................................................
843
843
844
844
844
846
849
852
853
853
854
854
854
855
855
856
856
857
858
860
861
862
865
865
866
866
868
Inhalt
14.6
XML-Dateien mit JDOM verarbeiten ........................................................
14.6.1 JDOM beziehen .........................................................................
14.6.2 Paketübersicht ...........................................................................
14.6.3 Die Document-Klasse ................................................................
14.6.4 Eingaben aus der Datei lesen .....................................................
14.6.5 Das Dokument im XML-Format ausgeben ..................................
14.6.6 Der Dokumenttyp ......................................................................
14.6.7 Elemente ...................................................................................
14.6.8 Zugriff auf Elementinhalte ..........................................................
14.6.9 Liste mit Unterelementen erzeugen ...........................................
14.6.10 Neue Elemente einfügen und ändern ........................................
14.6.11 Attributinhalte lesen und ändern ..............................................
14.6.12 XPath .......................................................................................
14.7 Transformationen mit XSLT ......................................................................
14.7.1 Templates und XPath als Kernelemente von XSLT ......................
14.7.2 Umwandlung von XML-Dateien mit JDOM und JAXP ................
14.8 Java Architecture for XML Binding (JAXB) .................................................
14.8.1 Beans für JAXB aufbauen ...........................................................
14.8.2 JAXBContext und die Marshaller/Unmarshaller ..........................
14.9 HTML-Dokumente einlesen ......................................................................
14.10 Zum Weiterlesen ......................................................................................
869
869
870
871
872
873
873
874
876
879
879
882
884
887
887
889
890
890
892
893
894
15 Grafische Oberflächen mit Swing ....................................................... 895
15.1
15.2
15.3
15.4
15.5
Das Abstract Window Toolkit und Swing ..................................................
15.1.1 Abstract Window Toolkit (AWT) ................................................
15.1.2 Java Foundation Classes .............................................................
15.1.3 Was Swing von AWT unterscheidet ...........................................
15.1.4 Die Klasse Toolkit ......................................................................
Fenster unter grafischen Oberflächen .......................................................
15.2.1 Swing-Fenster darstellen ............................................................
15.2.2 AWT-Fenster darstellen .............................................................
15.2.3 Sichtbarkeit des Fensters ............................................................
15.2.4 Größe und Position des Fensters verändern ...............................
15.2.5 Unterklassen der Fenster-Klassen bilden ....................................
15.2.6 Fenster- und Dialog-Dekoration ................................................
15.2.7 Dynamisches Layout während einer Größenänderung ................
Beschriftungen (JLabel) .............................................................................
15.3.1 Mehrzeiliger Text, HTML in der Darstellung ...............................
Icon und ImageIcon für Bilder auf Swing-Komponenten ...........................
15.4.1 Die Schnittstelle Icon .................................................................
Es tut sich was – Ereignisse beim AWT ......................................................
15.5.1 Die Klasse AWTEvent ................................................................
895
895
896
899
899
900
900
902
903
903
904
905
905
906
909
909
911
913
913
23
Inhalt
15.5.2 Events auf verschiedenen Ebenen ..............................................
15.5.3 Swings Ereignisquellen und Horcher (Listener) ...........................
15.5.4 Listener implementieren ............................................................
15.5.5 Listener bei dem Ereignisauslöser anmelden/abmelden ..............
15.5.6 Aufrufen der Listener im AWT-Event-Thread ..............................
15.5.7 Adapterklassen nutzen ...............................................................
15.5.8 Innere Mitgliedsklassen und innere anonyme Klassen ................
15.6 Schaltflächen ............................................................................................
15.6.1 Normale Schaltflächen (JButton) ................................................
15.6.2 Der aufmerksame ActionListener ...............................................
15.6.3 Basisklasse AbstractButton .........................................................
15.6.4 Wechselknopf (JToggleButton) ...................................................
15.7 Swing Action ............................................................................................
15.7.1 javax.swing.Action .....................................................................
15.7.2 Eigenschaften der Action-Objekte ..............................................
15.8 JComponent und Component als Basis aller Komponenten .......................
15.8.1 Tooltips .....................................................................................
15.8.2 Rahmen (Border) .......................................................................
15.8.3 Fokus und Navigation ................................................................
15.8.4 Ereignisse jeder Komponente .....................................................
15.8.5 Die Größe und Position einer Komponente ................................
15.8.6 Komponenten-Ereignisse ...........................................................
15.8.7 Hinzufügen von Komponenten ..................................................
15.8.8 UI-Delegate – der wahre Zeichner ..............................................
15.8.9 Undurchsichtige (opak) Komponente .........................................
15.8.10 Properties und Listener für Änderungen .....................................
15.9 Container .................................................................................................
15.9.1 Standardcontainer (JPanel) .........................................................
15.9.2 Bereich mit automatischen Rollbalken (JScrollPane) ...................
15.9.3 Reiter (JTabbedPane) .................................................................
15.9.4 Teilung-Komponente (JSplitPane) ..............................................
15.10 Alles Auslegungssache: die Layoutmanager ...............................................
15.10.1 Übersicht über Layoutmanager ..................................................
15.10.2 Zuweisen eines Layoutmanagers ................................................
15.10.3 Im Fluss mit FlowLayout ............................................................
15.10.4 Mit BorderLayout in allen Himmelsrichtungen ...........................
15.10.5 Rasteranordnung mit GridLayout ...............................................
15.10.6 Der GridBagLayout-Manager .....................................................
15.10.7 Null-Layout ...............................................................................
15.10.8 BoxLayout .................................................................................
15.10.9 Weitere Layoutmanager .............................................................
24
914
916
916
919
919
920
922
923
923
925
927
929
929
930
930
931
931
932
935
936
938
939
940
940
943
943
944
944
945
946
947
947
947
948
949
951
954
955
960
961
962
Inhalt
15.11 Rollbalken und Schieberegler ...................................................................
15.11.1 Schieberegler (JSlider) ................................................................
15.11.2 Rollbalken (JScrollBar) ................................................................
15.12 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen ...................................
15.12.1 Kontrollfelder (JCheckBox) .........................................................
15.12.2 ItemSelectable, ItemListener und das ItemEvent ........................
15.12.3 Sich gegenseitig ausschließende Optionen (JRadioButton) .........
15.13 Fortschritte bei Operationen überwachen .................................................
15.13.1 Fortschrittsbalken (JProgressBar) ................................................
15.13.2 Dialog mit Fortschrittsanzeige (ProgressMonitor) .......................
15.14 Menüs und Symbolleisten ........................................................................
15.14.1 Die Menüleisten und die Einträge ..............................................
15.14.2 Menüeinträge definieren ...........................................................
15.14.3 Einträge durch Action-Objekte beschreiben ...............................
15.14.4 Mit der Tastatur: Mnemonics und Shortcut ................................
15.14.5 Der Tastatur-Shortcut (Accelerator) ...........................................
15.14.6 Tastenkürzel (Mnemonics) .........................................................
15.14.7 Symbolleisten alias Toolbars ......................................................
15.14.8 Popup-Menüs ............................................................................
15.14.9 System-Tray nutzen ...................................................................
15.15 Das Model-View-Controller-Konzept .......................................................
15.16 Auswahlmenüs, Listen und Spinner ..........................................................
15.16.1 Auswahlmenü (JComboBox) ......................................................
15.16.2 Zuordnung einer Taste mit einem Eintrag ...................................
15.16.3 Datumsauswahl .........................................................................
15.16.4 Listen (JList) ...............................................................................
15.16.5 Drehfeld (JSpinner) ....................................................................
15.17 Texteingabefelder .....................................................................................
15.17.1 Text in einer Eingabezeile ..........................................................
15.17.2 Die Oberklasse der Text-Komponenten (JTextComponent) ........
15.17.3 Geschützte Eingaben (JPasswordField) .......................................
15.17.4 Validierende Eingabefelder (JFormattedTextField) ......................
15.17.5 Einfache mehrzeilige Textfelder (JTextArea) ...............................
15.17.6 Editor-Klasse (JEditorPane) ........................................................
15.18 Tabellen (JTable) ......................................................................................
15.18.1 Ein eigenes Tabellen-Model .......................................................
15.18.2 Basisklasse für eigene Modelle (AbstractTableModel) ................
15.18.3 Vorgefertigtes Standard-Modell (DefaultTableModel) ................
15.18.4 Ein eigener Renderer für Tabellen ..............................................
15.18.5 Zell-Editoren ..............................................................................
15.18.6 Größe und Umrandung der Zellen ..............................................
15.18.7 Spalteninformationen ................................................................
962
962
964
968
968
971
972
974
974
976
976
977
978
980
981
981
983
983
986
989
990
992
992
996
997
997
1002
1004
1004
1005
1006
1006
1008
1010
1013
1014
1015
1018
1019
1023
1024
1024
25
Inhalt
15.19
15.20
15.21
15.22
15.23
15.24
15.25
15.26
15.27
26
15.18.8 Tabellenkopf von Swing-Tabellen ...............................................
15.18.9 Selektionen einer Tabelle ...........................................................
15.18.10 Automatisches Sortieren und Filtern mit RowSorter ...................
15.18.11 Ein professionelles Tabellenlayout mit JGrid ..............................
Bäume (JTree) ...........................................................................................
15.19.1 JTree und sein TreeModel und TreeNode ...................................
15.19.2 Selektionen bemerken ...............................................................
15.19.3 Das TreeModel von JTree ..........................................................
JRootPane, JLayeredPane und JDesktopPane ............................................
15.20.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane) ...
15.20.2 JLayeredPane .............................................................................
15.20.3 JDesktopPane und die Kinder JInternalFrame ............................
Dialoge und Window-Objekte ..................................................................
15.21.1 JWindow und JDialog ................................................................
15.21.2 Modal oder nicht-modal ............................................................
15.21.3 Standarddialoge mit JOptionPane ..............................................
15.21.4 Der Farbauswahldialog JColorChooser .......................................
15.21.5 Der Dateiauswahldialog .............................................................
Flexibles Java-Look & Feel ........................................................................
15.22.1 L & F global setzen ....................................................................
15.22.2 UIManager ................................................................................
15.22.3 Verbessern des Aussehens unter Windows mit JGoodies Looks ...
Die Zwischenablage (Clipboard) ................................................................
15.23.1 Clipboard-Objekte .....................................................................
15.23.2 Auf den Inhalt zugreifen mit Transferable ...................................
15.23.3 DataFlavor ist das Format der Daten in der Zwischenablage .......
15.23.4 Einfügungen in der Zwischenablage erkennen ............................
15.23.5 Drag & Drop ..............................................................................
Undo durchführen ....................................................................................
AWT, Swing und die Threads ....................................................................
15.25.1 Ereignisschlange (EventQueue) und AWT-Event-Thread .............
15.25.2 Swing ist nicht Thread-sicher .....................................................
15.25.3 Swing-Elemente mit invokeLater() und invokeAndWait()
bedienen ...................................................................................
15.25.4 SwingWorker .............................................................................
15.25.5 Eigene Ereignisse in die Queue setzen ........................................
15.25.6 Auf alle Ereignisse hören ............................................................
Barrierefreiheit mit der Java Accessibility API ............................................
Benutzerinteraktionen automatisieren ......................................................
15.27.1 Automatisch in die Tasten hauen ...............................................
15.27.2 Mausoperationen ......................................................................
15.27.3 Methoden zur Zeitsteuerung ......................................................
1025
1025
1026
1027
1028
1028
1029
1030
1032
1032
1033
1033
1035
1035
1036
1036
1038
1040
1044
1044
1044
1046
1046
1046
1047
1048
1050
1050
1051
1053
1053
1054
1055
1056
1058
1059
1059
1060
1061
1062
1062
Inhalt
15.27.4 Screenshots ...............................................................................
15.27.5 MouseInfo und PointerInfo ........................................................
15.28 Zeitliches Ausführen mit dem javax.swing.Timer .......................................
15.29 Alternativen zu AWT und Swing ...............................................................
15.29.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor .........
15.29.2 SWT (Standard Widget Toolkit) ..................................................
15.30 Zum Weiterlesen ......................................................................................
1063
1063
1064
1064
1065
1065
1067
16 Grafikprogrammierung ........................................................................ 1069
16.1
16.2
16.3
16.4
16.5
Grundlegendes zum Zeichnen ...................................................................
16.1.1 Die paint()-Methode für das AWT-Frame ...................................
16.1.2 Zeichen von Inhalten mit JFrame ...............................................
16.1.3 Auffordern zum Neuzeichnen mit repaint() ................................
16.1.4 Grundbegriffe: Koordinaten, Punkte, Pixel .................................
16.1.5 Die ereignisorientierte Programmierung ändert Fensterinhalte ...
16.1.6 Java 2D-API ...............................................................................
Einfache Zeichenfunktionen ......................................................................
16.2.1 Linien ........................................................................................
16.2.2 Rechtecke ..................................................................................
16.2.3 Ovale und Kreisbögen ...............................................................
16.2.4 Polygone und Polylines ..............................................................
Zeichenketten schreiben und Fonts ..........................................................
16.3.1 Zeichenfolgen schreiben ............................................................
16.3.2 Die Font-Klasse .........................................................................
16.3.3 Einen neuen Font aus einem gegebenen Font ableiten ...............
16.3.4 Zeichensätze des Systems ermitteln ...........................................
16.3.5 Neue TrueType-Fonts in Java nutzen ..........................................
16.3.6 Font-Metadaten durch FontMetrics ...........................................
Geometrische Objekte ..............................................................................
16.4.1 Die Schnittstelle Shape ..............................................................
16.4.2 Kreisförmiges .............................................................................
16.4.3 Kurviges ....................................................................................
16.4.4 Area und die konstruktive Flächengeometrie .............................
16.4.5 Pfade .........................................................................................
16.4.6 Punkt in Form, Schnitt von Linien, Abstand Punkt/Linie und
Weiteres ....................................................................................
Das Innere und Äußere einer Form ...........................................................
16.5.1 Farben und die Paint-Schnittstelle .............................................
16.5.2 Farben mit der Klasse Color .......................................................
16.5.3 Die Farben des Systems über SystemColor .................................
16.5.4 Composite und Xor ....................................................................
16.5.5 Dicke und Art der Linien von Formen bestimmen über Stroke ...
1069
1069
1071
1072
1073
1073
1074
1075
1075
1076
1077
1077
1080
1080
1081
1082
1083
1084
1085
1088
1089
1090
1091
1091
1091
1094
1095
1095
1096
1101
1104
1105
27
Inhalt
16.6
Bilder .......................................................................................................
16.6.1 Eine Übersicht über die Bilder-Bibliotheken ...............................
16.6.2 Bilder mit ImageIO lesen ...........................................................
16.6.3 Ein Bild zeichnen .......................................................................
16.6.4 Programm-Icon/Fenster-Icon setzen ..........................................
16.6.5 Splash-Screen ............................................................................
16.6.6 Bilder im Speicher erzeugen .......................................................
16.6.7 Pixel für Pixel auslesen und schreiben ........................................
16.6.8 Bilder skalieren ..........................................................................
16.6.9 Schreiben mit ImageIO ..............................................................
16.6.10 Asynchrones Laden mit getImage() und dem MediaTracker ........
16.6.11 Selbst definierte Cursor ..............................................................
16.6.12 VolatileImage ............................................................................
16.7 Weitere Eigenschaften von Graphics .........................................................
16.7.1 Eine Kopie von Graphics erstellen ..............................................
16.7.2 Koordinatensystem verschieben .................................................
16.7.3 Beschnitt (Clipping) ...................................................................
16.8 Zeichenhinweise durch RenderingHints ....................................................
16.9 Transformationen mit einem AffineTransform-Objekt ...............................
16.10 Drucken ...................................................................................................
16.10.1 Drucken der Inhalte ...................................................................
16.10.2 Bekannte Drucker ......................................................................
16.11 Grafikverarbeitung ohne grafische Oberfläche ...........................................
16.11.1 Xvfb-Server ................................................................................
16.11.2 Pure Java AWT Toolkit (PJA) ......................................................
16.12 Zum Weiterlesen ......................................................................................
1109
1110
1111
1113
1116
1117
1117
1119
1121
1123
1126
1127
1129
1129
1129
1130
1130
1134
1134
1136
1137
1138
1139
1140
1140
1141
17 Netzwerkprogrammierung .................................................................. 1143
17.1
17.2
17.3
28
Grundlegende Begriffe ..............................................................................
17.1.1 Internet-Standards und RFC .......................................................
URI und URL ............................................................................................
17.2.1 URI ............................................................................................
17.2.2 Die Klasse URL ..........................................................................
17.2.3 Informationen über eine URL .....................................................
17.2.4 Der Zugriff auf die Daten über die Klasse URL ............................
17.2.5 Verbindungen durch einen Proxy-Server ....................................
Die Klasse URLConnection .......................................................................
17.3.1 Methoden und Anwendung von URLConnection .......................
17.3.2 Protokoll- und Content-Handler ................................................
17.3.3 Im Detail: vom URL zur URLConnection .....................................
17.3.4 Der Protokoll-Handler für Jar-Dateien ........................................
1143
1144
1144
1144
1144
1147
1148
1150
1151
1151
1153
1154
1155
Inhalt
17.3.5
Passwort-geschützte Seiten mit Basic Authentication/
Proxy-Authentifizierung .............................................................
17.4 Mit GET und POST Daten übergeben .......................................................
17.4.1 Kodieren der Parameter für Serverprogramme ...........................
17.4.2 Eine Suchmaschine ansprechen ..................................................
17.5 Host- und IP-Adressen .............................................................................
17.5.1 Lebt der Rechner? ......................................................................
17.5.2 Das Netz ist Klasse ... .................................................................
17.5.3 IP-Adresse des lokalen Hosts .....................................................
17.6 NetworkInterface .....................................................................................
17.7 Mit dem Socket zum Server ......................................................................
17.7.1 Das Netzwerk ist der Computer .................................................
17.7.2 Sockets ......................................................................................
17.7.3 Eine Verbindung zum Server aufbauen .......................................
17.7.4 Server unter Spannung: die Ströme ............................................
17.7.5 Die Verbindung wieder abbauen ................................................
17.7.6 Informationen über den Socket ..................................................
17.7.7 Reine Verbindungsdaten über SocketAddress ............................
17.8 Client/Server-Kommunikation ..................................................................
17.8.1 Warten auf Verbindungen ..........................................................
17.8.2 Ein Multiplikationsserver ...........................................................
17.8.3 Blockierendes Lesen ..................................................................
17.8.4 Von außen erreichbar sein .........................................................
17.9 Apache Jakarta Commons HttpClient und Net ..........................................
17.9.1 Jakarta Commons HttpClient ......................................................
17.9.2 Jakarta Commons Net ................................................................
17.10 Arbeitsweise eines Webservers .................................................................
17.10.1 Das Hypertext Transfer Protocol (HTTP) .....................................
17.10.2 Anfragen an den Server ..............................................................
17.10.3 Die Antworten vom Server .........................................................
17.10.4 Webserver mit com.sun.net.httpserver.HttpServer .....................
17.11 Datagram-Sockets ....................................................................................
17.11.1 Die Klasse DatagramSocket ........................................................
17.11.2 Datagramme und die Klasse DatagramPacket ............................
17.11.3 Auf ein hereinkommendes Paket warten ....................................
17.11.4 Ein Paket zum Senden vorbereiten .............................................
17.11.5 Methoden der Klasse DatagramPacket .......................................
17.11.6 Das Paket senden ......................................................................
17.12 E-Mail ......................................................................................................
17.12.1 Wie eine E-Mail um die Welt geht .............................................
17.12.2 Das Simple Mail Transfer Protocol und RFC 822 ........................
17.12.3 POP (Post Office Protocol) .........................................................
1157
1159
1159
1160
1161
1163
1164
1164
1165
1166
1166
1166
1167
1168
1169
1169
1171
1172
1173
1174
1176
1177
1178
1178
1179
1180
1180
1180
1183
1186
1187
1189
1190
1191
1192
1193
1193
1194
1195
1195
1196
29
Inhalt
17.12.4 Die JavaMail API ........................................................................
17.12.5 E-Mails mittels POP3 abrufen ....................................................
17.12.6 E-Mails versenden .....................................................................
17.12.7 Ereignisse und Suchen ...............................................................
17.13 Tiefer liegende Netzwerkeigenschaften .....................................................
17.13.1 Internet Control Message Protocol (ICMP) .................................
17.13.2 MAC-Adresse ............................................................................
17.14 Zum Weiterlesen ......................................................................................
1196
1197
1199
1202
1203
1203
1203
1204
18 Verteilte Programmierung mit RMI
und Web-Services ............................................................................... 1205
18.1
18.2
18.3
18.4
18.5
18.6
18.7
30
Entfernte Objekte und Methoden ............................................................. 1205
18.1.1 Stellvertreter helfen bei entfernten Methodenaufrufen .............. 1205
18.1.2 Standards für entfernte Objekte ................................................. 1207
Java Remote Method Invocation .............................................................. 1207
18.2.1 Zusammenspiel von Server, Registry und Client .......................... 1207
18.2.2 Wie die Stellvertreter die Daten übertragen ............................... 1207
18.2.3 Probleme mit entfernten Methoden .......................................... 1208
18.2.4 Nutzen von RMI bei Middleware-Lösungen ............................... 1210
18.2.5 Zentrale Klassen und Schnittstellen ............................................ 1210
18.2.6 Entfernte und lokale Objekte im Vergleich ................................. 1211
Auf der Serverseite ................................................................................... 1211
18.3.1 Entfernte Schnittstelle deklarieren ............................................. 1211
18.3.2 Remote-Objekt-Implementierung .............................................. 1212
18.3.3 Stellvertreterobjekte .................................................................. 1213
18.3.4 Der Namensdienst (Registry) ...................................................... 1213
18.3.5 Remote-Objekt-Implementierung exportieren und beim
Namensdienst anmelden ............................................................ 1215
18.3.6 Einfaches Logging ...................................................................... 1217
18.3.7 Aufräumen mit dem DGC .......................................................... 1218
Auf der Clientseite .................................................................................... 1218
Entfernte Objekte übergeben und laden ................................................... 1219
18.5.1 Klassen vom RMI-Klassenlader nachladen .................................. 1220
Weitere Eigenschaften von RMI ................................................................ 1220
18.6.1 RMI und CORBA ........................................................................ 1220
18.6.2 RMI über HTTP getunnelt .......................................................... 1220
18.6.3 Automatische Remote-Objekt-Aktivierung ................................. 1221
Daily Soap ................................................................................................ 1222
18.7.1 SOAP-Protokoll ......................................................................... 1222
18.7.2 Die technische Realisierung ....................................................... 1223
18.7.3 SOAP-Implementierungen ......................................................... 1223
18.7.4 @WebService in Java 6 ............................................................. 1224
Inhalt
18.8
18.9
18.7.5 Einen Web-Service definieren ....................................................
18.7.6 Web-Services veröffentlichen .....................................................
18.7.7 Einen JAX-WS-Client implementieren ........................................
Java Message Service (JMS) ......................................................................
Zum Weiterlesen ......................................................................................
1224
1225
1225
1227
1228
19 JavaServer Pages und Servlets ............................................................ 1229
19.1
19.2
19.3
19.4
19.5
19.6
19.7
19.8
Dynamisch generierte Webseiten .............................................................
19.1.1 Was sind Servlets? .....................................................................
19.1.2 Was sind JavaServer Pages? .......................................................
Servlets und JSPs mit Tomcat entwickeln ..................................................
19.2.1 Servlet-Container .......................................................................
19.2.2 Entwicklung der Servlet/JSP-Spezifikationen ..............................
19.2.3 Webserver mit Servlet-Funktionalität .........................................
19.2.4 Tomcat ......................................................................................
19.2.5 Ablageort für eigene JSP-Seiten .................................................
19.2.6 Web-Applikationen ...................................................................
19.2.7 Zuordnung von Web-Applikationen zu physikalischen
Verzeichnissen ...........................................................................
19.2.8 Mit dem WTP ein Web-Projekt entwickeln ................................
Statisches und Dynamisches .....................................................................
19.3.1 Statischer Template-Code ..........................................................
19.3.2 Dynamische Inhalte ...................................................................
19.3.3 Kommentare ..............................................................................
Die Expression Language (EL) ...................................................................
19.4.1 Operatoren der EL .....................................................................
19.4.2 Literale ......................................................................................
19.4.3 Implizite EL-Objekte ..................................................................
Formulardaten ..........................................................................................
Auf Beans zurückgreifen ...........................................................................
19.6.1 Beans in JSP-Seiten anlegen .......................................................
19.6.2 Properties einer Bean im EL-Ausdruck erfragen ..........................
19.6.3 Properties mit <jsp:setProperty> setzen .....................................
19.6.4 Bean-Klasse zum Testen von E-Mail-Adressen ...........................
19.6.5 Parameterwerte in Bean übertragen ...........................................
JSP Tag-Libraries .......................................................................................
19.7.1 Standard Tag Library (JSTL) ........................................................
19.7.2 Jakarta Taglibs Project ...............................................................
Einbinden und Weiterleiten ......................................................................
19.8.1 Einbinden von Inhalten ..............................................................
19.8.2 Forward und Redirect ................................................................
19.8.3 Applets einbinden .....................................................................
1229
1229
1230
1231
1231
1232
1232
1232
1233
1234
1235
1235
1236
1236
1237
1237
1237
1238
1238
1239
1239
1240
1240
1241
1241
1242
1243
1243
1244
1247
1248
1248
1250
1250
31
Inhalt
19.9
19.10
19.11
19.12
19.13
19.14
Skripten von JSPs ......................................................................................
19.9.1 Scriptlets ...................................................................................
19.9.2 JSP-Ausdrücke ...........................................................................
19.9.3 JSP-Deklarationen ......................................................................
19.9.4 Quoting .....................................................................................
19.9.5 Entsprechende XML-Tags ..........................................................
19.9.6 Implizite Objekte für Scriptlets und JSP-Ausdrücke ....................
JSP-Direktiven ..........................................................................................
19.10.1 page-Direktiven im Überblick ....................................................
19.10.2 Mit JSPs Bilder generieren .........................................................
Sitzungsverfolgung (Session Tracking) .......................................................
19.11.1 Lösungen für Sitzungsverfolgung ................................................
19.11.2 Auf Session-Dateien zurückgreifen .............................................
Servlets ....................................................................................................
19.12.1 Servlets compilieren ...................................................................
19.12.2 Servlet-Mapping ........................................................................
19.12.3 Der Lebenszyklus eines Servlets .................................................
19.12.4 Mehrere Anfragen beim Servlet und die Thread-Sicherheit ........
19.12.5 Servlets und Sessions .................................................................
19.12.6 Weiterleiten und Einbinden von Servlet-Inhalten .......................
Internationalisierung ................................................................................
19.13.1 Die Länderkennung des Anfragers auslesen ................................
19.13.2 Länderkennung für die Ausgabe setzen ......................................
19.13.3 Westeuropäische Texte senden ..................................................
Zum Weiterlesen ......................................................................................
1251
1251
1251
1252
1252
1252
1253
1253
1254
1255
1256
1257
1258
1258
1259
1260
1261
1261
1261
1262
1263
1264
1264
1264
1265
20 Applets ................................................................................................ 1267
20.1
20.2
20.3
32
Applets in der Wiege von Java ..................................................................
20.1.1 (J)Applet und Applikationen ......................................................
20.1.2 Das erste Hallo-Applet ...............................................................
20.1.3 Die Zyklen eines Applets ............................................................
20.1.4 Parameter an das Applet übergeben ..........................................
20.1.5 Wie das Applet den Browser-Inhalt ändern kann .......................
20.1.6 Den Ursprung des Applets erfragen ............................................
20.1.7 Datenaustausch zwischen Applets ..............................................
20.1.8 Was ein Applet alles darf ...........................................................
Fehler in Applets finden ...........................................................................
20.2.1 Ist Java im Browser aktiviert? .....................................................
20.2.2 Läuft das Applet unter Netscape oder Microsoft Explorer? .........
20.2.3 Datenaustausch zwischen Applets und Java-Skripten .................
Webstart ..................................................................................................
1267
1267
1267
1269
1269
1271
1271
1273
1275
1276
1276
1277
1278
1279
Inhalt
21 Midlets und die Java ME ..................................................................... 1281
21.1
21.2
21.3
21.4
21.5
21.6
Java Platform, Micro Edition (Java ME) .....................................................
Konfigurationen .......................................................................................
21.2.1 Connected Limited Device Configuration (CLDC) .......................
21.2.2 Connected Device Configuration (CDC) .....................................
Profile ......................................................................................................
21.3.1 Mobile Information Device Profile (MIDP) .................................
21.3.2 Weitere Profile ..........................................................................
Wireless Toolkits ......................................................................................
21.4.1 Sun Java Wireless Toolkit for CLDC ............................................
21.4.2 Eclipse-Plugin ............................................................................
Die Midlet-API .........................................................................................
21.5.1 Paketstruktur Mobile Information Device Profile (2.0) ...............
Zum Weiterlesen ......................................................................................
1281
1281
1281
1282
1282
1282
1283
1283
1283
1284
1286
1286
1287
22 Datenbankmanagement mit JDBC ...................................................... 1289
22.1
22.2
22.3
22.4
22.5
22.6
Das relationale Modell .............................................................................
Datenbanken und Tools ...........................................................................
22.2.1 HSQLDB ....................................................................................
22.2.2 Weitere Datenbanken ................................................................
22.2.3 Eclipse-Plugins zum Durchschauen von Datenbanken ................
JDBC und Datenbanktreiber .....................................................................
22.3.1 Treibertypen ..............................................................................
22.3.2 JDBC-Versionen .........................................................................
Eine Beispielabfrage .................................................................................
22.4.1 Schritte zur Datenbankabfrage ...................................................
22.4.2 Client für HSQLDB-Datenbank ...................................................
Mit Java an eine Datenbank andocken .....................................................
22.5.1 Der Treiber-Manager .................................................................
22.5.2 Den Treiber laden ......................................................................
22.5.3 Eine Aufzählung aller Treiber .....................................................
22.5.4 Log-Informationen .....................................................................
22.5.5 Verbindung zur Datenbank auf- und abbauen ............................
22.5.6 DataSource ................................................................................
22.5.7 Gepoolte Verbindungen .............................................................
Datenbankabfragen ..................................................................................
22.6.1 Abfragen über das Statement-Objekt .........................................
22.6.2 Ergebnisse einer Abfrage in ResultSet ........................................
22.6.3 Java und SQL-Datentypen ..........................................................
22.6.4 Unicode in der Spalte korrekt auslesen ......................................
1289
1290
1290
1291
1293
1295
1296
1297
1298
1298
1299
1300
1301
1301
1302
1303
1304
1307
1310
1310
1310
1312
1314
1317
33
Inhalt
22.7
22.8
22.9
22.10
22.11
22.12
22.13
22.14
22.6.5 Eine SQL-NULL und wasNull() bei ResultSet .............................. 1317
22.6.6 Wie viele Zeilen hat ein ResultSet? ............................................ 1318
Die Ausnahmen bei JDBC ......................................................................... 1318
Elemente einer Datenbank hinzufügen und aktualisieren .......................... 1319
22.8.1 Batch-Updates ........................................................................... 1320
ResultSets in Bohnen durch RowSet ......................................................... 1321
22.9.1 Die Schnittstelle RowSet ............................................................ 1321
22.9.2 Implementierungen von RowSet ................................................ 1322
22.9.3 Der Typ CachedRowSet ............................................................. 1322
22.9.4 Der Typ WebRowSet ................................................................. 1323
Vorbereitete Anweisungen (Prepared Statements) .................................... 1325
22.10.1 PreparedStatement-Objekte vorbereiten .................................... 1326
22.10.2 Werte für die Platzhalter eines PreparedStatement .................... 1326
Transaktionen ........................................................................................... 1328
Metadaten ............................................................................................... 1328
22.12.1 Metadaten über die Tabelle ....................................................... 1328
22.12.2 Informationen über die Datenbank ............................................ 1332
Einführung in SQL .................................................................................... 1333
22.13.1 Ein Rundgang durch SQL-Anfragen ............................................ 1333
22.13.2 Datenabfrage mit der Data Query Language (DQL) .................... 1335
22.13.3 Tabellen mit der Data Definition Language (DDL) anlegen ......... 1337
Zum Weiterlesen ...................................................................................... 1337
23 Reflection und Annotationen .............................................................. 1339
23.1
23.2
23.3
34
Metadaten ...............................................................................................
23.1.1 Metadaten durch Java-Doc Tags ................................................
23.1.2 XDoclet .....................................................................................
Metadaten der Klassen mit dem Class-Objekt ...........................................
23.2.1 An ein Class-Objekt kommen .....................................................
23.2.2 Was das Class-Objekt beschreibt ...............................................
23.2.3 Der Name der Klasse .................................................................
23.2.4 instanceof mit Class-Objekten ....................................................
23.2.5 Oberklassen finden ....................................................................
23.2.6 Implementierte Interfaces einer Klasse oder eines Interfaces ......
23.2.7 Modifizierer und die Klasse Modifier .........................................
23.2.8 Die Arbeit auf dem Feld .............................................................
Attribute, Methoden und Konstruktoren ..................................................
23.3.1 Reflections Gespür für Attribute einer Klasse .............................
23.3.2 Methoden einer Klasse erfragen .................................................
23.3.3 Properties einer Bean erfragen ...................................................
23.3.4 Konstruktoren einer Klasse ........................................................
23.3.5 Annotationen ............................................................................
1339
1339
1340
1340
1341
1343
1345
1347
1347
1348
1349
1350
1351
1352
1355
1358
1359
1361
Inhalt
23.4
23.5
23.6
23.7
Objekte erzeugen und manipulieren .........................................................
23.4.1 Objekte erzeugen ......................................................................
23.4.2 Die Belegung der Variablen erfragen ..........................................
23.4.3 Eine generische toString()-Funktion ...........................................
23.4.4 Variablen setzen ........................................................................
23.4.5 Private Attribute ändern ............................................................
Methoden aufrufen ..................................................................................
23.5.1 Statische Methoden aufrufen .....................................................
23.5.2 Dynamische Methodenaufrufe bei festen Methoden
beschleunigen ............................................................................
Informationen und Identifizierung von Paketen ........................................
23.6.1 Geladene Pakete ........................................................................
Annotationen ...........................................................................................
23.7.1 Neue Annotationen definieren ...................................................
23.7.2 Annotationen mit genau einem Element ....................................
23.7.3 Beliebige Schlüssel-Werte-Paare ................................................
23.7.4 Vorbelegte Elemente .................................................................
23.7.5 Annotieren von Annotationstypen .............................................
23.7.6 Annotationen zur Laufzeit ausgelesen ........................................
23.7.7 Mögliche Nachteile von Annotationen .......................................
1361
1361
1363
1365
1366
1368
1369
1370
1371
1372
1373
1373
1373
1373
1375
1378
1379
1381
1383
24 Logging und Monitoring ..................................................................... 1385
24.1
24.2
24.3
24.4
24.5
24.6
24.7
Die Logging-API .......................................................................................
24.1.1 Einfaches Logging ......................................................................
24.1.2 Log-Level ...................................................................................
24.1.3 Logging in eine Datei .................................................................
Überwachen von Systemzuständen ...........................................................
MBean-Typen, MBean-Server und weitere Begriffe ...................................
24.3.1 MXBeans des Systems ................................................................
Geschwätzige Programme und JConsole ...................................................
24.4.1 JConsole ....................................................................................
Der MBeanServer .....................................................................................
Eine eigene Standard-MBean ....................................................................
24.6.1 Management-Schnittstelle .........................................................
24.6.2 Implementierung der managed Ressource ..................................
24.6.3 Anmeldung beim Server .............................................................
24.6.4 Eigene Bean in JConsole ............................................................
24.6.5 JMX mit RMI-Adaptor ...............................................................
Zum Weiterlesen ......................................................................................
1385
1385
1386
1386
1387
1388
1389
1391
1391
1393
1394
1394
1394
1395
1395
1397
1399
35
Inhalt
25 Sicherheitskonzepte ............................................................................ 1401
25.1
25.2
25.3
25.4
25.5
25.6
25.7
Zentrale Elemente der Java-Sicherheit ...................................................... 1401
25.1.1 Security-API der Java SE ............................................................. 1401
25.1.2 Cryptographic Service Providers ................................................. 1402
Der Sandkasten (Sandbox) ........................................................................ 1403
Sicherheitsmanager (Security Manager) .................................................... 1403
25.3.1 Der Sicherheitsmanager bei Applets ........................................... 1405
25.3.2 Sicherheitsmanager aktivieren .................................................... 1406
25.3.3 Wie nutzen die Java-Bibliotheken den Sicherheitsmanager? ....... 1407
25.3.4 Rechte durch Policy-Dateien vergeben ....................................... 1408
25.3.5 Erstellen von Rechtedateien mit dem grafischen Policy-Tool ...... 1410
25.3.6 Kritik an den Policies ................................................................. 1410
Signierung ................................................................................................ 1412
25.4.1 Warum signieren? ...................................................................... 1412
25.4.2 Digitale Ausweise und die Zertifizierungsstelle ........................... 1412
25.4.3 Mit keytool Schlüssel erzeugen .................................................. 1413
25.4.4 Signieren mit jarsigner ............................................................... 1414
Digitale Unterschriften ............................................................................. 1414
25.5.1 Die MDx-Reihe .......................................................................... 1415
25.5.2 Secure Hash Algorithm (SHA) ..................................................... 1415
25.5.3 Mit der Security-API einen Fingerabdruck berechnen ................. 1416
25.5.4 Die Klasse MessageDigest .......................................................... 1416
25.5.5 Unix-Crypt ................................................................................. 1418
Verschlüsseln von Daten(-strömen) .......................................................... 1418
25.6.1 Den Schlüssel bitte .................................................................... 1418
25.6.2 Verschlüsseln mit Cipher ............................................................ 1420
25.6.3 Verschlüsseln von Datenströmen ............................................... 1420
Zum Weiterlesen ...................................................................................... 1422
26 Java Native Interface (JNI) .................................................................. 1423
26.1
26.2
26.3
36
Java Native Interface und Invocation-API .................................................
Einbinden einer C-Funktion in ein Java-Programm ....................................
26.2.1 Schreiben des Java-Codes ..........................................................
26.2.2 Compilieren des Java-Programms ...............................................
26.2.3 Erzeugen der Header-Datei ........................................................
26.2.4 Implementierung der Methode in C ...........................................
26.2.5 Übersetzen der C-Programme und Erzeugen der dynamischen
Bibliothek ..................................................................................
26.2.6 Suchort der dynamischen Bibliothek ..........................................
Nativ die Stringlänge ermitteln .................................................................
1423
1424
1424
1425
1425
1426
1427
1429
1429
Inhalt
26.4
26.5
26.6
Erweiterte JNI-Eigenschaften ....................................................................
26.4.1 Klassendefinitionen ...................................................................
26.4.2 Zugriff auf Attribute ...................................................................
Einfache Anbindung von existierenden Bibliotheken .................................
26.5.1 C++ Klassen ansprechen ............................................................
26.5.2 COM-Schnittstellen anzapfen ....................................................
Zum Weiterlesen ......................................................................................
1430
1430
1431
1433
1433
1433
1434
27 Dienstprogramme für die Java-Umgebung ......................................... 1435
27.1
27.2
27.3
27.4
27.5
27.6
27.7
27.8
27.9
A
Die Werkzeuge im Überblick ....................................................................
Java-Compiler ...........................................................................................
27.2.1 Bytecode Compiler javac ............................................................
27.2.2 Native Compiler .........................................................................
27.2.3 Java-Programme in ein natives ausführbares Programm
einpacken ..................................................................................
Der Java-Interpreter java ..........................................................................
27.3.1 Der Unterschied zwischen java.exe und javaw.exe .....................
Das Archivformat Jar ................................................................................
27.4.1 Das Dienstprogramm Jar benutzen .............................................
27.4.2 Das Manifest .............................................................................
27.4.3 Applikationen in Jar-Archiven starten ........................................
27.4.4 Applets in Jar-Archiven ..............................................................
Monitoringprogramme .............................................................................
27.5.1 jps .............................................................................................
27.5.2 jstat ...........................................................................................
27.5.3 jmap ..........................................................................................
27.5.4 jstack .........................................................................................
Ant ...........................................................................................................
27.6.1 Bezug und Installation von Ant ..................................................
27.6.2 Properties ..................................................................................
27.6.3 Externe und vordefinierte Properties ..........................................
27.6.4 Weitere Ant-Tasks .....................................................................
Decompiler und Obfuscatoren ..................................................................
27.7.1 Der Decompiler Jad ...................................................................
27.7.2 Das Obfuscator-Programm ProGuard .........................................
Weitere Dienstprogramme .......................................................................
27.8.1 Sourcecode Beautifier ................................................................
27.8.2 Java-Programme als Systemdienst ausführen ..............................
Zum Weiterlesen ......................................................................................
1435
1435
1435
1436
1437
1437
1438
1439
1439
1442
1442
1443
1444
1444
1444
1444
1445
1445
1446
1447
1448
1449
1450
1451
1451
1452
1452
1453
1454
Die Begleit-DVD .................................................................................. 1455
Index
................................................................................................................. 1457
37
Wenn ich eine Oper hundertmal dirigiert habe,
dann ist es Zeit, sie wieder zu lernen.
– Arturo Toscanini (1867 – 1957)
2
Sprachbeschreibung
Ein Programm in Java wird nicht umgangssprachlich beschrieben, sondern ein Regelwerk und
eine Grammatik definieren die Syntax und die Semantik. In den nächsten Abschnitten werden
wir kleinere Beispiele für Java-Programme kennenlernen, und dann ist der Weg frei für größere Programme.
2.1
Elemente der Programmiersprache Java
Wir wollen im Folgenden über das Regelwerk, die Grammatik und Syntax der Programmiersprache Java sprechen und uns unter anderem über die Unicode-Kodierung, Token sowie
Bezeichner Gedanken machen. Bei der Benennung einer Funktion zum Beispiel dürfen wir
aus einer großen Anzahl Zeichen wählen; der Zeichenvorrat nennt sich Lexikalik.
Die Syntax eines Java-Programms definiert die Token und bildet so das Vokabular. Richtig
geschriebene Programme müssen aber dennoch nicht korrekt sein. Unter dem Begriff
»Semantik« fassen wir daher die Bedeutung eines syntaktisch korrekten Programms zusammen. Die Semantik bestimmt, was das Programm macht. Die Abstraktionsreihenfolge ist also
Lexikalik, Syntax und Semantik. Der Compiler durchläuft diese Schritte, bevor er den Bytecode erzeugen kann.
2.1.1
Textkodierung durch Unicode-Zeichen
Java kodiert Texte durch Unicode-Zeichen. Jedem Zeichen ist ein eindeutiger Zahlenwert
(engl. code point) zugewiesen, sodass zum Beispiel das große »A« an Position 65 liegt. Der Unicode-Zeichensatz beinhaltet die ISO US-ASCII-Zeichen1 von 0 bis 127 (hexadezimal 0x00 bis
0x7f, also 7 Bit) und die erweiterte Kodierung nach ISO8859-1 (Latin-1), die Zeichen von 128
bis 255 hinzunimmt.
In den letzten Jahren hat sich der Unicode-Standard erweitert, und Java ist den Erweiterungen gefolgt. Die Java-Versionen von 1.0 bis 1.4 nutzen den Unicode-Standard 1.1 bis 3.0, der
für jedes Zeichen 16 Bit reserviert. So legt Java jedes Zeichen in 2 Byte ab und ermöglicht die
1 http://en.wikipedia.org/wiki/ASCII
85
2
Sprachbeschreibung
Kodierung von mehr als 65 000 Zeichen. Ab Java 5 ist der Unicode-4.0-Standard möglich, der
32 Bit für die Abbildung eines Zeichens nötig macht. Die Entwickler haben allerdings für ein
Java-Zeichen nicht die interne Länge angehoben, sondern zwei 16-Bit-Zeichen – ein Surrogate-Paar – bilden in der UTF-16-Kodierung ein Unicode-4.0-Zeichen. Diese Surrogate vergrößern den Bereich der Basic Multilingual Plane (BMP).
Hinweis Obwohl Java intern alle Zeichenfolgen in Unicode kodiert, ist es ungünstig, Klassennamen zu wählen, die Unicode-Zeichen enthalten. Einige Dateisysteme speichern die
Namen im alten 8-Bit-ASCII-Zeichensatz ab, sodass Teile vom Unicode-Zeichen verloren
gehen.
Schreibweise für Unicode-Zeichen/Unicode Escapes
Da ein Java-Compiler alle Eingaben als Unicode verarbeitet, kann er grundsätzlich Quellcode
mit deutschen Umlauten, griechischen Symbolen und chinesischen Schriftzeichen verarbeiten. Allerdings ist es gut zu überlegen, ob ein Programm direkt Unicode-Zeichen enthalten
sollte, denn Editoren2 haben mit Unicode-Zeichen oft ihre Schwierigkeiten – genauso wie
Dateisysteme. Beliebige Unicode-Zeichen lassen sich für den Compiler jedoch über Unicode
Escapes mit \uxxxx schreiben, wobei x eine hexadezimale Ziffer ist – also 0...9, A...F (beziehungsweise a...f). Diese sechs ASCII-Zeichen, die das Unicode beschreiben, lassen sich in
jedem ASCII-Texteditor schreiben, sodass kein Unicode-fähiger Editor nötig ist. Unicode-Zeichen für deutsche Sonderzeichen sind folgende:
Zeichen
Unicode
Ä, ä
\u00c4, \u00e4
Ö, ö
\u00d6, \u00f6
Ü, ü
\u00dc, \u00fc
ß
\u00df
Tabelle 2.1
Beispiel
Deutsche Sonderzeichen in Unicode
Deklariere und initialisiere eine Variable :
double \u03C0 = 3.141592653589793;
Die Unicode-Escape-Sequenzen sind an beliebiger Stelle erlaubt, wo auch sonst ein Zeichen
stehen würde. So lässt sich an Stelle eines Anführungszeichens alternativ \u0027 schreiben,
was der Compiler als gleichwertig ansieht. Das Unicode-Zeichen \uffff ist nicht definiert und
kann bei Zeichenketten als Ende-Symbol verwendet werden.
Anzeige der Unicode-Zeichen
Die Darstellung der Zeichen – besonders auf der Konsole – ist auf einigen Plattformen noch
ein Problem. Die Unterstützung für die Standardzeichen des ASCII-Alphabets ist dabei weniger ein Problem als die Sonderzeichen, die der Unicode-Standard definiert. Unter ihnen ist
2 Ein Unicode-Editor unter Windows ist SC UniPad unter http://www.unipad.org/main/.
86
Elemente der Programmiersprache Java
der beliebte Smiley :-), der als Unicode \u263A (WHITE SMILING FACE) und \u2369 (WHITE
FROWNING FACE) :-( definiert ist. Das Euro-Zeichen ist unter \u20ac zu finden.
Tipp Sofern sich die Sonderzeichen und Umlaute auf der Tastatur befinden, sollten keine
Unicode-Kodierungen Verwendung finden. Der Autor von Quelltext sollte seine Leser nicht
zwingen, eine Unicode-Tabelle zur Hand zu haben. Die Alternativdarstellung lohnt sich daher
nur, wenn der Programmtext bewusst unleserlich gemacht werden soll.
Ein Versuch, den Smiley auf die Standardausgabe zu drucken, scheitert oft an der Fähigkeit
des Terminals beziehungsweise der Shell. Hier ist eine spezielle Shell nötig, die aber bei den
meisten Systemen noch in der Entwicklung ist. Und auch bei grafischen Oberflächen ist die
Integration noch mangelhaft. Es wird Aufgabe der Betriebssystementwickler bleiben, dies zu
ändern.3
Unicode-Tabellen unter Windows
Unter Windows legt Microsoft das nützliche Programm charmap.exe für eine Zeichentabelle
bei, mit der jede Schriftart auf ihre installierten Zeichen untersucht werden kann. Praktischerweise zeigt die Zeichentabelle auch gleich die Position in der Unicode-Tabelle an.
Unter der erweiterten Ansicht lassen sich zusätzlich Unicode-Unterbereiche auswählen, wie
etwa Währungszeichen oder unterschiedliche Sprachen. Im Unterbereich Latin finden sich
zum Beispiel die Zeichen aus der französischen Schrift (etwa »Ç« mit Cedille unter 00c7) und
spanischen Schrift (»ñ« mit Tilde unter 00F1), und bei Allgemeinen Interpunktionszeichen
findet sich das umgedrehte (invertierte) Fragezeichen bei 00BF.
Abbildung 2.1
Zeichentabelle unter Windows XP
3 Mit veränderten Dateiströmen lässt sich dies etwas in den Griff bekommen. So kann man beispielsweise
mit einem speziellen OutputStream-Objekt eine Konvertierung für die Windows-NT-Shell vornehmen, so
dass auch dort die Sonderzeichen erscheinen.
87
2.1
2
Sprachbeschreibung
2.1.2
Literale
Ein Literal ist ein konstanter Ausdruck. Es gibt verschiedene Typen von Literalen:
왘
Die Wahrheitswerte true und false
왘
Integrale Literale für Zahlen, etwa 122
왘
Zeichenliterale, etwa 'X' oder '\n'
왘
Gleitkommaliterale: 12.567 oder 9.999E-2
왘
Stringliterale für Zeichenketten wie "Paolo Pinkas"
2.1.3
Bezeichner
Für Variablen (und damit Konstanten), Methoden, Klassen und Schnittstellen werden Bezeichner vergeben – auch Identifizierer (von engl. identifier) genannt –, die die entsprechenden
Bausteine anschließend im Programm identifizieren. Unter Variablen sind dann Daten verfügbar, Methoden sind die Unterprogramme in objektorientierten Programmiersprachen, und
Klassen sind die Bausteine objektorientierter Programme.
Ein Bezeichner ist eine Folge von Zeichen, die fast beliebig lang sein kann (die Länge ist nur
theoretisch festgelegt). Die Zeichen sind Elemente aus dem gesamten Unicode-Zeichensatz,
und jedes Zeichen ist für die Identifikation wichtig. Das heißt: Ein Bezeichner, der 100 Zeichen lang ist, muss auch immer mit allen 100 Zeichen korrekt angegeben werden. Manche
C- und FORTRAN-Compiler sind in dieser Hinsicht etwas großzügiger und bewerten nur die
ersten Stellen.
Beispiel
Im folgenden Java-Programm sind die Bezeichner fett und unterstrichen gesetzt.
class Main
{
public static void main( String[] args )
{
System.out.println( "Hallo Welt" );
}
}
Dass String fett und unterstrichen ist, hat seinen Grund, denn String ist eine Klasse und kein
eingebauter Datentyp wie int. Zwar wird die Klasse String in Java bevorzugt behandelt – das
Plus kann Zeichenketten zusammenhängen –, aber es ist immer noch ein Klassentyp.
Aufbau der Bezeichner
Jeder Java-Bezeichner ist eine Folge aus Java-Buchstaben und Java-Ziffern, 4 wobei der
Bezeichner mit einem Java-Buchstaben beginnen muss. Ein Java-Buchstabe umfasst nicht nur
unsere lateinischen Buchstaben aus dem Bereich »A« bis »Z« (auch »a« bis »z«), sondern auch
4 Ob ein Zeichen ein Buchstabe ist, stellt die Funktion Character.isLetter() fest; ob er ein gültiger
Bezeichner-Buchstabe ist, sagen die Funktionen isJavaIdentifierStart() für den Startbuchstaben und
isJavaIdentifierPart() für den Rest.
88
Elemente der Programmiersprache Java
viele weitere Zeichen aus dem Unicode-Alphabet, etwa den Unterstrich, Währungszeichen
(wie die Zeichen für Dollar »$«, Euro »€«, Yen »¥«) oder griechische Buchstaben. Auch wenn
damit viele wilde Zeichen als Bezeichner-Buchstaben grundsätzlich möglich sind, sollte doch
die Programmierung mit englischen Bezeichnernamen erfolgen. Es ist noch einmal zu erwähnen, dass Java streng zwischen Groß-/Kleinschreibung unterscheidet.
Die folgende Tabelle listet einige gültige und ungültige Bezeichner auf.
Gültige Bezeichner
Ungültige Bezeichner
mami
2und2macht4
ichWeißIchMussAndréAnrufen
class
RAPHAEL_IST_LIEB
hose gewaschen
cláss
hurtig!
¥+E+U+R+O+$
null
Tabelle 2.2
Beispiele für Bezeichner in Java
mami ist ein Bezeichner, der nur aus Alphazeichen besteht und daher korrekt ist. Auch ¥€$ ist
korrekt. Der Bezeichner zeigt zusätzlich die in Java übliche Bezeichnerbildung; denn besteht
dieser aus mehreren einzelnen Wörtern, werden diese einfach ohne Leerzeichen hintereinander gesetzt, jedes Teilwort (außer dem ersten) beginnt jedoch dann mit einem Großbuchstaben. Leerzeichen sind in Bezeichnern nicht erlaubt, und daher ist auch hose gewaschen ungültig. Auch das Ausrufezeichen ist, wie viele Sonderzeichen, ungültig. ichWeißIchMussAndré
Anrufen ist jedoch wieder korrekt, auch wenn es ein Apostroph-é enthält. Treiben wir es weiter auf die Spitze, dann sehen wir einen gültigen Bezeichner, der nur aus griechischen Zeichen
gebildet ist. Auch der erste Buchstabe ist ein Zeichen, anders als in 2und2macht4. Und class
sowie null sind ebenso ungültig, da der Name schon von Java belegt ist.
Hinweis In Java-Programmen bilden sich Bezeichnernamen oft aus zusammengesetzten
Wörtern einer Beschreibung. Dies bedeutet, dass in einem Satz wie »schönes Wetter heute«
die Leerzeichen entfernt werden und die nach dem ersten Wort folgenden Wörter mit Großbuchstaben beginnen. Damit wird aus dem Beispielsatz anschließend »schönesWetterHeute«.
Sprachwissenschaftler nennen diese gemischte Groß- und Kleinschreibung Binnenmajuskel.
Die Tabelle im nächsten Abschnitt zeigt uns, welche Namen wir nicht verwenden können.
2.1.4
Reservierte Schlüsselwörter
Bestimmte Wörter sind als Bezeichner nicht zulässig, da sie als Schlüsselwörter durch den
Compiler besonders behandelt werden. Schlüsselwörter bestimmen die »Sprache« eines Compilers. Nachfolgende Zeichenfolgen sind Schlüsselwörter (beziehungsweise Literale im Fall
von true, false und null)5 und in Java daher nicht als Bezeichnernamen möglich:
5 Siehe dazu Abschnitt 3.9 (Keywords) der Sprachdefinition unter http://java.sun.com/docs/books/jls/
third_edition/html/lexical.html#3.9.
89
2.1
Index
#ifdef 61
#IMPLIED 849
#REQUIRED 848
$, innere Klasse 409, 414
%% 281
%, Modulo-Operator 113
%, Operator 303
%b 281
%c 281
%d 281
%e 281
%f 281
%n 281
%s 281
%t 281
%tD 647
%tR 647
%tT 647
%x 281
&&, logischer Operator 119
&, Generics 424
&amp 846
&apos 846
&gt 846
&lt 846
&quot 846
*, Multiplikations-Operator 112
*7 56
+, Additions-Operator 112
-, Subtraktions-Operator 112
..., Variable Argumentlisten 217
.class 498, 1341
.java.policy 1409
.keystore 1413
.NET Remoting 1207
/, Divisions-Operator 112
//, Zeilenkommentar 93
<exec>, Ant 1428
=, Zuweisungsoperator 111
== 193
?, Generics 425
@{code, JavaDoc} 432
@author, JavaDoc 432
@category, JavaDoc 432
@Deprecated 438, 540
@deprecated 540, 1339
@deprecated, JavaDoc 437
@Documented 1380
@exception, JavaDoc 432
@javax.management.MXBean
1394
@link, JavaDoc 432
@linkplain, JavaDoc 432
@literal, JavaDoc 432
@OneWay 1224
@Override 378, 397, 540, 1373
@param, JavaDoc 432
@Retention 1380
@return, JavaDoc 432
@see, JavaDoc 432
@SOAPBinding 1224
@SuppressWarnings 540, 657,
1373
@Target 1379
@throws, JavaDoc 432
@version, JavaDoc 432
@WebMethod 1224
@WebParam 1224
@WebResult 1224
@WebService 1224
@XmlElement 891
@XmlRootElement 891
[L 1346
^, logischer Operator 119
||, logischer Operator 119
100% Java-Kompatibel 75
1099, Port rmiregistry 1215
200, OK 1184
404, Not Found 1184
500, Internal Server Error 1184
80, Http-Port 1180
8080, Http-Port 1180
A
abrunden 300
abs(), Math 298
Absolutwert 173
Abstract Syntax Notation One
1413
Abstract Window Toolkit 895
abstract, Schlüsselwort 391–392
AbstractAction, Klasse 930
AbstractBorder, Klasse 932
AbstractButton, Klasse 927
AbstractTableModel, Klasse 1015
abstrakte Klasse 391
abstrakte Methode 392
Absturz der Ariane 5 126
Accelerator 981
accept(), ServerSocket 1173
Accepted 1184
Access Controller 1401
Accessibility 897
Accessible, Schnittstelle 1059
AccessibleObject, Klasse 1353,
1368
Action, Schnittstelle 930, 980
ACTION_PERFORMED, ActionEvent 913
Action-Command 929
ActionListener, Schnittstelle 916,
923, 925
Activatable, Klasse 1221
Activation Daemon 1222
activation.jar 1196
Adapter 681
Adapter, MBean 1388
Adapterklasse 920
add(), Container 906, 940
addActionListener(), JButton 925
addItem(), JComboBox 994
Addition 112
addKeyListener(), Component
936
addWindowListener() 919
Adjazenzmatrize 215
Adjustable, Schnittstelle 965
AdjustmentEvent, Klasse 964
AdjustmentListener, Schnittstelle 967
Adleman, Leonard M. 1415
Adler32, Klasse 819
affine Transformation 1134
AffineTransform, Klasse 1135
Age, Response-Header 1185
Aggregationsfunktionen 1336
Ahead-Of-Time Compiler 1436
AIFF 538
Aktor 181
aktueller Parameter 152
1457
Index
Al Gore 1143
AlgorithmParameterSpec, Schnittstelle 1419
Algorithmus 655
-alias 1413
allgemeine Semaphor 603
Allow, Entity Header 1185
allowSystemProperty 1409
AllPermission 1410
AlphaComposite, Klasse 1104
AlreadyBoundException 1216
AM_PM, Calendar 642
Amigos 180
Anführungszeichen 109
angehäufte if-Anweisungen 133
angepasster Exponent 292
Anhängen an Strings 244
Anhängen von Zeichen 253
Animierter Cursor 1128
Anmelde-/Versendesystem 1227
AnnotatedElement, Schnittstelle
1361, 1381
Annotation, Schnittstelle 1382
Annotationen 539
annotiert 1339
anonyme innere Klasse 413
Anpassung 455
Ant 1428, 1446
Antialiasing 1075, 1134
Anweisung 92
Anweisungssequenz 99
Anwendungsfall 181
ANY 848
Anzahl Einträge 1337
Apache Axis 1223
Apache Commons CLI 228
Apache Commons Codec 280
Apache Commons Collections
715
Apache Commons Compress 806
Apache Commons DBCP 1310
Apache Commons IO 743, 762
Apache Commons Logging 1399
Apache Commons/Net 1178–
1179
Apache Jakarta HttpClient 1178
append(), StringBuffer/StringBuilder 254
Appendable, Schnittstelle 254,
772
Apple, Look-And-Feel 1045
1458
Applet 56, 65, 1267
AppletContext 538, 1271, 1276
appletviewer 1435
Applikations-Klassenlader 515
APRIL, Calendar 638
Ära 651
Arc2D, Klasse 1089–1090
Arcus-Funktionen 299
Area, Klasse 1091
AreaAveragingScaleFilter, Klasse
1122
Argument der Funktion 152
ArithmeticException 308, 480
arithmetische Typen 100
arithmetischer Operatorer 112
Array 204
Array, Klasse 1350
arraycopy(), System 219
Array-Grenze 61
ArrayIndexOutOfBoundsExceptions 480
ArrayList 662
ArrayList, Klasse 361, 656, 661,
669, 677
ArrayStoreException 381, 683
Array-Typen 100
Artefakte 1125
Aschermittwoch 640
ASCII-Zeichen 85
asin(), Math 299
asList(), Arrays 226, 681, 690
ASN.1 1413
assert, Schlüsselwort 489
Assertion 489
AssertionError 489
assignment 111
Assistive technology 1059
Assoziation 359
assoziativer Speicher 662
Astronomie 623
Atlantic City 64
atomar 574
atomare Komponente 906
Atomuhr 624
Attribute 179, 844
Attributinhalte 882
AU 538
AudioClip, Klasse 537
aufgeschobene Initialisierung
161
Aufruf einer Funktion 150
Aufrunden 300
AUGUST, Calendar 638
Ausdruck 111
Ausdrucksanweisung 96–97
Ausführungsstrang 543
Ausgabeformatierung 624
Ausnahme 61
Ausnahmenbehandlung 61
Ausprägung 179
Ausprägungsvariable 183
ausschließendes Oder 119
äußere Schleife 143
Auswahlmenü 992
Auszeichnungssprachen 843
authentication required 1151
Authenticator, Klasse 1157
Authentifizierung 1412
Autoboxing 200
Auto-Commit 1328
Automatische Typanpassung 122,
371
Autorisierung 1412
await(), Condition 593
AWT 895
AWTEvent, Klasse 913
AWTEventListener, Schnittstelle
1059
AWT-Event-Thread 919, 1053
AWT-Input 566
AWT-Motif 566
B
Bad Gateway 1184
Bad Request 1184
barrier 562
Base64 280
Base64 Encoding 1196
baseline 1080
Basic Multilingual Plane 86
BasicStroke, Klasse 1105
BatchUpdateException 1320
Beautifier 1452
bedingte Compilierung 61
Bedingungsoperator 121, 172
Behinderungen, Accessibility 897
Beispielprogramme der Insel 49
Benutzerdefinierter Klassenlader
515
Benutzerinteraktion 1060
Beobachter-Pattern 448
Index
Berkeley-Socket Interface 1166
Betrag 298
BevelBorder, Klasse 932
Bezeichner 88
Bézier-Kurve 1091
Bias 292
biased exponent 292
bidirektionale Beziehung 359
BigDecimal, Klasse 308, 313
Big-Endian 309
BigInteger, Klasse 308
Bilder skalieren 1121
Bildlaufleiste 962
Bildschirmabzug 1063
binäre Semaphor 603
binäre Suche (binary search) 722
binärer Operator 110
Binary and Floating-Point
Arithmetic 292
binarySearch(), Arrays 225, 687
bind(), Registry 1215
Binnenmajuskel 89
bin-Pfad 72
biometrisches System 1412
Birrel 1205
Bitmenge 727
BitSet, Klasse 727
Bitttage 640
bitweise Manipulation 727
bitweises Exklusives Oder 167
bitweises Komplement 120
bitweises Oder 121, 167
bitweises Und 121, 167
bitweises Xor 121
Block 99
BlockingQueue, Schnittstelle 701
Block-Tag 434
boolean, Datentyp 101
Boolean, Klasse 202
Bootstrap-Klassenlader 515
Border, Schnittstelle 932
BorderFactory, Klasse 934
BorderLayout, Klasse 948, 951
bound properties 457
BoundedRangeModel, Schnittstelle 964
Bound-Properties 456
Boxing 200
BoxLayout 961
BoxLayout, Klasse 947, 961
break 143–144
BreakIterator, Klasse 275
brighter(), Color 1099
Brightness 1100
Browser-Version 523
Bruch 317
Bruchzahl 291
Bucket, Hash-Table 713
BufferedImage, Klasse 1118
BufferedInputStream, Klasse 763,
789
BufferedOutputStream 787
BufferedReader, Klasse 763, 789
BufferedWriter 787
build.xml 1446
ButtonGroup, Klasse 973
Byte 166
byte, Datentyp 101, 106, 291
Byte, Klasse 197
ByteArrayInputStream, Klasse
786
ByteArrayOutputStream, Klasse
785
Bytecode 57, 95
Bytecode Verifier 1401
BZip2 806
C
C 55
C# 200
C++ 55, 178
Cache, Bilder 1127
Cache-Control 1185
CachedRowSet, Schnittstelle
1322
CachedRowSetImpl, Klasse 1322
CAG (Constructive Area
Geometry) 1091
Calendar, Klasse 624, 635
call by reference 192
call by value 152, 191
Callable, Schnittstelle 569
CallableStatement, Schnittstelle
1310
CANON_EQ, Pattern 264
Canvas 1109
CAP_BUTT, BasicStroke 1106
CAP_ROUND, BasicStroke 1106,
1108
CAP_SQUARE, BasicStroke 1106
CardLayout, Klasse 948
Caret 1006
CASE_INSENSITIVE, Pattern 264
CASE_INSENSITIVE_ORDER,
String 691
Cast 120
Cast, casten 122
catch 465
CDATA 848
CDC (Connected Device Configuration) 1282
ceil(), Math 300
Central European Time 632
CERN 1180
Certificate Authority, CA 1412
CET 632
ChangeListener, Schnittstelle 963
char, Datentyp 101, 109
Character, Klasse 233
CharArrayReader, Klasse 784
CharArrayWriter, Klasse 783
CharSequence, Schnittstelle 238,
439
Checkbox, Klasse 968
checked exception 480
checkError() 775
Checksum, Schnittstelle 817
choice box 992
Christi Himmelfahrt 640
Cipher, Klasse 1420
CipherInputStream, Klasse 1420
CipherOutputStream, Klasse
1420
class literal 498
Class Loader 512
Class, Klasse 498, 1340
class, Schlüsselwort 319, 1349
ClassCastException 480
ClassLoader, Klasse 515, 1403
ClassNotFoundException 1341–
1342
CLASSPATH 514, 1437, 1443
-classpath 514, 1437
Class-Path Wildcard 1438
Client 1167, 1207
Client/Server-Kommunikation
1172
Clip-Bereich 1070
Clipboard 982, 1046
Clipboard, Klasse 1046
Clipper 1415
clipping 1095
1459
Index
Clipping-Bereich 1130
clone() 504
clone(), Arrays 218
CloneNotSupportedException
505, 507
Closeable, Schnittstelle 766
closePath(),Path2D 1094
Cloudscape 1290
Clustering, Hash-Tabelle 713
cmd.exe 527
code point 85
Codebase 1408
CollationKey, Klasse 261
Collator, Klasse 258, 685, 691
Collection API 655
Collection, Schnittstelle 657–658
Collections, Klasse 656
Color, Klasse 1096
com.sun.image.codec.jpeg, Paket
1110
com.sun.net.httpserver, Paket
1186
com4j 1433
combo box 992
ComboBoxModel, Schnittstelle
992
Command Model 916
Command not found 71
command.com 527
Comparable, Schnittstelle 400,
685
Comparator, Schnittstelle 685
compare(), Comparator 686
compareTo(), Comparable 686
compareToIgnoreCase(), String
241
compile(), Pattern 263
Compiler 95
Component, Klasse 931
ComponentEvent, Klasse 915
ComponentListener, Schnittstelle 939
ComponentUI, Klasse 991
Composite Pattern 940
Composite, Schnittstelle 1104
CompoundBorder, Klasse 932
concat(), String 245
CONCUR_UPDATABLE, ResultSet 1318, 1323
ConcurrentHashMap, Klasse 725
1460
ConcurrentLinkedQueue, Klasse
725
ConcurrentMap, Schnittstelle
725
ConcurrentModificationException 669
ConcurrentSkipListMap, Klasse
662
ConcurrentSkipListSet, Klasse
725
Condition, Schnittstelle 593
Connected Limited Device Configuration (CDC) 1281
Connection 1185
Connection, Schnittstelle 1300
Connector/J 1291
Connector-Level 1388
Console, Klasse 781
const, Schlüsselwort 161–162
const-korrekt 162
Constraint-Properties 456
Constructor, Klasse 1359
Contact Port 1167
Container 655
contains(), Shapre 1094
contains(), String 238
containsKey(), Map 706
Content Handler 1154
Content-Base 1185
Content-Encoding 1185–1186
contentEquals(), String 256
Content-Handler 1151
ContentHandler, Schnittstelle
865
Content-Language 1185
Content-Length 1185
Content-Location 1185
Content-MD5 1185
Content-Pane 907
Content-Range 1185
Content-Type 1185
continue 143, 145
Controller 991
Copy-Konstruktor 346, 504
copyOf(), Arrays 222
copyOfRange(), Arrays 222
CopyOnWriteArrayList, Klasse
669, 727
CopyOnWriteArraySet, Klasse
727
CORBA (Common Object Request
Broker Architecture) 1207,
1220
cos(), Math 299
cosh(), Math 300
Cosinus 299
Cosmo 164
-cp 514, 1438
Cp037 278
Cp850 278
CRC32, Klasse 818
CREATE TABLE 1337
createCompatibleImage(), GraphicsConfiguration 1118
Created 1184
createGraphics(), BufferedImage
1118
createStatement(), Connection
1310
Crimson 855
Cryptographic Service Providers
1402
CSV (Comma Separated Values)
841
CubicCurve2D, Klasse 1089
currency, Datentyp 109
currentThread(), Thread 552
currentTimeMillis(), System 525
Cursor 1127
curveTo(), GeneralPath 1091
custom tag library 1244
Customization 455
CVM 1282
cxxwrap 1433
CyberNeko 894
CyclicBarrier, Klasse 562
D
-D 523
Dämon 564
dangling pointer 355
Dangling-Else Problem 131
darker(), Color 1099
dash attribute 1105
Data Hiding 327
Data Query Language 1335
Database Management Systems
1289
DatabaseMetaData, Schnittstelle
1332
Index
DataFlavor, Klasse 1048
Datagramme 1189
Datagrammsockets 1187
DatagramPacket, Klasse 1189
DatagramSocket, Klasse 1187,
1189
DataInput, Schnittstelle 754, 823
DataInputStream, Klasse 795
DataOutput, Schnittstelle 754,
823
DataOutputStream, Klasse 795
Datapoint 57
DataSource 1307
DataSource, Schnittstelle 1307
DataTruncation, Klasse 1318
DATE, Calendar 642
Date, General Header Fields 1185
Date, Klasse 624, 634
DateFormat, Klasse 284, 624,
647, 652
Dateiauswahl-Dialog 1040
Dateiauswahldialog 1040
Dateinamenendungen 242
Dateiverknüpfung 737
Datenbankausprägung 1289
Datenbankschema 1289
Datenbankverbindung 1305
Datenbasis 1289
Datenkompression 805
Datenstrukturen 655
Datentyp 100
Datenzeiger 754
Datumswerte 624
DAY_OF_MONTH 642
DAY_OF_WEEK, Calendar 642
DAY_OF_WEEK_IN_MONTH,
Calendar 642
DAY_OF_YEAR, Calendar 642
DBMS 1289
-Dcom.sun.management.jmxremote 1392
Deadlock 544, 590
DECEMBER, Calendar 638
DecimalFormat, Klasse 286
Decompiler 1450
Decrement 120
default 134
default, Schlüsselwort 1378
DEFAULT_LAYER 1033
DefaultHandler, Klasse 865–866
Default-Konstruktor 186, 343
DefaultListCellRenderer, Klasse
1002
DefaultListModel, Klasse 998,
1001
DefaultMutableTreeNode, Klasse
1028
Default-Paket 230
defaultReadObject(), ObjectInputStream 830
DefaultTableCellRenderer, Klasse
1020
DefaultTableModel, Klasse 1018
defaultWriteObject(), ObjectOutputStream 829
DEK 306
Dekonstuktor 510
Dekoration 905
delegate 74
Delegation Model 916
DELETE 1181
delete() 60
delete(), StringBuffer/StringBuilder 255
Delimiter 266, 274
Deployment-Descriptor 1234
Deprecated 436
deprecated 1436
-deprecation 437
Deque 700
Deque, Schnittstelle 661
Derby 1290
dereferenced-Meldung 1218
Dereferenzierung 128
deriveFont(), Font 1082
DES (Data Encryption Standard)
1418
Design-Pattern 447
Desktop, Klasse 529
Dezimalpunkt 292
DGC 1218
Dialog 1035–1036
Digitale Unterschriften 1414
DirectX 74
Distributed Component Object
Model (DCOM) 1207
distributed GC 1218
Dividend 112
Divider 944
Division 112
Divisionsoperator 112
Divisor 112
-Djava.rmi.dgc.leaseValue 1218
-Djava.rmi.server.codebase 1220
-Djava.security.debug 1406
-Djava.security.manager 1407
-Djava.security.policy 1408
-Djdbc.drivers 1301
dll-Dateien 1427
DnD, Drag & Drop 1050
DNS 1143, 1276
do/while-Schleife 138
Doc Comment 431
Doclet 435, 1340
DOCTYPE 849
Document Object Model 854
Document Type Definition 847
Document, Klasse 871
DocumentBuilderFactory 856
Dokumentationskommentar 431
DOM 854
DOM Level 3 XPath 885
Domain Name Service 1143
Domain Name System 1189
Domain-Name-Server 1276
DOMBuilder, Klasse 872
Donald E. Knuth 306
Doppel-Pufferung, Swing 944
DOS-Programme 527
DOTALL, Pattern 264
double 292
double, Datentyp 101
Double, Klasse 197
Double-Buffering, Swing 944
doubleToLongBits(), Double 510
DQL 1335
Drag & Drop 1050
Drag and Drop 897
draw(Shape), Graphics2D 1089
draw3DRect(), Graphics 1099
drawImage(), Graphics 1113
drawLine(), Graphics 1076
drawString(), Graphics 1080
Drehfeld 1002
DriverInfo 1306
DriverManager, Klasse 1301,
1304
Drucken 1136
DSAPrivateKeySpec, Klasse 1420
DSN 1189
DST_OFFSET, Calendar 643
DTD 847
DTDHandler, Schnittstelle 865
1461
Index
Durchschnittswerte 1336
Durchschuss 1086
-Duser.timezone 638
dynamic invocation 1369
dynamic linked libraries 1427
Dynamic MBeans 1389
Dynamische Datenstrukturen
655
Dynamischer Methodenaufruf
1371
Dynamisches Layout 905
E
-ea 490
EBCDIC 799
EBCDIC-Zeichensatz 278
Echozeichen 1006
Eclipse 73
Eclipse Translation Packs 75
EclipseME 1284
ECML 1240
Editor-Kit 1010
Eiche 55
Eigenschaft 455
einfache Eigenschaft 455
einfache Hochkommata 109
Einfachvererbung 365
eingeschränkte Eigenschaft 456
Einstelliger Operator 110
Electronic Commerce Modeling
Language 1240
Element suchen 721, 723
Element, Klasse 874
Element, XML 844
elementare Anweisung 99
Elementklasse 409
ElementType, Aufzählung 1379
Ellipse, UML 181
Ellipse2D, Klsse 1089
else 130
Elternklasse 363
Embedded Java 68
EmptyBorder, Klasse 932
EmptyStackException 480, 699
enable assertions 490
encoding 278
end caps 1106
Ende der Welt 165
Endlosschleife 137
endorsed-Verzeichnis 514, 519
1462
Endpoint, Klasse 1225
endsWith(), String 242
ENGLISH 626
ensureCapacity(), List 679
Enterprise Edition 68
entfernte Methoden 1205
entfernte Methodenaufrufe 1205
entfernte Objekte 1211
Entitäten 846
Entity 1185
Entity Header 1185
Entity-Body 1185
Entity-Header 1183, 1185
EntityResolver, Schnittstelle 865
entrySet(), Map 709
Entwurfsmuster 447
Enum, Klasse 426
enum, Schlüsselwort 339, 489
Enumeration, Schnittstelle 665
Enumerator 665
EnumMap, Klasse 444
EOFException 753
equals() 500–501, 1148
equals(), Arrays 220
equals(), Object 193, 500
equals(), Point 194
equals(), String 256
equalsIgnoreCase(), String 240
ERA, Calendar 642
Erdzeitalter 166
Ereignis, Gui 913
Ereignisauslöser 916
Ereignisschlange 1053
Ereignisse 455
Ergebnistyp 148
erreichbar, catch 475
erreichbarer Quellcode 154
Error, Klasse 476, 480
ErrorHandler, Schnittstelle 865
erweiterte for 211
Erweiterungs-Klassenlader 515
Erzeuger/Verbraucher 596
Escape-Sequenz 109
Escape-Zeichen 239
Escher, Maurits 175
ETag 1185
EtchedBorder, Klasse 932
Eulersche Zahl 297
Euro-Zeichen 87
Event Queue 1053
Event-Dispatching-Thread 919
EventFilter, Schnittstelle 861
EventListener, Schnittstelle 452
EventObject, Klasse 452
Eventquelle 916
EventQueue, Klasse 1053, 1055,
1058
Events 455
Event-Source 916
Excelsior JET 1436
Exception 61
Exception, Klasse 476
ExceptionInInitializerError 336
Exchanger, Klasse 562
exec(), Runtime 526
executeQuery(), Statement 1312
executeUpdate(), Statement 1312
Executor, Schnittstelle 566
ExecutorService, Schnittstelle
567
Exemplar 179
Exemplarinitialisierer 353
Exemplarinitialisierungsblock
416
Exemplarvariable 183, 330
exit(), System 228
EXIT_ON_CLOSE, JFrame 901
exklusives Oder 119
Expires 1185
explizite Typanpassung 122
explizite Typumwandlung 373
explizites Klassenladen 513
Explorer 65
Exponenten 292
Exponentialwert 302
exportObject(), UnicastRemoteObject 1215
expression 111
extends, Schlüsselwort 363, 403
eXtensible Markup Language 844
Extension-Verzeichnis 514
F
Fabrik 448
Fabrikmethode 358
Facelets 1266
Factory 448
Faden 543
Fakultät 312
Fall-Through 134
false 101
Index
Farbauswahl 1038
Farbe 1096
Farbmodell 1101
Farbsättigung 1100
FEBRUARY, Calendar 638
Federal Information Processing
Standards Publication 1415
Fee, die gute 162
Fehler 477
Fehlercode 465
Feld 204
Feld-Typen 100
fencepost error 141
Fenster 900
Fenstermenü 976
Field, Klasse 1352–1353, 1363
FIFO-Prinzip 661
File,Klasse 732
file.encoding 799
File.separatorChar 733
FileChannel, Klasse 747
FileDescriptor, Klasse 762
FileFilter, Klasse 1040
FileFilter, Schnittstelle 741
FileInputStream, Klasse 759
FilenameFilter, Schnittstelle 741
FileNotFoundException 466, 477
FileOutputStream, Klasse 759
FilePermission 1410
FileReader, Klasse 758
FileWriter, Klasse 756
fill(), Arrays 221
fill(), Collections 720
fillInStackTrace(), Throwable 485
FilteredRowSet, Schnittstelle
1322
FilterInputStream, Klasse 795
FilterOutputStream, Klasse 795
FilterReader, Klasse 795
FilterWriter, Klasse 795
final 160
final, Schlüsselwort 337, 389–
390, 1349
finale Klasse 389
finale Methode 390
finale Werte 352
finalize() 510
Finalizer 510
finally, Schlüsselwort 472
findClass(), ClassLoader 516
Fingerabdruck 1414
FIPS 1415
Firewall 1220
First Person, Inc. 56
First-In-First-Out 661
Fitts’s Law 949
Five-Nine System 1411
flache Kopie 712
flache Kopie, clone() 507
Flaubert, Gustave 1435
Fließkommazahl 100, 108, 291
Fließpunktzahl 291
float 292
float, Datentyp 101
Float, Klasse 197
floatToIntBits(), Float 510
floor(), Math 300
FlowLayout, Klasse 947, 949
Fluchtsymbole 109
Flushable, Schnittstelle 766
FocusEvent, Klasse 915
FocusListener, Schnittstelle 935
Fokus 935
Font, Klasse 908, 1081
FontFormatException 1084
FontMetrics, Klasse 1085
FontRenderContext, Klasse 1087
Forbidden 1184
formale Typ-Parameter 419
formaler Parameter 152
format() 775
format(), Format 285
format(), String 281
Format, Klasse 284
Formatierungsanweisungen 648
Formatierungsstrings 651
Format-Spezifizierer 281
Format-String 281
Formatter, Klasse 282
forName(), Class 1341
for-Schleife 140
Fortschaltausdruck 140
Fortschrittsbalken 974
Fragezeichenoperator 110
Frame 900
Frame, Klasse 902
FrameMaker 50
FRANCE 626
free() 60
FRENCH 626
Fronleichnam 640
FULL, DateFormat 649
Füllfaktor 713
Füllmuster 1108
Füllung, Paint 1095
Funktion 94, 150
Funktionsaufruf 95
Funktionszeiger 443
G
Ganzzahl 100
ganzzahliger Datentyp 106
Garbage-Collector 60, 182, 186,
342, 355
Gauß-Normalverteilung 308
GC 60, 342, 355
GCC 1427
gcj 1436
gebundene Eigenschaft 456–457
gebundene Property 943
Geburtsdatum 644
Geburtstagsparadoxon 1415
gegenseitiger Ausschluss 574,
577
Geltungsbereich 104
General-Header 1183
GeneralPath, Klasse 1091
Generic Connection Framework
1282
Generics 419
generischer Typ 419
-genkey 1413
geordnete Liste 661
Georg Shar 439
geprüfte Ausnahme 480
GERMAN 626
GERMANY 626
geschachtelte Alternativen 132
geschachtelte Ausnahme 485
geschachtelte Top-Level Klasse
408
GET 1181
get(), List 670
get(), Map 705
getBytes(), ResultSet 1317
getBytes(), String 278
getChars(), String 244
getColumnClass(), TableModel
1015
getColumnCount(), TableModel
1015
1463
Index
getColumnName(), TableModel
1015
getConnection(), DriverManager
1301
getContentPane(), JFrame 907
getContextClassLoader(), Thread
520
getDefaultToolkit(), Toolkit 899
getenv(), System 525
getInstance(), Calendar 638
GET-Methode 1159, 1180
getPriority(), Thread 563
getProperties(), System 521
getProperty(), Properties 715
getResource() 768
getResourceAsStream() 768
getRowCount(), TableModel
1015
getStackTrace(), Thread 487
GetStringUTFChars 1429
getTableCellEditorComponent(),
TableCellEditor 1023
Getter 329
getText(), JLabel 907
getText(), JTextComponent 1005
getTimeInMillis(), Calendar 641
getValueAt(), TableModel 1015
ggT 308
GIF 1109
Glass-Pane 1032
Gleichheit 194
Gleitkommazahl 291
globale Variable 104
Glyphe 1080
GMST 623
Goldsäule 165
Gosling, James 55
goto, Schlüsselwort 146
GradientPaint 1095
Grammatik 85
grant-Anweisung 1408
Granularität von Threads 564
Graphics Interchange Format
1109
Graphics, Klasse 1070
Graphics2D, Klasse 1070
GraphicsEnvironment, Klasse
1083
Green-Projekt 56
Greenwich Mean Siderial Time
623
1464
GregorianCalendar, Klasse 636
Gregorianischer Kalender 635
GridBagConstraints, Klasse 956
GridBagLayout, Klasse 948, 955
GridLayout, Klasse 948, 954
Groovy 531
Groß-/Kleinschreibung 89, 242,
245
größter gemeinsamer Teiler 308
GroupLayout, Klasse 948
Grundlinie 1080
Grundton 1100
Gruppenfunktionen 1336
guard 597
guarded action 597
guarded wait 597
GUI-Builder 1339
gültig, XML 847
Gültigkeitsbereich 104
gzip 1186
GZIPInputStream, Klasse 806
GZIPOutputStream, Klasse 806
H
Halbierungssuche 722
Hashcode 507, 712
hashCode(), Object 507
Hash-Funktion 507, 712
HashMap, Klasse 662, 702
HashSet, Klasse 661, 694
Hash-Tabelle 702
Hashtable 702
Hash-Verfahren 1414
Hash-Wert 507
Haupt-Klasse 93
HEAD 1181
Header-Datei 61, 1426
HEAD-Methode 1181
Heap 182
heavyweight component 896
Helligkeit 1100
hexadezimale Zahlen 107
Hexadezimalform 106
Hibernate 1337
HierarchyEvent, Klasse 915
high level event 914
Hilfsklasse 357
Hoare 577
Holder, Klasse 217
Horcher 916
Host 1143
Host-Adresse 1161
Host-Name 1143
HotJava 56
HotSpot 355
HOUR, Calendar 642
HOUR_OF_DAY, Calendar 642
HP 57
HSB 1100
HSQLDB 1290
HTML 843, 1180
HTTP 1144, 1180
HTTP 0.9 1183
HTTP 1.0 1180
http.proxyHost 1150
http.proxyPort 1150
HttpClient 1178
HttpHandler, Schnittstelle 1187
HTTP-Header 1153
https.ProxyHost 1151
https.ProxyPort 1151
HttpServer, Klasse 1186
Hue 1100
Hyersonic 1290
Hyperbolicus Funktionen 300
Hypertext Transfer Protocol
1144, 1180
I
i18n.jar 513
IBM 1205, 1339
Ibn Mû sâ Al-Chwâ rismî 655
ICCCM 1047
Ich-Ansatz 179
ICMP 1203
ICO 1111
Icon, Schnittstelle 910–911
Identifizierer 88
Identität 194, 500
identityHashCode(), System 509
IdentityHashMap, Klasse 709
IEEE-754 Standard 108, 114, 292
IEEEremainder(), Math 303
IETF 1143–1144
if-Anweisung 129
IFC 896
if-Kaskade 133
ignorierte Statusrückgabewerte
467
IIOP 1220
Index
IllegalArgumentException 480–
481, 483
IllegalMonitorStateException
480, 596, 601
IllegalThreadStateException 548
Image, Klasse 1110
ImageIcon, Klasse 910–911
ImageIO, Klasse 1110–1111
ImageObserver, Schnittstelle
1113
Imagination 55
immutable 236
imperative Programmiersprache
92
implizites Klassenladen 513
import, Schlüsselwort 188, 229
Increment 120
Index 204, 207
Indexed-Properties 456
indexierte Variablen 207
indexOf(), String 239
IndexOutOfBoundException 209
indizierte Eigenschaft 456
InetAddress 1163
InetAddress, Klasse 1162
InetSocketAddress, Klasse 1171
infinity 293
InheritableThreadLocal, Klasse
611
Inline-Tag 434
innere Klasse 407
innere Schleife 143
InputMethodEvent, Klasse 915
InputMismatchException 273
InputStream, Klasse 767
InputStreamReader, Klasse 279,
800
InstallShields 1279
instanceof, Schlüsselwort 394,
1347
InstantiationException 371, 1362
Instanz 179
Instanzinitialisierer 353
Instanzvariable 183
instrumentalisierte Objekte 1388
int, Datentyp 101, 106, 291
Integer, Klasse 197
integraler Typ 100
Integritätsprüfung von Nachrichten 1415
Inter Client Communication Convention Manual 1047
Interaktionsdiagramm 181
Interface 64, 391, 395
interface, Schlüsselwort 396
Interface/Implementation-Pair
1015
Interface-Typen 100
intermediate container 944
internal frame 1033
Internal Server Error 1184
Internationalisierung 628
interne Fenster 1033
Internet Control Message Protocol
1203
Internet Engineering Task Force
1143–1144
Internet Foundation Classes 896
Internet Media-Types 1185
Internet Protocol 1144
Internet-Explorer 65
Inter-ORB Protocol 1220
Interrupt 557
interrupt(), Thread 557, 601
interrupted(), Thread 559
InterruptedException 529, 554,
558, 593, 601
InterruptedIOException 1173
Intersolv 1296
Intervall 141
Introspection 455, 1339
invalidate(), Component 942
InvalidClassException 822, 832
Invarianz 424
Invocation-API 1423
InvocationEvent, Klasse 1056
InvocationTargetException 1362
invoke(), Method 1369
invokeAndWait(), SwingUtilities
1055
invokeLater(), SwingUtilities 976,
1055
Invoker-Servlet 1260
IOException 466, 477
IP 1144
IP-Adressen 1161
ipconfig 1203
iPhone 58
IP-Nummer 1143
is- Methode 329
isCellEditable(), TableModel
1015, 1017
isInterrupted(), Thread 557
isNaN(), Double/Float 294
ISO Country Code 625
ISO Language Code 625
ISO-639 Code 625
ISO8859-1 85
ISO-Abkürzung 627
Ist-Eine-Art-Von-Beziehung 391
ITALIAN 626
ItemEvent, Klasse 968
ItemListener, Schnittstelle 968,
971, 974, 995
ItemSelectable, Schnittstelle 971
itemStateChanged(), ItemListener 971
Iterable, Schnittstelle 441, 664
Iterator 665
Iterator, Schnittstelle 441, 665
Ivar Jacobson 180
J
J++ 75
J/Direct 74
J2EE 68
J2ME 68
JAAS 1402, 1411
Jad 1451
Jahr 642, 651
JAI 1111
Jakarta Commons Math 317
Jakarta Taglibs Project 1247
JANUARY, Calendar 638
JAPAN 626
JAPANESE 626
Jar 1439
jar, Dienstprogramm 1435, 1439
-jar, java 1443
Jar-Datei 1155
JarFile, Klasse 816, 1156
jarsigner, Dienstprogramm 1414,
1435
JarURLConnection, Klasse 1156
Java 56, 1435
Java 2D API 897, 1074
Java Accessibility 1059
Java API for XML Parsing 855
Java Authentication and Authorization Service 1411
1465
Index
Java Authentication and Authorization Service (JAAS) 1402
Java Bean 455
Java Cryptography Architecture
1401
Java Cryptography Extension
(JCE) 1401
Java Database Connectivity 1295
Java DB 1290
Java Decompiler 1451
Java Document Object Model
855
Java Foundation Classes 896
Java Foundation Classes (JFC)
1074
Java Image Management Interface
1111
Java Look&Feel 1044
Java Management Beans 1389
Java Management Extensions
1388
Java Message Service 1227
Java Native Interface 1423
Java Network Launcher Protocol
1279
Java Object Serialization 820
Java Persistence API (JPA) 1337
Java Runtime Environment 1442
Java Secure Socket Extension
1151, 1204
Java Service Wrapper 1453
Java Virtual Machine 57
Java Virtual Machine Process
Status Tool 1444
Java Virtual Machine Statistics
Monitoring Tool 1444
java, Dienstprogramm 1437
java, Paket 230
java.awt.event, Paket 913
java.awt.geom, Paket 1075
java.beans, Paket 836
java.endorsed.dirs 519
java.ext.dirs 514
java.lang.ref, Paket 1287
java.naming.factory.initial 1310
java.net, Paket 1143
java.nio.charset, Paket 279
java.rmi.server.codebase 1220
java.rmi.useCodebaseOnly 1220
java.security 1409
java.text, Paket 275
1466
java.util.concurrent, Paket 726
java.util.concurrent.atomic, Paket
583, 608
java.util.concurrent.lock, Paket
577
java.util.jar, Paket 806, 1440
java.util.regex, Paket 262
java.util.zip, Paket 806
Java-Beans 1339
JavaBeans Activation Framework
(JAF) 748, 1196
JavaBeans Persistence 820
javac, Dienstprogramm 1435
Java-Cryptography-API 1401
JavaDoc 430
javadoc 1435
javadoc, Dienstprogramm 433
JavaDoc-Tag 1339
javah, Ant 1425
javah, Dienstprogramm 1425
JavaMail API 1196
JavaScript 64, 1276
Java-Security-Model 59
JavaServer Faces 1266
JavaServer Page 1230
JavaSoft 57
javaw, Dienstprogramm 1438
javax, Paket 230, 497
javax.annotation, Paket 541
javax.crypto, Paket 1401
javax.jws, Paket 542, 1224
javax.microedition.midlet, Paket
1286
javax.net, Paket 1204
javax.script, Paket 530
javax.sound, Paket 537
javax.sound.midi, Paket 538
javax.swing, Paket 900
javax.swing.text, Paket 1004
javax.swing.undo, Paket 1051
javax.xml.bind.annotation, Paket
542, 891
javax.xml.ws, Paket 542
Jawin 1433
JAXB 890
JAXBContext, Klasse 892
Jaxen 871, 885
JAXP 855–856
JAX-WS 1223
JBP, JavaBeans Persistence 820
JButton, Klasse 923, 927
JCA 1401
JCheckBox, Klasse 927
JCheckBoxMenuItem, Klasse 978
jCIFS 749
JColorChooser, Klasse 1038
JComboBox, Klasse 992
jconsole, Dienstprogramm 1391
jdb 1435
JDBC 1295
JDBC 1.0 1297
JDBC 2.0 API 1297
JDBC 2.0 Optional Package API
1298
JDBC 2.1 core API 1297
jdbc.drivers 1301
JDBC-ODBC Bridge Treiber 1296
JDBCRowSet, Schnittstelle 1322
JDesktopPane, Klasse 1033
JDialog, Klasse 1036
JDOM 855
JDOMResult, Klasse 889
JDOMSource, Klasse 889
JEditorPane, Klasse 1004, 1010
Jetty 1232
JFC 896
JFileChooser, Klasse 1040
JFormattedTextField, Klasse
1004, 1007
JFrame, Klasse 900, 1071
JGoodies Looks 1046
Jimi 1111
Jindent 1453
JIT 57
JLabel, Klasse 906
JLayeredPane, Klasse 1033
jlGui 538
JList, Klasse 997
jmap, Dienstprogramm 1444
JMenu, Klasse 977–978
JMenuBar, Klasse 977
JMenuItem, Klasse 927, 978
JMS 1227
JMX 1388
JMXConnector, Schnittstelle
1398
JMXConnectorServer, Klasse
1397
JNDI 1308
jndi.properties 1308
JNI 1423
Joda Time 654
Index
Joe Palrang 56
join(), Thread 561
JOIN_BEVEL, BasicStroke 1107
JOIN_MITER, BasicStroke 1107
JOIN_ROUND, BasicStroke 1107
JoinRowSet, Schnittstelle 1322
JOptionPane, Klasse 468, 1036
JOS, Java Object Serialization
820
JPA, Java Persistence API 1337
JPanel, Klasse 944
JPasswordField, Klasse 1004,
1006
JPEG 1110
JPopupMenu, Klasse 986
JProgressBar, Klasse 974, 1055
jps, Dienstprogramm 1391, 1444
JRadioButton, Klasse 927, 972–
973
JRadioButtonMenuItem, Klasse
978
JRE 1442
JRMP (Java Remote Method Protocol) 1220
JRootPane, Klasse 1032
jrunscript, Dienstprogramm 530
JScrollBar, Klasse 945, 964
JScrollPane 945
JScrollPane, Klasse 944–945,
998, 1010, 1013
JSlider, Klasse 962
JSmooth 1437
JSP 1230
JSpinner, Klasse 1002
JSplitPane, Klasse 944, 947
JSR 223 530
JSR 250 541
JSSE 1151
jstack, Dienstprogramm 1445
jstat, Dienstprogramm 1444
JSTL 1244
JTabbedPane, Klasse 944, 946
JTable, Klasse 1013
JTableHeader, Klasse 1025
JTextArea, Klasse 1004
JTextComponent, Klasse 1005
JTextField, Klasse 1004
JTextPane, Klasse 1004
JTidy 893
JToggleButton, Klasse 927, 929
JToolBar, Klasse 944, 983
JTree, Klasse 1028
JULY, Calendar 638
JUNE, Calendar 638
Just-In-Time Compiler 57
JViewport, Klasse 945
JWindow, Klasse 1035
JXPath 894
K
kanonischer Pfad 734
Kardinalität 359
kaufmännische Rundung 301
Keller 698
Kerberos 1412
Key 662
Key, Schnittstelle 1418
KeyEvent, Klasse 915, 936
KeyGenerator, Klasse 1419
KeyListener, Schnittstelle 936
KeyPairGenerator, Klasse 1419
KeySelectionManager, Schnittstelle 996
keySet(), Map 709
Keystore 1414
keytool, Dienstprogramm 1413,
1435
Kindklasse 363
Klammerpaar 150
Klasse 179
Klassendiagramm 181
Klasseneigenschaft 331
Klassenhierarchie 364
Klasseninitialisierer 335
Klassenkonzept 64
Klassenlader 59, 512, 1403
Klassen-Literal 498
Klassenmethode 151
Klassenobjekte 498
Klassen-Typen 100
Klassenvariable, Initialisierung
351
Klonen 504
Kodierung, Zeichen 278
Kollision, Signatur 1415
Kollisionsangriff 1415
Kommandozeilenparameter 227
Kommaoperator 143
Kommentar 93
Komplement 167
komplexe Zahl 317
Kompressionsfunktion 1415
Kompressionsstufe 1125
Komprimierungsfaktor 1110
Konkatenation 236
konkrete Klasse 391
konstante Zeichenkette 236
Konstantenpool 238
konstruktive Flächengeometrie
1091
Konstruktor 186, 342
Konstruktoraufruf 182
Konstruktoren in Vererbung 367
Konstruktorweiterleitung 367
Kontextmenü 986
Kontraktionsfunktion 1415
Kontrollfeldgruppe 972
Kontrollstrukturen 128
Kopf 148
Kopfdefinition 846
KOREA 626
KOREAN 626
Kouznetsov, Pavel 1451
kovarianter Rückgabetyp 380
Kovarianz bei Arrays 381
Kreiszahl 297
kritischer Abschnitt 574
kryptografische Prüfsumme 1415
ktoolbar, Dienstprogramm 1283
kubische Kurvensegmente 1091
Kupfersäule 164
Kurven 1091
Kurzschlussoperator 119
L
Länge des Strings 238
lastIndexOf(), String 240
Last-Modified 1185
Latin-1 799
Laufwerksname 738
Laufzeitumgebung 57
launch4j 1437
LayoutManager, Schnittstelle 949
lazy activation 1221
LCDUI 1287
LD_LIBRARY_PATH 1429
leading 1086
Lease 1218
Lebensdauer 104
leere Anweisung 99
leerer Block 99
1467
Index
leerer String 248
Leer-String 249
Leerzeichen 274
Leerzeichen entfernen 246
Lempel-Ziv Kodierung 1186
length(), String 238
Lexikalik 85
lib/security 1409
LIFO 698
lightweight component 898
line joins 1105, 1107
line.separator 522, 1406
Line2D, Klasse 1089
lineare Algebra 317
lineare Kongruenzen 306
LinearGradientPaint 1095
LineBorder, Klasse 933
LineMetrics, Klasse 1087
LineNumberReader, Klasse 791
lineTo(), GeneralPath 1091
Linie 1075
Linienende 1106
Linien-Pattern 1105
Linieverbindung 1107
LinkedHashSet, Klasse 698
LinkedList, Klasse 661–662, 669,
680
Linking 512
linksassoziativ 122
Liskov'sches Substitutionsprinzip 374
Liskov, Barbara 374
List, Schnittstelle 661, 669
ListCellRenderer, Schnittstelle
1002
Listen 669
Listen füllen 720
Listener 451, 916
ListIterator, Schnittstelle 674
ListSelectionEvent, Klasse 999–
1000
ListSelectionListener, Schnittstelle 999–1000
ListSelectionModel, Schnittstelle
1025
Literal 108
Load Factor 713
loadClass(), ClassLoader 515
loadLibrary(), System 1424
Locale, Klasse 625
LocateRegistry, Klasse 1214
1468
Location, Response-Header 1185
Lock 577, 583
lock(), Lock 578
Locking 747
log(), Math 303
Log4j 1399
logClass 1217
Logger, Klasse 1385
Logging, RMI 1217
Login-Modul 1412
logisch atomar 595
logischer Operator 119
logisches Komplement 120
logisches Und 121
logisches Xor 121
lokale Klasse 413
lokale Objekte 1211
lokaler Host 1164
lokalisierte Zahl 273
Lokalisierung 628
long 106
LONG, DateFormat 649
long, Datentyp 101
Long, Klasse 197
low level event 914
lower bound wildcard 425
Luxor 1065
LU-Zerlegung 317
LZ77 1186
M
MAC 1415
MAC-Adresse 1203
magic number 337
magische Zahl 337
magische Zahlenwerte 1349
Mail User Agent 1195
main() 94
main()-Funktion 72
Main-Class 1442
Makro 61
MalformedURLException 1146
Management Interface 1389
ManagementFactory, Klasse 1393
MANIFEST.MF 1442
Manipulation Detection Code
1415
Mantelsklasse 195
Mantisse 292
Map, Schnittstelle 657, 662, 702
Map.Entry, Klasse 710
MARCH, Calendar 638
marker interface 398
Markierungsschnittstelle 398,
824
Marshaller, Schnittstelle 892
marshalling 1208
Matcher, Klasse 262
matches(), Pattern 262
matches(), String 262
MatchResult, Schnittstelle 264
Math, Klasse 297
MathContext, Klasse 315
Matisse 948
MatteBorder, Klasse 933
Mausrad 938
maven 1446
max(), Collections 688
max(), Math 299
MAX_PRIORITY, Thread 563
MAX_RADIX 234
Maximalwert 1337
Maximum 173, 298
MAY, Calendar 638
MBean 1388
MBean-Server 1388
McNealy, Scott 56
MD 1414
MD2 1415
MD4 1415
MD5 1415
MDC 1415
MediaTracker, Klasse 1126
MEDIUM, DateFormat 649
Megginson, David 854
mehrdimensionales Array 213
Mehrfachvererbung 399
Mehrfachverzweigung 132
member class 409
memory leak 355
Memory Map 1444
Menü 976
Menübalken 977
Menüeintrag 977
Menütrennlinie 979
Merant 1296
Merge-Sort 690
Meridian 623
MESA 55
Message Authentication Code
1415
Index
Message Integrity Check 1415
Message Queues 1227
Message Store 1195
Message Transfer Agent 1195
Message Transfer System 1195
Message-Digest 1414
MessageDigest, Klasse 1416
MessageFormat, Klasse 284, 287
Metadaten 1183, 1328
META-INF/MANIFEST.MF 1442
Meta-Information 1185
Meta-Objekte 1341
Meta-Programming 1339
Method, Klasse 1355
Methode des Aufrufes 1181
Methoden 94, 147
überladen 158
Methodenaufruf 322
Methodenkopf 148
Methodenrumpf 148
MEZ 632
MIC 1415
Microsoft 65
Microsoft Access 1292
Microsoft Development Kit 74
Microsoft SQL Server 1292
Middleware 1209–1210
MIDI 538
MidiSystem, Klasse 538
Midlet 1286
MIDP (Mobile Information Device
Profile) 1282
MILLISECOND, Calendar 642
Millisekunden 642
MIME 1195
MimeMultipart, javax.mail 1201
MIME-Nachrichten 1183
MIME-Typ 1154
min(), Collections 688
min(), Math 299
MIN_PRIORITY, Thread 563
MIN_RADIX 234
MIN_VALUE 295
Minimum 173
MINUTE, Calendar 642
Mitgliedsklasse 409
Mitteleuropäische Zeit 632
mitteleuropäische Zeit 633
Mnemonic 981
Mobile Information Device Profile
(MIDP) 1282
modal 1036
Model 991
Model MBeans 1389
Model-View-Controller 448, 990
Modifizierer 98, 1349
modifiziertes UTF-8 753
Modulo 114
Monat 642
Mönch 165
Monitor 577
monitorenter 577
monitorexit 577
Monitoring 1387
MONTH, Calendar 642
mouse wheel 938
MouseEvent, Klasse 915
MouseInfo, Klasse 1064
MouseListener, Schnittstelle 916
MouseMotionListener, Schnittstelle 916
MouseWheelEvent, Klasse 938
Moved Permanently 1184
Moved Temporarily 1184
MS 1195
MTA 1195
MTS 1195
MUA 1195
multicast 74
Multicast, Bean 454
Multicast-Kommunikation 1204
Multilevel continue 146
MULTILINE, Pattern 264
Multi-Map 715
Multiple Choices 1184
MULTIPLE_INTERVAL_SELECTION, ListSelectionModel
1000
Multiplikation 112
Multiplizität 359
Multipurpose Internet Mail
Extensions 1195
multitaskingfähig 543
multithreaded 544
Muster 262
MutableTreeNode, Schnittstelle
1028
Mutex 577
MVC 990
MXBeans 1389
MySQL 1291
N
Namensdienst 1207, 1213
Namensraum 852
Naming 1216–1217
NaN 293, 295
nanoTime(), System 525
narrowing conversion 123
native Methode 1423
Native Protocol All-Java Driver
1297
native Threads 544
native, Schlüsselwort 1424
native2ascii, Dienstprogramm,
279
Native-API Java Driver 1297
NativeCall 1433
nativer Compiler 1436
natural ordering 685
natürliche Ordnung 685
NavigableMap, Schnittstelle 662,
704
NavigableSet, Schnittstelle 696
Navigation 935
nearest neighbor algorithm 1122
Nebeneffekt 322
N-Eck 1078
NEGATIVE_INFINITY 295
negatives Vorzeichen 110
Nelson 1205
nested exception 485
nested top-level class 408
NetBeans 74
NetPermission 1410
netstat 1172
Network Filesystem 1189
Network Information Services
1143
NetworkInterface, Klasse 1165
Netz-Protoll All-Java Driver 1297
new line 522
new, Schlüsselwort 182, 342,
1361
newInstance() 371
newInstance(), Array 1351
newInstance(), Constructor 1361
newLine(), BufferedWriter 789
NFS 1189
nicht ausführend 593
nicht geprüfte Ausnahme 480
nicht-primitives Feld 212
1469
Index
nicht-rechteckiges Feld 214
NIS 1143
No Content 1184
NO_SUCH_PAGE, Printable 1137
No-Arg-Konstruktor 186
NoClassDefFoundError 1342
non-static method-Fehlermeldung 151
Normalizer, Klasse 262
Normalverteilung 307
NoSuchAlgorithmException
1417
NoSuchElementException 666,
701
NoSuchProviderException 1417
Not Found 1184
Not Implemented 1184
Not Modified 1184
Not-a-Number 293, 295
Notation 180
notify(), Object 592, 600
notifyAll() 595
NotSerializableException 822,
824, 826
NOVEMBER, Calendar 638
nowarn 1436
NULL 465
null, Schlüsselwort 183, 188
NULL, SQL 1317
NullPointerException 189, 209,
480
Null-Referenz 188
Null-String 249
Number, Klasse 197
NumberFormat, Klasse 197, 284–
285
NumberFormatException 251,
468
numeric promotion 112
numerische Umwandlung 112
numerischer Typ 111
O
Oak 55
Oberklasse 363
Oberklasse finden 1347
Oberlänge 1086
Obfuscator 1343, 1451
Object Management Group 180,
1207, 1220
1470
Object Serialization Stream
Protocol 827
Object, Klasse 363, 498
ObjectInputStream, Klasse 822
Objective-C 64
ObjectName, Klasse 1395
ObjectOutputStream, Klasse 821
ObjectStreamField, Klasse 827
Objektansatz 179
Objektgleichheit 500
Objektidentifikation 498
objektorientiert 58
objektorientierter Ansatz 64
Objektorientierung 98
Objektvariable 183
Objektvariable, Initialisierung
350
Observable, Klasse 448
Observer, Schnittstelle 448
Observer/Observable 448
Observer-Pattern 990
OCTOBER, Calendar 638
ODBC 1292, 1295–1296
ODBC-Datenquellen-Administrator 1292
Oder 119
off-by-one error 141
OK 1184
Oktalform 106
Olson, Ken 1281
OMG (Object Management
Group) 180, 1207
OO-Methode 180
opak 943
Open Database Connectivity
Standard 1296
Open MBeans 1389
openStream(), URL 1148
Operator 111
operator precedence 120
Optionsfeld 972
Oracle 1291
OracleDriver 1302
Ordinalzahl, Aufzählung 426
Ordinalzahl, Enum 426
org.jdom, Paket 870
org.omg, Paket 497
Ostersonntag 639
OutOfMemoryError 182, 505
OutputStream, Klasse 764
OutputStreamWriter, Klasse 279,
799
OverlayLayout, Klasse 962
P
P2P 1227
Pack200 806
Package, Klasse 1373
package, Schlüsselwort 229
PAGE_EXISTS, Printable 1137
paint(), Frame 1069
Paint, Schnittstelle 1095
paintComponent() 1071
Paket 187, 1143
Paketsichtbarkeit 324
PalmOS 1281
PalmPilot 68
Palmsonntag 640
Parameter 152
Parameterliste 148, 150
Parameterübergabemechanismus 152
parametrisierter Typ 419
parseBoolean(), Boolean 251
Parsed Character Data 848
parseDouble(), Double 251
ParseException 285, 653
parseInt(), Integer 198, 251, 468
parseObject(), Format 285
partiell abstrakte Klasse 392
Passionssonntag 640
PATH 72
Patrick Naughton 56
Pattern, Klasse 262
Payne, Jonathan 56
PCDATA 848
p-code 57
PDA 68
PDAP 1283
Peer-Elemente 1054
Peer-Klassen 895
Permissions 1410
PersistenceDelegate, Klasse 837
Persistenz 455
Personal Digital Assistant Profile
1283
Personal Java 68
Pfad 1091
Pfingstsonntag 640
PicoJava 58
Index
Picture Element 1073
PipedInputStream, Klasse 801
PipedOutputStream, Klasse 801
PipedReader, Klasse 801
PipedWriter, Klasse 801
pissing on at every opportunity
75
Pixel 1073
Plattenspeicher 739
Pluggable Authentication Module
(PAM) 1412
Pluggable Look and Feel 897
Plugins, Eclipse 82
PocketPC 1282
Point, Klasse 179, 182
Pointer 59
PointerInfo, Klasse 1064
Point-to-Point 1227
Polar-Methode 307
Policy-Datei 1408
policytool, Dienstprogramm
1410, 1435
Polygon 1077
Polygon, Klasse 1078, 1089
Polylines 1077
Polymorphie 385
Pommes-Bude 50
POP before send 1200
POP3 1196
Popup-Menü 986
Porphyr 164
Port 1234 1172
Port, RMI-Namensdienst 1215
Port-Adresse 1167
Position des Fensters 903
POSITIVE_INFINITY 295
POST 1181
Post-Dekrement 116
Post-Inkrement 116
POST-Methode 1159, 1180
Potenz 303
Prä-Dekrement 116
Präfix 242
Präfix/Postfix 116
Pragma 1185
Prä-Inkrement 116
Preferences, Klasse 532
Preimage-Angriffe 1415
PreparedStatement, Schnittstelle
1310, 1326
primitiver Type 100
Primzahlen 730
Principal 1408, 1412
print() 159, 775
Printable, Schnittstelle 1137
PrinterJob, Klasse 1137
printf() 97, 775
printf(), PrintWriter/PrintStream
282
PrintJob, Klasse 1137
println(), print() 96, 775
PrintService, Schnittstelle 1138
printStackTrace() 467
PrintStream 775
PrintWriter 775
Priorität, Thread 563
Prioritätswarteschlange 563
PriorityQueue, Klasse 661
private, Schlüsselwort 325, 1349
PrivateKey, Schnittstelle 1418
Privatsphäre 324
Process, Klasse 529
ProcessBuilder, Klasse 526
Profil, Java ME 1282
Profiling 525
Profiling-Informationen 1438
Programm 93
Programmicon 1116
Programmieren gegen Schnittstellen 399
ProGuard 1451
Prolog 93
Properties 455, 715
Properties, Bean 455
Properties, Klasse 521, 715
Property 329
PropertyChangeEvent, Klasse
457, 463, 943
PropertyChangeListener, Schnittstelle 457
PropertyDescriptor, Klasse 1358
PropertyPermission 1410
Property-Sheet 455
PropertyVetoException 460
Proposed Standard 1144
protected, Schlüsselwort 327,
366, 1349
Protocol Handler 1154
Protocols 64
Protokoll 1144
Protokoll-Handler 1154
Proxy 1205
Proxy-Authenticate, ResponseHeader 1185
Proxy-Authorization 1158
Proxy-Server 1150
Prozess 543
Pseudo-Primzahltest 308
Public, Response-Header 1185
public, Schlüsselwort 324, 1349
PublicKey, Schnittstelle 1418
Publish-Subscribe 1227
Pulldown-Menü 976
Punktoperator 184
pure abstrakte Klasse 392
PushbackInputStream, Klasse 792
PushbackReader, Klasse 792
PUT 1181
put(), Map 704
Q
qNaNs 295
QuadCurve2D, Klasse 1089
quadratische Kurvensegmente
1091
Quadratwurzel 302
quadTo(), GeneralPath 1091
QuantumDB 1293
Quartz 621
Quasiparallelität 543
Quellcodeverschönerer 1452
Query-String 1159
Queue, Schnittstelle 661, 700
Quicksort 690
Quiet NaN 295
Quoted Printing Encoding 1196
R
race condition 575
race hazard 575
RadialGradientPaint 1095
Rahmen 932
random(), Math 212, 304
Random, Klasse 306
RandomAccess, Schnittstelle 677
RandomAccessFile, Klasse 466,
751
Rang eines Operators 120
Range-Checking 61
Rangordnung 120
Raw-Type 422
1471
Index
Reader, Klasse 773
readLine(), BufferedReader 791
readLine(), RandomAccessFile
466
readObject(), ObjectInputStream
822
readPassword() 781
readResolve() 830
readUTF(), RandomAccessFile
753
ReadWriteLock, Schnittstelle 580
rebind(), Registry 1215
Rechenungenauigkeit 138
rechtsassoziativ 122
Record Management System
1287
Rectangle2D, Klasse 1089
RectangularShape, Klasse 1089
reentrant 588
ReentrantLock, Klasse 578
ReentrantLock, Schnittstelle 593
ReentrantReadWriteLock, Klasse
581
Reference Concrete Syntax 845
referenced-Meldung 1218
Referenz 59
Referenzierung 128
Referenztyp 100, 111
Referenztyp, Vergleich mit ==
193
Referenzvariable 183
Reflection 1339
ReflectPermission 1410
reflexive Assoziation 359
reg 536
regionMatches(), String 242
Registry 532, 1207, 1213
REGISTRY_PORT 1214
REGISTRY_PORT, Registry 1214
reguläre Ausdrücke 262
Reihung 204
reine abstrakte Klasse 392
Rekursionsform 163
rekursive Assoziation 359
rekursive Funktion 162
relationale Datenbanksysteme
1295
Relationaler Operator 118
Remainder Operator 113
Remote Manager 1388
Remote Object Activation 1221
1472
Remote Procedure Call 1207
Remote, Schnittstelle 1211
RenderedImage, Schnittstelle
1123
Rendering-Algorithmus 1134
Renderpack Pipelines 1027
Rendezvous 560, 562
repaint() 1072
replace(), String 246
replaceAll(), Collections 720
replaceAll(), String 247
replaceFirst(), String 247
ReplicateScaleFilter, Klasse 1122
Request 1181
Request For Comment 1144
Request Header 1183
requestFocusInWindow(), JComponent 935
reservierte Schlüsselwörter 89
ResourceBundle, Klasse 629
Response-Header 1183, 1185
Rest der Division 304
Restwertoperator 112–113, 303
Result, Schnittstelle 889
Resultat 111
ResultSet, Schnittstelle 1312
ResultSetMetaData, Schnittstelle
1329
resume(), Thread 563
RetentionPolicy, Aufzählung
1380
Re-throwing 484
Retry-After, Response-Header
1185
return, Schlüsselwort 153, 216
revalidate(), JComponent 942
RFC 1144
RFC 1521 280
RFC 1952 1186
RFC 2616 1180
RGB 1100
Rhino 530
Rich Text Format 1010
rint(), Math 301
Ritchie, Dennis M. 70
RMI 1207
RMI Wire Protocol 1208
rmi:// 1216
rmic, Dienstprogramm 1213
RMIClassLoader, Klasse 1220
rmid, Dienstprogramm 1222
RMI-Klassenlader 1220
RMI-Logging 1217
rmiregistry, Dienstprogramm
1214, 1310
RMI-Transportschicht 1208
Robot, Klasse 1060, 1062
Rollbalken 962
Rollenbasierte Rechtevergabe
1411
Rollrads 938
Ron Rivest 1415
Rotation 1134
round(), Math 301
RoundingMode, Aufzählung 316
RoundRectangle2D, Klasse 1089
Router 1143
RowFilter, Klasse 1027
RowSet, Schnittstelle 1321
RPC 1207
rt.jar 513
RTF 51, 1010
Rückgabetyp 148
Rückgabewert 150
Rumpf 148
run(), Runnable 546
Runden 300
Rundungsfehler 114
Rundungsmodi, BigDecimal 315
runFinalizersOnExit(), System
512
Runnable, Schnittstelle 415, 546
Runtime 526
Runtime Packages 1401
RuntimeException 479
Run-Time-Interpreter 57
RuntimePermission 1410
r-Wert 111
S
Sandbox 1403
Saturation 1100
SAX 854
SAXBuilder, Klasse 872
SAXParser, Klasse 866
SCALE_AREA_AVERAGING,
Image 1121
SCALE_DEFAULT, Image 1121
SCALE_FAST, Image 1121
SCALE_REPLICATE, Image 1121
SCALE_SMOOTH, Image 1121
Index
Scanner, Klasse 268
Schablonen-Muster 766
Schaltjahr 155, 624
ScheduledThreadPoolExecutor,
Klasse 567, 572
Scheduler 543, 573
Schema 849
Scherung 1134
Schieberegler 962
Schlange 661
Schleifen 136
Schleifenbedingung 137–138
Schleifen-Inkrement 140
Schleifentest 140
Schleifenzähler 141
Schlüssel 662
Schlüsselpaare 1413
Schlüsselspeicher 1414
Schlüsselwörter 89
Schnittstelle 64, 395
Schnittstellen-Typen 100
Schriftlinie 1080
Schurken 623
schwergewichtige Komponente
896
Schwyzerdütsch 631
Scope 104
Screen_Updater 566
Screenshot 1063
ScriptEngine, Schnittstelle 531
ScriptEngineManager, Klasse 531
Scriptlets 1251
Scrollable, Schnittstelle 945
Scrollbar 962
ScrollPaneLayout, Klasse 962
sealing, Jar 412
SECOND, Calendar 642
SecretKey, Schnittstelle 1418
SecretKeySpec, Klasse 1420
Secure Hash Algorithm 1415
Secure Hash Standard 1415
Secure Sockets Layer 1204
SecureRandom, Klasse 306
Security Manager 1403
SecurityException 1408
Security-Manager 59
SecurityManager 1267
SecurityManager, Klasse 1403–
1404
SecurityPermission 1410
Seed 306–307
Seiteneffekt 322
Sekunden 642
Selbstbeobachtung 455
Semantik 85
semantisches Ereignis 914
Semaphore, Klasse 603
Separator 91
SEPTEMBER, Calendar 638
SEQUEL 1333
Sequence, Klasse 539
SequenceInputStream, Klasse 769
Sequencer, Schnittstelle 538–539
Sequenz 656, 661
Sequenzdiagramm 181
Serializable, Schnittstelle 824
SerializablePermission 1410
serialPersistentFields 827
serialver, Kommandozeilenprogramm 834
serialVersionUID 833
Server 1167, 1207
Server, Response-Header 1185
ServerSocket, Klasse 1172
Service Unavailable 1184
ServiceLoader, Klasse 1301
Service-Provider Implementation 497
Session, Klasse 1196, 1199
Set, Schnittstelle 661, 692
setBorder(), JComponent 932
setContentType(), JEditorPane
1010
setDefaultCloseOperation(),
JFrame 901, 922
setDefaultRenderer(), JTable
1022
setDoInput(), URLConnection
1153
setDoOutput(), URLConnection
1153
setFont(), Graphics 1081
setLayout(), Container 948
setLookAndFeel(), UIManager
1044
setModel(), JSpinner 1002
setModel(), JTable 1017
setPaint(), Graphics2D 1096
setPriority(), Thread 563
setProperty(), Properties 715
setRenderingHint(), Graphics2D
1089
setSize(), Window 903
Setter 329
setText(), JButton 924
setText(), JLabel 907
setText(), JTextComponent 1005
Set-Top-Boxen 56
setVisible(), Window 903
SGML 844
SHA 1415
Shallow Copy 712
Shamir, Adi 1415
Shape, Schnittstelle 1088–1089
shared objects 1427
ShellFolder, Klasse 737
Sheridan, Mike 56
Shift 120
Shift-Operator 169
SHORT, DateFormat 649
short, Datentyp 101, 106, 291
Short, Klasse 197
Short-Circuit-Operator 119
showConfirmDialog(), JOptionPane 1038
showMessageDialog(), JOptionPane 1038
showOptionDialog(), JOptionPane
1038
SHS 1415
Shutdown-Hook 621
Sicherheitsmanager 1403, 1407
Sichtbarkeit 104, 324, 366
Sichtbarkeitsmodifizierer 324
signal(), Condition 593
signaling NaN 295
Signierung 1408, 1412
Simple API for XML Parsing 854
Simple Mail Transfer Protocol
1195
SimpleDateFormat, Klasse 647
SimpleTimeZone, Klasse 633
SIMPLIFIED_CHINESE 626
SIMULA 64
Simula-67 177
sin(), Math 299
Single Inheritance 365
SINGLE_INTERVAL_SELECTION,
ListSelectionModel 1000
SINGLE_SELECTION, ListSelectionModel 1000
Singleton 357, 724
sinh(), Math 300
1473
Index
Sinus 299
sizeof 128
Skalierung 1134
Skipjack 1415
Skript-Engine 530
Slash 732
sleep(), Thread 553
slider, Schieberegler 962
Slivka, Ben 75
Smalltalk 58, 177
Smart-Card 1412
SMB (Server Message Block) 749
Smiley 87
SMTP 1195
SMTP-Server 1196
sNaN 295
SOAP 1222
SOCK_DGRAM 1203
SOCK_STREAM 1203
Socket, Klasse 1167
SocketPermission 1410
Sockets 1166
SOCKS 1151
SoftBevelBorder, Klasse 933
Sommer-/Winterzeit 632
Sommerzeit 633
Sommerzeitabweichung 643
sort(), Arrays 223, 687
sort(), Collections 689
SortedMap, Schnittstelle 704
SortedSet, Schnittstelle 697
sortieren 689
Soundbank 538
Source, Schnittstelle 889
Source-Code Beautifier 1452
späte dynamische Bindung 385
SpinnerDateModel, Klasse 1002
SpinnerListModel, Klasse 1002
SpinnerModel, Schnittstelle 1002
SPI-Pakete 497
Splash-Screen 1117
split(), Pattern 267
split(), String 266
SpringLayout, Klasse 948
Sprungmarken 146
SQL 1333
SQL 2 1333
SQLException 1306, 1318
SQLWarning, Klasse 1318
SQuirreL 1293
SSL 1204
1474
SSLSocket, Klasse 1204
SSLSocketFactory, Klasse 1204
stabil sortieren 689
Stabile Sortieralgorithmen 691
Stack 698
Stack, Klasse 698
Stack-Inhalt 488
Stack-Trace 486
StackTraceElement, Klasse 487
Standard Extension API 497
Standard Generalized Markup
Language 844
Standard MBeans 1388
Standard Tag Library 1244
Standard Widget Toolkit 1066
Standardberechtigungen 1409
Standard-Konstruktor 186, 343
Standardserialisierung 820
Stapelspeicher 698
Star Seven 56
start(), Thread 547
startsWith(), String 242
Statement, Schnittstelle 1310
statements 92
static final 396
static, Schlüsselwort 99, 151, 331
statische Eigenschaft 331
statische innere Klasse 408
statische Methode 151
Statischer Block 335
statisches Import 231
Statusanzeige 974
Statuscode 1183
Statuszeile 1183
StAX 856
Stellvertreterobjekt 1205, 1213
Sternzeit 623
Steuerelemente 895
stilles NaN 295
STL Bibliothek 690
stop(), Thread 557
Store-and-Forward 1195
StreamEncoder 799
StreamFilter, Schnittstelle 861
StreamTokenizer, Klasse 838
streng-typisiert 100
strictfp, Schlüsselwort 305
StrictMath, Klasse 305
String 96, 234
StringBuffer, Klasse 236, 252
StringBuilder, Klasse 236, 252
StringIndexOutOfBoundsException 242–243
Stringkonkatenation 120
String-Literale 236
StringReader, Klasse 763, 784
Stringteil vergleichen 242
Stringteile extrahieren 242
StringTokenizer, Klasse 273
StringWriter, Klasse 782
Stroke, Schnittstelle 1105
Stroustrup, Bjarne 178
Structured English Query
Language 1333
Struts 1266
Subinterface 403
Subject 1412
Subklasse 363
Subprotokoll 1304
Substitutionsprinzip 374
substring(), String 243
Subtraktion 112
Suffix 242
SUID 834
Summe aller Einträge 1337
sun, Paket 230
sun.boot.class.path 514
sun.jdbc.odbc.JdbcOdbcDriver
1302
sun.nio.cs 799
SunWorld 56
super() 369, 371
super, Generics 423
super, Schlüsselwort 371, 378
Superklasse 363
Surrogate-Paar 86
suspend(), Thread 563
SWIG 1433
swing.properties 1044
SwingUtilities, Klasse 1055
SwingWorker, Klasse 1056
SwingWT 1066
switch-Anweisung 133
Swixml 1065
SWT 1066
symbolische Konstante 336
Symbolleiste 983
sync() 762
Synchronisation 512, 573
synchronized, Schlüsselwort 577,
582
SynerJ 74
Index
Syntax 85
System.err 97, 779
System.in 527, 767, 779
System.out 97, 779
SystemColor, Klasse 1095, 1101
Systemeigenschaften 72, 521
Systemfarben 1101
System-Klassenlader 515
SystemTray, Klasse 989
T
TableCellEditor, Schnittstelle
1023
TableCellRenderer, Schnittstelle
1019
TableColumn, Klasse 1024
TableLayout, Klasse 962
TableModel, Schnittstelle 1014,
1024
TableModelEvent, Klasse 1018
TableModelListener, Schnittstelle 1014
TableRowSorter, Klasse 1027
Tabulator 274
Tag 642, 843
Tag des Jahres 642
Tage im Monat 646
Tagesdatum 644
Taglib 1244
TagLib-Deskriptoren 1244
TAI 624
TAIWAN 626
Taj Mahal 64
tan(), Math 299
Tangens 299
tangle 431
Tango Desktop Projekt 911
tanh(), Math 300
Tar-Archive 806
Tastatur-Shortcut 981
Tastenkürzel 981
TCP 1189
TCP/IP 1166
Tear-Off-Menü 978
Teletubbies 1161
Template-Code 1236
Template-Pattern 766
terminiert 564
TextArea, Klasse 1008
TextLayout, Klasse 1087
TexturePaint 1095
Textverarbeitung 50
this und Vererbung 416
this$0, innere Klasse 412
this() 371
this(), Beschränkungen 349
this(), Konstruktoraufruf 348
this-Referenz 322, 371
this-Referenz, innere Klasse 410
Thread 543
thread local storage (TLS) 609
Thread, Klasse 415, 547
ThreadDeath, Klasse 559
ThreadGroup, Klasse 612
Threadgruppe 615
ThreadLocal, Klasse 609
thread-lokale Variablen 609
Thread-Pool 567
ThreadPoolExecutor, Klasse 567
Threads, Zustände 553
Throwable, Klasse 476
throws 469
Tick Marks 962
tiefe Kopie, clone() 507
Tiefe Objektkopien 831
Tim Berner-Lee 1180
timeout 1208
Timer, Klasse 619
Timer, Swing-Klasse 1064
TimerTask, Klasse 619
Timestamp, Klasse 1316
TimeZone, Klasse 632
Titelleiste 902
TitledBorder, Klasse 933
TLS 1204
toArray(), Collection 682
toCharArray(), String 207
tödliche Umarmung 590
Token 90, 274
toLowerCase(), Character 234
toLowerCase(), String 245
Tomcat 1232
Toolkit, Klasse 899
TooManyListenersException 454
Topic, JMS 1227
Toplevel-Container 900
Top-Level-Klassen 408
toString(), Arrays 224
toString(), Integer 199
toString(), Object 376, 498
toString(), Point 185
toUpperCase(), Character 234
toUpperCase(), String 245
Transferable, Schnittstelle 1047
Transfer-Encoding 1185
TransferHandler, Klasse 1050
Transformationen 1095
transient, Schlüsselwort 827
translate(), Graphics 1130
Transparency, Schnittstelle 1096
TransparentLayout 961
Transport Layer Security 1204
Transportschicht 1208
TrayIcon, Klasse 989
TreeMap, Klasse 656, 662, 702
TreeModel, Schnittstelle 1028,
1030
TreeNode, Schnittstelle 1030
TreeSelectionListener, Schnittstelle 1029
TreeSet, Klasse 695
Trennzeichen 90, 266
trim(), String 246
true 101
TrueType-Zeichensatz 1084
TrueZIP 806
try 465
Tupel 1289
Türme von Hanoi 164
typ erasure 421
Typanpassung 122
TYPE_INT_RGB, BufferedImage
1119
TYPE_SCROLL_INSENSITIVE,
ResultSet 1318
Typecast 122
Types, Klasse 1314
Typvariable 419
Typvergleich 121
U
Überblendung, Grafik 1104
überdecken, Methoden 387
überladen 97
überladene Methode 158
überladener Operator 62
überladenes Plus 127
überlagert, Methode 376
Überlauf 296
überschreiben, Methoden 376
Übersetzer 95
1475
Index
überwachtes Warten 597
Uboxing 200
UCSD-Pascal 57
UDP 1189
UDP-Protokoll 1188
UIDefaults, Klasse 908
UI-Delegate 940
UIManager, Klasse 1044
UK 626
Umgebungsvariablen, Betriebssystem 524
Umkehrfunktionen 299
UML 180
Umlaut 86
Umrisslinie 1105
Umrisslinie, Stroke 1095
unärer Operator 110
unäres Minus 115
unäres Plus/Minus 120
Unauthorized 1184
unbenanntes Paket 230
UncaughtExceptionHandler,
Schnittstelle 556
unchecked 541
Und 119
UNDECIMBER, Calendar 638
Undo/Redo 1051
UndoableEditEvent, Klasse 1052
UndoManager, Klasse 1051
Unendlich 293
Unicast, Beans 454
UnicastRemoteObject, Klasse
1215
Unicast-Verbindung 1204
Unicode escapes 86
UNICODE_CASE, Pattern 264
Unicode-Zeichen 85
unidirektionale Beziehung 359
Unified I/O 755
Unified Method 180
Uniform Resource Locater 1144
Universal Time 623
Unix-Crypt 1418
UnknownHostException 1168
unlock(), Lock 578
Unmarshaller, Schnittstelle 892
unnamed package 230
UnsatisfiedLinkError 1424
UnsupportedOperationException 480, 486, 660, 667,
681, 723
1476
Unterklasse 363
Unterlänge 1086
Untermenü 977
Unzahl 112
Upgrade 1185
upper bound wildcard 425
URL 1144
URL, Klasse 1144
URLClassLoader, Klasse 516
URLConnection, Klasse 1151
URLDecoder, Klasse 1160
URLEncoder, Klasse 1159
US 626
Use-Cases-Diagramm 181
user.timezone 638
UTC 624
UTF-16 846
UTF-16 Kodierung 86
UTF-8 846
UTF-8 Kodierung 753
Utility-Klasse 357
uuencode 1195
V
valid, XML 847
Value 662
valueOf() 196
valueOf(), String 250
values(), Map 709
Varargs 217
variable Argumentanzahl 217
Variablendeklaration 102
Variableninitialisierung 387
Vary, Response-Header 1185
Vector, Klasse 669
veränderbare Zeichenketten 252
verbindungsloses Protokoll 1188
verbindungsorientiert 1188
verbose 1436, 1438
Verbundoperator 115
verdecken von Variablen 322
vererbte Konstanten 404
Vererbung 363
Vergleich 241
Vergleichsoperator 118
Vergleichsstring 242
verkettete Liste 657, 680
Verklemmung 544
Verlaufsbalken 974
Verschiebeoperator 169
Verschiebung 1134
Verzeichnis anlegen 740
Verzeichnis umbenennen 740
Vetorecht 456
Via 1185
Video-Übertragungen 1129
View 991
ViewPortLayout, Klasse 962
virtuelle Maschine 57
Visual Age for Java 73
Visual Basic 246
void, Schlüsselwort 151
volatile, Schlüsselwort 606
VolatileImage, Klasse 1129
Vorschaubild 1111
Vorzeichenerweiterung 120
Vorzeichenumkehr 115
W
Wahrheitswert 100
wait(), Object 592, 600
War-Archiv 1234
Warning, Response-Header 1185
Warning:Applet Window 1408
Watson, Thomas 1205
WAV 538
weave 431
WEB 431
Web Application Security 1266
Web-Applets 56
Webbrowser 1011
WebRowSet, Schnittstelle 1322–
1323
WebRunner 56
Webstart 1279
Wechselknopf 929
WEEK_OF_MONTH, Calendar
642
WEEK_OF_YEAR, Calendar 642
Weichzeichnen 1075, 1134
Well-Known System Ports 1167
Wertebereich 328
Werte-Objekt 196
Wertoperation 110
Wertübergabe 152
Wettlaufsituation 575
while-Schleife 136
WHITE, Color 1098
White-Space 90
widening conversion 123
Index
Widgets 895
Wiederverwendung per CopyUnd-Paste 127
Wildcard 425
Wilde 1267
Win32-API 74
WinCE 1281
WIND_NON_ZERO, GeneralPath 1093
Winding Rule 1092
windowClosed(), WindowListener 921
windowClosing(), WindowListener 921
WindowEvent, Klasse 918
WindowListener, Schnittstelle
916
Windows Icon-Format 1111
Windows XP 1267
Windows-NT Konsole 278
Windows-Registry 536
Windungsregel 1092
Winkelfunktionen 299
WinZip 69
Wireless Toolkit 1283
wissenschaftliche Notation 108
Woche 642
Woche des Monats 642
wohlgeformt 845
WORA 65
Word 50
Worker-Thread 1058
Workspace 76
World Wide Web 56
Wrapper-Klasse 195
write once, run anywhere 65
writeObject(), ObjectOutputStream 821
Writer, Klasse 770
writeReplace() 830
writeUTF(), RandomAccessFile
753
wsimport, Dienstprogramm
1224, 1226
Wurzelelement 875
Wurzelverzeichnis 737
WWW-Authenticate, ResponseHeader 1185
X
X.509 1413
XAML 1065
-Xbootclasspath 514
XDoclet 1340
Xerces 855
XHTML 853
XML 844
XML User Interface Language
1065
XMLDecoder, Klasse 836
XMLEncoder, Klasse 836
XMLEvent, Klasse 857
XMLEventFactory, Klasse 862
XMLEventReader, Klasse 860
XMLEventReader, Schnittstelle
862
XMLEventWriter, Klasse 858
XMLEventWriter, Schnittstelle
863
XMLInputFactory, Klasse 862
XMLOutputFactory, Klasse 862–
863
XMLOutputter, Klasse 873
XMLStreamConstants, Schnittstelle 858
XMLStreamReader, Schnittstelle
857
XMLStreamWriter, Klasse 858
XMLStreamWriter, Schnittstelle
862–863
-Xms 1438
-Xmx 1438
Xnoclassgc 1438
XOPEN SQL-Status 1318
XOR 1070
Xor 119, 168
Xor-Modus, Zeichnen 1105
XPath 884, 887
XPath, Klasse 885
XPath-Wurzel 884
-Xprof 1438
-Xrs 1438
X-Server 1140
XSLT 887
-Xss 1438
XStream 838
XUL 1065
Xvfb-Server 1140
X-Virtual-Framebuffer-Server
1140
Y
YEAR, Calendar 642
yield(), Thread 555
Z
Zahlenwert, Unicode-Zeichen 85
Zeichen 100, 109
Zeichen ersetzen 246
Zeichenbereich 1095
Zeichenkette 96
Zeichenkodierung 278
Zeiger 59
Zeilenkommentar 93
Zeilentrenner 274
Zeilenumbruch 522
Zeitablauf 1208
Zeitgenauigkeit 634
Zeitmessung 525
Zeitverschiebung 633
Zeitzone 624, 632, 651
Zeitzonenabweichung 643
Zertifizierungsstelle 1412
ZipEntry, Klasse 810
ZipFile, Klasse 810
zirkuläre Assoziation 359
ZONE_OFFSET, Calendar 643
Z-Order 1033
Zufallszahl 304, 309
Zufallszahlengenerator 306
Zugriffsmethode 328–329
Zugriffsmodifizierer 1355
zusammengesetzte Bedingung
130
Zustandsänderung 463
Zuweisung 121
Zuweisung mit Operation 121
Zuweisung pro Zeile 112
zweidimensionales Feld 213
Zweierkomplement 291
zweistelliger Operator 110
Zwischenablage 1046
zyklische Redundanzprüfung 817
1477