Leseprobe zum Titel: Java ist auch eine Insel

Leseprobe zum Titel: Java ist auch eine Insel
Christian Ullenboom
Java ist auch eine Insel
Programmieren mit der Java Standard Edition Version 6
Auf einen Blick
Vorwort ................................................................................................
39
1
Java ist auch eine Sprache ....................................................................
53
2
Sprachbeschreibung .............................................................................
83
3
Klassen und Objekte ............................................................................
175
4
Der Umgang mit Zeichenketten ...........................................................
221
5
Mathematisches ...................................................................................
275
6
Eigene Klassen schreiben .....................................................................
301
7
Exceptions ............................................................................................
433
8
Die Funktionsbibliothek .......................................................................
459
9
Threads und nebenläufige Programmierung ........................................
515
10
Raum und Zeit ......................................................................................
595
11
Datenstrukturen und Algorithmen .......................................................
627
12
Dateien und Datenströme ....................................................................
693
13
Die eXtensible Markup Language (XML) .............................................
803
14
Grafische Oberflächen mit Swing .........................................................
855
15
Grafikprogrammierung ......................................................................... 1021
16
Das Netz ............................................................................................... 1093
17
JavaServer Pages und Servlets ............................................................. 1155
18
Verteilte Programmierung mit RMI und Web-Services ....................... 1211
19
Applets, Midlets und Sound ................................................................ 1235
20
Datenbankmanagement mit JDBC ....................................................... 1253
21
Reflection und Annotationen ............................................................... 1301
22
Komponenten durch Bohnen ............................................................... 1345
23
Logging und Monitoring ...................................................................... 1359
24
Sicherheitskonzepte ............................................................................. 1371
25
Java Native Interface (JNI) ................................................................... 1393
26
Dienstprogramme für die Java-Umgebung .......................................... 1405
A
Die Begleit-DVD ................................................................................... 1427
Index ..................................................................................................... 1429
Inhalt
1
Vorwort ...............................................................................................................
39
Java ist auch eine Sprache ...................................................................
53
1.1
1.2
1.3
53
53
55
55
56
57
57
58
58
59
60
60
61
62
62
63
63
63
64
65
65
66
67
67
68
70
70
71
71
71
72
72
73
74
75
77
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 ......................................
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
Java Studio und NetBeans von Sun ............................................
1.7.2
Die Entwicklungsumgebung Eclipse ...........................................
1.7.3
Together ....................................................................................
1.7.4
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 ......................................................................................
78
78
79
79
80
81
81
Sprachbeschreibung ............................................................................
83
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 und Programme ..................................................................
2.2.1
Eine Klasse bildet den Rahmen ..................................................
2.2.2
Die Reise beginnt am main() ......................................................
2.2.3
Programme übersetzen und starten ............................................
2.2.4
Funktionsaufrufe als Ausdrücke und Anweisungen .....................
2.2.5
Modifizierer ...............................................................................
2.2.6
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 ..........................................................
2.3.7
Die Typanpassung (das Casting) .................................................
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
Überladenes Plus für Strings .......................................................
2.4.10 Was C(++)-Programmierer vermissen könnten ...........................
83
83
86
86
87
88
89
90
91
92
93
93
96
96
97
98
100
100
104
107
108
109
113
114
115
117
118
119
120
121
122
124
125
Inhalt
2.5
2.6
2.7
2.8
2.9
2.10
3
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
Operationen auf Bit-Ebene ........................................................
2.8.2
Die Verschiebeoperatoren .........................................................
2.8.3
Ein Bit setzen, löschen, umdrehen und testen ............................
2.8.4
Bit-Funktionen der Integer- und Long-Klasse .............................
2.8.5
Der Bedingungsoperator ............................................................
Einfache Benutzereingaben .......................................................................
Zum Weiterlesen ......................................................................................
126
126
128
130
133
133
134
136
137
142
144
145
146
146
148
148
149
150
151
152
152
156
158
158
160
163
164
165
167
169
170
171
172
173
Klassen und Objekte ........................................................................... 175
3.1
3.2
Objektorientierte Programmierung ...........................................................
3.1.1
Warum überhaupt OOP? ...........................................................
3.1.2
Wiederverwertbarkeit ................................................................
Eigenschaften einer Klasse ........................................................................
3.2.1
Die Klasse Point .........................................................................
175
175
176
177
177
7
Inhalt
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
8
Die UML (Unified Modeling Language) .....................................................
3.3.1
Hintergrund und Geschichte zur UML ........................................
3.3.2
Wichtige Diagrammtypen der UML ............................................
Anlegen und Nutzen eines Punktes ..........................................................
3.4.1
Deklarieren von Referenz-Variablen ...........................................
3.4.2
Anlegen eines Exemplars einer Klasse mit dem new-Operator ....
3.4.3
Zugriff auf Variablen und Methoden mit dem ».« .......................
3.4.4
Konstruktoren nutzen ................................................................
Import und Pakete ...................................................................................
Die API-Dokumentation ...........................................................................
Mit Referenzen arbeiten ...........................................................................
3.7.1
Die null-Referenz .......................................................................
3.7.2
Zuweisungen bei Referenzen .....................................................
3.7.3
Funktionen mit nicht-primitiven Parametern ..............................
Identität und Gleichheit ...........................................................................
3.8.1
Identität von Objekten ..............................................................
3.8.2
Gleichheit und die Methode equals() .........................................
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
Arrays mit nicht-primitiven Elementen .......................................
3.9.8
Vorinitialisierte Arrays ................................................................
3.9.9
Die erweiterte for-Schleife .........................................................
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 Arrays klonen .............................................................................
3.9.15 Feldinhalte kopieren ..................................................................
3.9.16 Die Klasse Arrays zum Vergleichen, Füllen und Suchen ..............
Der Einstiegspunkt für das Laufzeitsystem main() ......................................
3.10.1 Kommandozeilen-Argumente verarbeiten ..................................
3.10.2 Der Rückgabewert von main() und System.exit() ........................
3.10.3 Parser der Kommandozeilenargumente – Apache CLI .................
Eigene Pakete schnüren ............................................................................
3.11.1 Die package-Anweisung .............................................................
3.11.2 Importieren von Klassen mit import ...........................................
3.11.3 Paketnamen ...............................................................................
178
178
179
180
180
180
181
184
184
185
186
186
188
188
190
190
191
193
193
194
195
195
196
197
198
199
199
201
203
204
204
205
206
207
213
213
214
214
216
216
216
217
Inhalt
3.12
4
3.11.4 Hierarchische Strukturen und das Default-Package .....................
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 ......................................................................................
217
218
218
219
220
Der Umgang mit Zeichenketten .......................................................... 221
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
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
Länge eines StringBuffer/-Builder-Objekts lesen und setzen .......
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 mit der Collator-Klasse ..............................
4.5.1
Die Klasse Collator .....................................................................
4.5.2
Effiziente interne Speicherung für die Sortierung ........................
Reguläre Ausdrücke ..................................................................................
4.6.1
Die Klassen Pattern und Matcher ...............................................
4.6.2
Mit MatchResult alle Ergebnisse einsammeln .............................
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 ..........................
221
222
224
226
226
227
229
231
233
235
237
237
238
239
239
240
241
241
242
244
244
244
247
248
248
250
252
252
253
254
258
260
263
263
264
9
Inhalt
4.9
4.10
5
5.2
5.3
5.4
5.5
5.6
5.7
5.8
270
272
274
Arithmetik in Java .....................................................................................
5.1.1
Mantisse und Exponent .............................................................
5.1.2
Spezialwerte Unendlich, Null, NaN ............................................
Wertebereich eines Typs und Überlaufkontrolle ........................................
5.2.1
Behandlung des Überlaufs ..........................................................
Die Eigenschaften der Klasse Math ...........................................................
5.3.1
Attribute ....................................................................................
5.3.2
Winkelfunktionen ......................................................................
5.3.3
Runden von Werten ..................................................................
5.3.4
Wurzel und Exponentialfunktionen ............................................
5.3.5
Der Logarithmus ........................................................................
5.3.6
Rest der ganzzahligen Division ...................................................
5.3.7
Absolutwerte und Maximum/Minimum .....................................
5.3.8
Zufallszahlen ..............................................................................
5.3.9
Der Nächste, bitte .....................................................................
Mathe bitte strikt .....................................................................................
5.4.1
Strikt Fließkomma mit strictfp ....................................................
5.4.2
Die Klassen Math und StrictMath ..............................................
Die Random-Klasse ..................................................................................
Große Zahlen ............................................................................................
5.6.1
Die Klasse BigInteger .................................................................
5.6.2
Funktionen von BigInteger .........................................................
5.6.3
Ganz lange Fakultäten ................................................................
5.6.4
Große Fließkommazahlen mit BigDecimal ..................................
5.6.5
Mit MathContext komfortabel die Rechengenauigkeit setzen .....
Rechnen mit Einheiten: Java Units Specification .......................................
Zum Weiterlesen ......................................................................................
275
275
276
278
278
280
281
281
282
284
284
285
286
286
287
287
287
287
288
290
290
292
294
295
296
297
299
Eigene Klassen schreiben .................................................................... 301
6.1
10
264
265
266
266
269
Mathematisches .................................................................................. 275
5.1
6
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 ......................................................................................
Eigene Klassen deklarieren ....................................................................... 301
6.1.1
Methodenaufrufe und Nebeneffekte .......................................... 304
Inhalt
6.2
6.3
6.4
6.5
6.6
6.7
6.1.2
Argumentübergabe mit Referenzen ............................................
6.1.3
Die this-Referenz .......................................................................
6.1.4
Überdeckte Objektvariablen nutzen ...........................................
Privatsphäre und Sichtbarkeit ...................................................................
6.2.1
Wieso nicht freie Methoden und Variablen für alle? ...................
6.2.2
Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht .......
6.2.3
Zugriffsmethoden für Attribute deklarieren ................................
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 final-Variablen .................
6.4.2
Eincompilierte Belegungen der Klassenvariablen ........................
6.4.3
Typsicherere Konstanten ............................................................
6.4.4
Aufzählungen mit enum .............................................................
6.4.5
enum-Konstanten in switch .......................................................
6.4.6
Enum-Objekte in der Weitergabe ..............................................
6.4.7
Statische Imports von Aufzählungen ..........................................
Objekte anlegen und zerstören .................................................................
6.5.1
Konstruktoren schreiben ............................................................
6.5.2
Konstruktor nimmt ein Objekt vom Typ der eigenen Klasse
(Copy-Konstruktor) ....................................................................
6.5.3
Einen anderen Konstruktor der gleichen Klasse aufrufen ............
6.5.4
Initialisierung der Objekt- und Klassenvariablen .........................
6.5.5
Finale Werte im Konstruktor und in statischen Blöcken setzen ...
6.5.6
Exemplarinitialisierer (Instanzinitialisierer) ..................................
6.5.7
Ihr fehlt uns nicht – der Garbage-Collector .................................
6.5.8
Implizit erzeugte String-Objekte ................................................
6.5.9
Private Konstruktoren, Utility-Klassen, Singleton, Fabriken ........
Assoziationen zwischen Objekten .............................................................
6.6.1
Gegenseitige Abhängigkeiten von Klassen ..................................
Vererbung ................................................................................................
6.7.1
Vererbung in Java ......................................................................
6.7.2
Einfach- und Mehrfachvererbung ...............................................
6.7.3
Gebäude modelliert ...................................................................
6.7.4
Konstruktoren in der Vererbung ................................................
6.7.5
Sichtbarkeit protected ...............................................................
304
305
306
307
309
309
310
313
314
314
315
315
316
317
318
319
319
320
321
323
324
324
325
325
325
328
329
332
334
335
337
338
339
341
342
342
343
343
344
345
347
11
Inhalt
6.8
6.9
6.10
6.11
6.12
12
6.7.6
Das Substitutionsprinzip ............................................................
6.7.7
Automatische und explizite Typanpassung .................................
6.7.8
Typen mit dem binären Operator instanceof testen ....................
6.7.9
Array-Typen und Kovarianz ........................................................
6.7.10 Methoden überschreiben ...........................................................
6.7.11 Mit super eine Methode der Oberklasse aufrufen ......................
6.7.12 Kovariante Rückgabetypen ........................................................
6.7.13 Finale Klassen ............................................................................
6.7.14 Nicht überschreibbare Funktionen .............................................
6.7.15 Zusammenfassung zur Sichtbarkeit .............................................
6.7.16 Sichtbarkeit in der UML .............................................................
6.7.17 Zusammenfassung: Konstruktoren und Methoden .....................
Die Oberklasse gibt Funktionalität vor ......................................................
6.8.1
Spätes dynamisches Binden als Beispiel für Polymorphie ............
6.8.2
Unpolymorph bei privaten, statischen und finalen Methoden ....
6.8.3
Polymorphie bei Konstruktoraufrufen ........................................
Abstrakte Klassen und abstrakte Methoden ..............................................
6.9.1
Abstrakte Klassen ......................................................................
6.9.2
Abstrakte Methoden ..................................................................
Schnittstellen ............................................................................................
6.10.1 Ein Polymorphie-Beispiel mit Schnittstellen ...............................
6.10.2 Die Mehrfachvererbung bei Schnittstellen ..................................
6.10.3 Erweitern von Interfaces – Subinterfaces ....................................
6.10.4 Vererbte Konstanten bei Schnittstellen ......................................
6.10.5 Schnittstellenmethoden, die nicht implementiert werden
müssen ......................................................................................
6.10.6 Abstrakte Klassen und Schnittstellen im Vergleich .....................
6.10.7 CharSequence als Beispiel einer Schnittstelle .............................
6.10.8 Die Schnittstelle Iterable ............................................................
Object ist die Mutter aller Oberklassen .....................................................
6.11.1 Klassenobjekte ...........................................................................
6.11.2 Objektidentifikation mit toString() .............................................
6.11.3 Objektgleichheit mit equals() und Identität ................................
6.11.4 Klonen eines Objekts mit clone() ...............................................
6.11.5 Hashcodes über hashCode() liefern ............................................
6.11.6 Aufräumen mit finalize() ............................................................
6.11.7 Synchronisation .........................................................................
Innere Klassen ..........................................................................................
6.12.1 Statische innere Klassen und Schnittstellen ................................
6.12.2 Mitglieds- oder Elementklassen .................................................
6.12.3 Lokale Klassen ...........................................................................
6.12.4 Anonyme innere Klassen ............................................................
6.12.5 this und Vererbung ....................................................................
348
349
350
351
352
354
356
356
357
357
358
359
360
362
363
365
367
367
368
370
374
375
378
378
380
381
381
383
386
386
386
388
392
395
397
398
399
399
400
403
404
407
Inhalt
6.13
6.14
6.15
7
6.12.6 Implementierung einer verketteten Liste ....................................
6.12.7 Funktionszeiger .........................................................................
Generische Datentypen ............................................................................
6.13.1 Einfache Klassenschablonen .......................................................
6.13.2 Einfache Methodenschablonen ..................................................
6.13.3 Umsetzen der Generics, Typlöschung und Raw-Types ................
6.13.4 Einschränken der Typen .............................................................
6.13.5 Generics und Vererbung, Invarianz ............................................
6.13.6 Wildcards ..................................................................................
Die Spezial-Oberklasse Enum ...................................................................
6.14.1 Methoden auf Enum-Objekten ..................................................
6.14.2 enum mit eigenen Konstruktoren und Methoden ......................
Dokumentationskommentare mit JavaDoc ................................................
6.15.1 Einen Dokumentationskommentar setzen ..................................
6.15.2 Mit javadoc eine Dokumentation erstellen .................................
6.15.3 HTML-Tags in Dokumentationskommentaren ............................
6.15.4 Generierte Dateien ....................................................................
6.15.5 Dokumentationskommentare im Überblick ................................
6.15.6 JavaDoc und Doclets .................................................................
6.15.7 Veraltete (deprecated) Klassen, Konstruktoren und
Methoden .................................................................................
408
410
412
413
414
415
416
418
418
419
420
422
424
425
426
426
427
428
428
429
Exceptions ........................................................................................... 433
7.1
7.2
7.3
Problembereiche einzäunen ......................................................................
7.1.1
Exceptions in Java mit try und catch ..........................................
7.1.2
Eine Datei mit RandomAccessFile auslesen ................................
7.1.3
Ablauf einer Ausnahmesituation ................................................
7.1.4
Wiederholung abgebrochener Bereiche .....................................
7.1.5
throws im Methodenkopf angeben ............................................
7.1.6
Abschlussbehandlung mit finally ................................................
7.1.7
Nicht erreichbare catch-Klauseln ...............................................
Die Klassenhierarchie der Fehler ...............................................................
7.2.1
Die Exception-Hierarchie ...........................................................
7.2.2
Oberausnahmen auffangen ........................................................
7.2.3
Alles geht als Exception durch ...................................................
7.2.4
RuntimeException muss nicht aufgefangen werden ....................
7.2.5
Harte Fehler: Error .....................................................................
Auslösen eigener Exceptions .....................................................................
7.3.1
Mit throw Ausnahmen auslösen .................................................
7.3.2
Neue Exception-Klassen deklarieren ..........................................
7.3.3
Abfangen und Weiterleiten ........................................................
7.3.4
Geschachtelte Ausnahmen .........................................................
433
433
434
435
436
437
440
443
443
444
445
446
447
448
449
449
450
452
453
13
Inhalt
7.4
7.5
7.6
8
454
455
455
456
457
457
457
458
Die Funktionsbibliothek ...................................................................... 459
8.1
8.2
8.3
8.4
8.5
8.6
14
Rückgabewerte bei ausgelösten Ausnahmen .............................................
Der Stack Trace ........................................................................................
7.5.1
Stack Trace aus Throwable .........................................................
7.5.2
Stack Trace aus Thread ...............................................................
Assertions .................................................................................................
7.6.1
Assertions in Java .......................................................................
7.6.2
Assertions in eigenen Programmen nutzen .................................
7.6.3
Assertions aktivieren ..................................................................
Die Java-Klassenphilosophie .....................................................................
8.1.1
Übersicht über die Pakete der Standardbibliothek ......................
Wrapper-Klassen ......................................................................................
8.2.1
Die Basisklasse Number für numerische Wrapper-Objekte .........
8.2.2
Die Klasse Integer ......................................................................
8.2.3
Unterschiedliche Ausgabeformate ..............................................
8.2.4
Autoboxing: Boxing und Unboxing ............................................
8.2.5
Die Boolean-Klasse ....................................................................
8.2.6
Die Klassen Double und Float für Fließkommazahlen .................
Die Utility-Klasse System und Properties ..................................................
8.3.1
Systemeigenschaften der Java-Umgebung ..................................
8.3.2
line.separator .............................................................................
8.3.3
Browser-Version abfragen ..........................................................
8.3.4
Property von der Konsole aus setzen ..........................................
8.3.5
Umgebungsvariablen des Betriebssystems ..................................
8.3.6
Einfache Zeitmessung und Profiling ............................................
Benutzereinstellungen ..............................................................................
8.4.1
Eine zentrale Registry .................................................................
8.4.2
Einträge einfügen, auslesen und löschen ....................................
8.4.3
Auslesen der Daten und Schreiben in anderem Format ..............
8.4.4
Auf Ereignisse horchen ..............................................................
Klassenlader (Class Loader) .......................................................................
8.5.1
Woher die kleinen Klassen kommen ..........................................
8.5.2
Setzen des Klassenpfades ...........................................................
8.5.3
Die wichtigsten drei Typen von Klassenladern ............................
8.5.4
Der java.lang.ClassLoader ..........................................................
8.5.5
Hot Deployment mit dem URL-ClassLoader ...............................
8.5.6
Das jre/lib/endorsed-Verzeichnis ...............................................
8.5.7
getContextClassLoader() vom Thread .........................................
8.5.8
Wie heißt die Klasse mit der Methode main()? ...........................
Design-Pattern und das Beobachten von Änderungen ..............................
8.6.1
Design-Pattern ...........................................................................
459
459
465
467
468
470
470
473
475
475
476
477
478
478
479
480
483
483
484
486
487
487
487
488
489
490
491
494
494
495
496
497
Inhalt
8.7
8.8
8.9
9
8.6.2
Das Beobachter-Pattern (Observer/Observable) .........................
Ausführen externer Programme, Compiler und Skripten ...........................
8.7.1
ProcessBuilder und Prozesskontrolle mit Process .......................
8.7.2
Die Windows-Registry verwenden .............................................
8.7.3
Einen Browser/E-Mail-Client/Editor aufrufen .............................
8.7.4
Ausführen von Skripten .............................................................
8.7.5
Programme mit der Compiler-API übersetzen ............................
Annotationen ...........................................................................................
8.8.1
Annotationstypen @Override, @Deprecated,
@SuppressWarnings ..................................................................
8.8.2
Common Annotations ................................................................
8.8.3
Annotationen für Web-Services .................................................
8.8.4
Annotationen für XML-Mapping ................................................
Zum Weiterlesen ......................................................................................
497
501
501
504
505
506
508
510
510
512
512
512
512
Threads und nebenläufige Programmierung ....................................... 515
9.1
9.2
9.3
9.4
Nebenläufigkeit ........................................................................................
9.1.1
Threads und Prozesse ................................................................
9.1.2
Wie parallele Programme die Geschwindigkeit steigern
können ......................................................................................
Threads erzeugen .....................................................................................
9.2.1
Threads über die Schnittstelle Runnable implementieren ...........
9.2.2
Thread mit Runnable starten ......................................................
9.2.3
Der Name eines Threads ............................................................
9.2.4
Die Klasse Thread erweitern ......................................................
9.2.5
Wer bin ich? ..............................................................................
Der Ausführer (Executor) kommt ..............................................................
9.3.1
Die Schnittstelle Executor ..........................................................
9.3.2
Die Thread-Pools .......................................................................
9.3.3
Threads mit Rückgabe über Callable ..........................................
9.3.4
Mehrere Callable abarbeiten ......................................................
9.3.5
Mit ScheduledExecutorService wiederholende Ausgaben und
Zeitsteuerungen .........................................................................
Die Zustände eines Threads ......................................................................
9.4.1
Threads schlafen ........................................................................
9.4.2
Das Ende eines Threads .............................................................
9.4.3
UncaughtExceptionHandler für unbehandelte Ausnahmen .........
9.4.4
Einen Thread höflich mit Interrupt beenden ...............................
9.4.5
Der stop() von außen und die Rettung mit ThreadDeath ............
9.4.6
Ein Rendezvous mit join() ..........................................................
9.4.7
Barrier und Austausch mit Exchanger .........................................
9.4.8
Mit yield() auf Rechenzeit verzichten .........................................
515
515
516
518
518
519
521
521
524
524
524
526
527
529
530
530
531
532
533
534
536
537
539
540
15
Inhalt
9.5
9.6
9.7
9.8
9.9
9.10
9.11
9.12
16
9.4.9
Arbeit niederlegen und wieder aufnehmen ................................
9.4.10 Priorität .....................................................................................
9.4.11 Der Thread ist ein Dämon ..........................................................
Synchronisation über kritische Abschnitte .................................................
9.5.1
Gemeinsam genutzte Daten .......................................................
9.5.2
Probleme beim gemeinsamen Zugriff und kritische Abschnitte ...
9.5.3
Punkte parallel initialisieren .......................................................
9.5.4
i++ sieht atomar aus, ist es aber nicht ........................................
9.5.5
Kritische Abschnitte schützen ....................................................
9.5.6
Schützen mit ReentrantLock ......................................................
9.5.7
Synchronisieren mit synchronized ..............................................
9.5.8
Synchronized-Methoden der Klasse StringBuffer ........................
9.5.9
Mit synchronized synchronisierte Blöcke ....................................
9.5.10 Dann machen wir doch gleich alles synchronisiert ......................
9.5.11 Look-Freigabe im Fall von Exceptions ........................................
9.5.12 Mit synchronized nachträglich synchronisieren ..........................
9.5.13 Monitore sind reentrant – gut für die Geschwindigkeit ...............
9.5.14 Synchronisierte Methodenaufrufe zusammenfassen ....................
9.5.15 Deadlocks ..................................................................................
9.5.16 Erkennen von Deadlocks ............................................................
Synchronisation über Warten und Benachrichtigen ...................................
9.6.1
Die Schnittstelle Condition ........................................................
9.6.2
Beispiel Erzeuger-Verbraucher-Programm ..................................
9.6.3
Warten mit wait() und Aufwecken mit notify() ...........................
9.6.4
Falls der Lock fehlt: IllegalMonitorStateException ......................
9.6.5
Semaphore ................................................................................
Atomare Operationen und frische Werte mit volatile ................................
9.7.1
Der Modifizierer volatile bei Objekt-/Klassenvariablen ...............
9.7.2
Das Paket java.util.concurrent.atomic ........................................
Mit dem Thread verbundene Variablen .....................................................
9.8.1
ThreadLocal ...............................................................................
9.8.2
InheritableThreadLocal ..............................................................
Gruppen von Threads in einer Thread-Gruppe ..........................................
9.9.1
Aktive Threads in der Umgebung ...............................................
9.9.2
Etwas über die aktuelle Thread-Gruppe herausfinden .................
9.9.3
Threads in einer Thread-Gruppe anlegen ....................................
9.9.4
Methoden von Thread und ThreadGroup im Vergleich ...............
Zeitgesteuerte Abläufe ..............................................................................
9.10.1 Die Klassen Timer und TimerTask ...............................................
9.10.2 Job-Scheduler Quartz .................................................................
Einen Abbruch der virtuellen Maschine erkennen .....................................
Zum Weiterlesen ......................................................................................
540
540
542
544
544
544
545
547
548
549
553
554
555
556
557
558
559
560
561
562
563
564
567
571
573
574
577
577
578
579
580
581
583
583
584
586
588
590
590
591
592
593
Inhalt
10 Raum und Zeit ..................................................................................... 595
10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
10.9
Weltzeit ...................................................................................................
Wichtige Datum-Klassen im Überblick ......................................................
Sprachen der Länder .................................................................................
10.3.1 Sprachen und Regionen über Locale-Objekte .............................
Übersetzung durch ResourceBundle-Objekte ............................................
10.4.1 Ressource-Dateien .....................................................................
10.4.2 Die Klasse ResourceBundle ........................................................
10.4.3 Ladestrategie für ResourceBundle-Objekte ................................
Zeitzonen .................................................................................................
10.5.1 Zeitzonen durch die Klasse TimeZone repräsentieren .................
Die Klasse Date ........................................................................................
10.6.1 Objekte erzeugen und Methoden nutzen ...................................
Calendar und GregorianCalendar ..............................................................
10.7.1 Die abstrakte Klasse Calendar ....................................................
10.7.2 Der gregorianische Kalender ......................................................
10.7.3 Ostertage ...................................................................................
10.7.4 Abfragen und Setzen von Datumselementen ..............................
Formatieren der Datumsangaben ..............................................................
10.8.1 Mit DateFormat und SimpleDateFormat formatieren .................
10.8.2 Parsen von Datumswerten .........................................................
10.8.3 Parsen und Formatieren ab bestimmten Positionen ....................
Zum Weiterlesen ......................................................................................
595
596
596
597
600
600
601
602
603
604
605
605
607
607
608
611
612
617
617
623
624
625
11 Datenstrukturen und Algorithmen ...................................................... 627
11.1
11.2
11.3
Datenstrukturen und die Collection-API ...................................................
11.1.1 Die Schnittstelle Collection ........................................................
11.1.2 Das erste Programm mit Container-Klassen ................................
11.1.3 Die Schnittstelle Iterable und das erweiterte for .........................
11.1.4 Generische Datentypen in der Collection-API ............................
11.1.5 Generischer Typ bei Iterable und konkreter Typ beim
erweiterten for ...........................................................................
11.1.6 Schnittstellen, die Collection erweitern, und Map ......................
11.1.7 Konkrete Container-Klassen .......................................................
Mit einem Iterator durch die Daten wandern ...........................................
11.2.1 Die Schnittstellen Enumeration und Iterator ..............................
11.2.2 Der typisierte Iterator ................................................................
Listen .......................................................................................................
11.3.1 ArrayList oder LinkedList? Speicherung im Feld oder in einer
verketteten Liste ........................................................................
11.3.2 Die Schnittstelle List ..................................................................
627
628
629
630
631
632
632
634
634
634
636
638
638
639
17
Inhalt
11.3.3
11.3.4
11.3.5
11.3.6
11.3.7
11.3.8
ListIterator .................................................................................
Beispiel mit List-Methoden ........................................................
ArrayList ....................................................................................
LinkedList ..................................................................................
Arrays.asList() und die »echten« Listen .......................................
toArray() von Collection verstehen – die Gefahr einer Falle
erkennen ...................................................................................
11.4 Vergleichen von Objekten ........................................................................
11.4.1 Die Schnittstellen Comparator und Comparable .........................
11.4.2 Algorithmen mit Such- und Sortiermöglichkeiten .......................
11.4.3 Den größten und kleinsten Wert einer Collection finden ............
11.4.4 Sortieren ....................................................................................
11.5 Mengen (Sets) ..........................................................................................
11.5.1 HashSet .....................................................................................
11.5.2 TreeSet – die Menge durch Bäume .............................................
11.5.3 LinkedHashSet ...........................................................................
11.6 Stack (Kellerspeicher, Stapel) ....................................................................
11.6.1 Die Methoden von Stack ...........................................................
11.6.2 Ein Stack ist ein Vector – aha! ....................................................
11.7 Queues (Schlangen) ..................................................................................
11.7.1 Blockierende Queues und Prioritätswarteschlangen ...................
11.8 Assoziative Speicher HashMap und TreeMap ............................................
11.8.1 Ein Objekt der Klasse HashMap erzeugen ..................................
11.8.2 Einfügen und Abfragen der Datenstruktur ..................................
11.8.3 Die Bedeutung von equals(), hashCode() und
IdentityHashMap .......................................................................
11.8.4 Elemente im Assoziativspeicher müssen unveränderbar
bleiben ......................................................................................
11.8.5 Aufzählen der Elemente .............................................................
11.8.6 Der Gleichheitstest, Hash-Wert und Klon einer Hash-Tabelle .....
11.8.7 Die Arbeitsweise einer Hash-Tabelle ..........................................
11.9 Die Properties-Klasse ................................................................................
11.9.1 Properties setzen und lesen .......................................................
11.9.2 Properties verketten ..................................................................
11.9.3 Eigenschaften ausgeben .............................................................
11.9.4 Hierarchische Eigenschaften .......................................................
11.9.5 Properties speichern ..................................................................
11.9.6 Über die Beziehung zwischen den Klassen Properties und
Hashtable ..................................................................................
11.10 Algorithmen in Collections .......................................................................
11.10.1 Datenmanipulation: Umdrehen, Füllen, Kopieren ......................
11.10.2 Mit der Halbierungssuche nach Elementen fahnden ...................
18
641
642
645
647
649
649
652
652
654
655
657
659
662
662
664
664
665
665
666
667
668
668
669
671
672
672
674
675
677
677
677
678
679
679
681
681
682
683
Inhalt
11.10.3 Nicht-änderbare Datenstrukturen ..............................................
11.10.4 Häufigkeit eines Elements ..........................................................
11.10.5 nCopies() ...................................................................................
11.10.6 Singletons ..................................................................................
11.11 Synchronisation der Datenstrukturen ........................................................
11.11.1 Lock-Free-Algorithmen aus java.util.concurrent .........................
11.11.2 Wrapper zur Synchronisation .....................................................
11.11.3 CopyOnWriteArrayList und CopyOnWriteArraySet .....................
11.12 Die abstrakten Basisklassen für Container .................................................
11.12.1 Optionale Methoden .................................................................
11.13 Die Klasse BitSet für Bitmengen ................................................................
11.13.1 Ein BitSet anlegen, füllen und erfragen .......................................
11.13.2 Mengenorientierte Operationen ................................................
11.13.3 Funktionsübersicht ....................................................................
11.13.4 Primzahlen in einem BitSet verwalten ........................................
684
684
684
685
686
686
686
687
687
688
689
689
690
691
692
12 Dateien und Datenströme ................................................................... 693
12.1
12.2
12.3
Datei und Verzeichnis ...............................................................................
12.1.1 Dateien und Verzeichnisse mit der Klasse File ............................
12.1.2 Verzeichnis oder Datei? Existiert es? ..........................................
12.1.3 Verzeichnis- und Dateieigenschaften/-attribute .........................
12.1.4 Wurzelverzeichnis, Laufwerksnamen, Plattenspeicher ................
12.1.5 Umbenennen und Verzeichnisse anlegen ...................................
12.1.6 Verzeichnisse listen und Dateien filtern ......................................
12.1.7 Dateien berühren, neue Dateien anlegen, temporäre Dateien ....
12.1.8 Dateien und Verzeichnisse löschen ............................................
12.1.9 Verzeichnisse nach Dateien rekursiv durchsuchen ......................
12.1.10 URL- und URI-Objekte aus einem File-Objekt ableiten ..............
12.1.11 Mit Locking Dateien sperren ......................................................
12.1.12 Sicherheitsprüfung .....................................................................
12.1.13 Mime-Typen mit dem JavaBeans Activation Framework (JAF) ....
12.1.14 Zugriff auf SMB-Server mit jCIFS ................................................
Dateien mit wahlfreiem Zugriff .................................................................
12.2.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen ............
12.2.2 Aus dem RandomAccessFile lesen ..............................................
12.2.3 Schreiben ..................................................................................
12.2.4 Die Länge des RandomAccessFile ..............................................
12.2.5 Hin und her in der Datei ............................................................
12.2.6 Wahlfreier Zugriff und Pufferung mit Unified I/O .......................
Stream-Klassen und Reader/Writer am Beispiel von Dateien .....................
12.3.1 Mit dem FileWriter Texte in Dateien schreiben ..........................
12.3.2 Zeichen mit der Klasse FileReader lesen .....................................
694
694
696
697
699
701
702
704
706
707
708
709
709
709
710
711
712
712
714
715
715
716
717
718
719
19
Inhalt
12.4
12.5
12.6
12.7
12.8
12.9
20
12.3.3 Kopieren mit FileOutputStream und FileInputStream .................
12.3.4 Das FileDescriptor-Objekt ..........................................................
Basisklassen für die Ein-/Ausgabe .............................................................
12.4.1 Die abstrakten Basisklassen ........................................................
12.4.2 Übersicht über Ein-/Ausgabeklassen ..........................................
12.4.3 Die abstrakte Basisklasse OutputStream .....................................
12.4.4 Die Schnittstellen Closeable und Flushable ................................
12.4.5 Ein Datenschlucker ....................................................................
12.4.6 Die abstrakte Basisklasse InputStream ........................................
12.4.7 Ressourcen wie Grafiken aus dem Klassenpfad und aus
Jar-Archiven laden .....................................................................
12.4.8 Ströme mit SequenceInputStream zusammensetzen ...................
12.4.9 Die abstrakte Basisklasse Writer .................................................
12.4.10 Die Schnittstelle Appendable .....................................................
12.4.11 Die abstrakte Basisklasse Reader ................................................
Formatierte Textausgaben ........................................................................
12.5.1 Die Klassen PrintWriter und PrintStream ....................................
12.5.2 System.out, System.err und System.in ........................................
12.5.3 Geschützte Passwort-Eingaben mit der Klasse Console ...............
Schreiben und Lesen aus Strings und Byte-Feldern ...................................
12.6.1
Mit dem StringWriter ein String-Objekt füllen ..........................
12.6.2 CharArrayWriter ........................................................................
12.6.3 StringReader und CharArrayReader ............................................
12.6.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben .............
12.6.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen ................
Datenströme filtern und verketten ............................................................
12.7.1 Writer als Filter verketten ..........................................................
12.7.2 Gepufferte Unicode-Ausgabe mit BufferedWriter .......................
12.7.3 Gepufferte Unicode-Eingabe mit BufferedReader .......................
12.7.4 LineNumberReader zählt automatisch Zeilen mit .......................
12.7.5 Daten mit der Klasse PushbackReader zurücklegen ....................
12.7.6 DataOutputStream/DataInputStream .........................................
12.7.7 Basisklassen für Filter .................................................................
12.7.8 Die Basisklasse FilterWriter ........................................................
12.7.9 Ein LowerCaseWriter .................................................................
12.7.10 Eingaben mit der Klasse FilterReader filtern ...............................
Vermittler zwischen Byte-Streams und Unicode-Strömen .........................
12.8.1 Datenkonvertierung durch den OutputStreamWriter .................
12.8.2 Automatische Konvertierungen mit dem InputStreamReader .....
Kommunikation zwischen Threads mit Pipes ............................................
12.9.1 PipedOutputStream und PipedInputStream ...............................
12.9.2 PipedWriter und PipedReader ...................................................
720
723
724
724
724
725
727
728
728
729
730
732
733
734
736
736
740
743
743
744
744
745
746
747
747
748
748
750
752
752
755
755
756
757
758
759
759
760
761
762
763
Inhalt
12.10 Datenkompression ...................................................................................
12.10.1 Java-Unterstützung beim Komprimieren und
Zusammenpacken ......................................................................
12.10.2 Datenströme komprimieren .......................................................
12.10.3 Zip-Archive ................................................................................
12.10.4 Jar-Archive ................................................................................
12.11 Prüfsummen .............................................................................................
12.11.1 Die Schnittstelle Checksum ........................................................
12.11.2 Die Klasse CRC32 ......................................................................
12.11.3 Die Adler32-Klasse ....................................................................
12.12 Persistente Objekte und Serialisierung ......................................................
12.12.1 Objekte mit der Standard-Serialisierung speichern .....................
12.12.2 Objekte über die Standard-Serialisierung lesen ..........................
12.12.3 Die Schnittstelle Serializable ......................................................
12.12.4 Nicht serialisierbare Attribute aussparen ....................................
12.12.5 Das Abspeichern selbst in die Hand nehmen ..............................
12.12.6 Tiefe Objektkopien ....................................................................
12.12.7 Versionenverwaltung und die SUID ...........................................
12.12.8 Wie die ArrayList serialisiert .......................................................
12.12.9 Probleme mit der Serialisierung .................................................
12.12.10 Serialisieren in XML-Dateien ......................................................
12.12.11 JavaBeans Persistence ................................................................
12.12.12 XStream .....................................................................................
12.13 Tokenizer .................................................................................................
12.13.1 StreamTokenizer ........................................................................
12.13.2 CSV-(Comma Separated Values-)Dateien verarbeiten .................
765
766
766
770
777
777
777
778
780
780
781
784
785
786
788
790
792
794
795
795
796
798
798
798
801
13 Die eXtensible Markup Language (XML) ............................................ 803
13.1
13.2
13.3
Auszeichnungssprachen ............................................................................
13.1.1 Die Standard Generalized Markup Language (SGML) .................
13.1.2 Extensible Markup Language (XML) ...........................................
Eigenschaften von XML-Dokumenten .......................................................
13.2.1 Elemente und Attribute .............................................................
13.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten ...
13.2.3 Schema – eine Alternative zu DTD .............................................
13.2.4 Namensraum (Namespace) ........................................................
13.2.5 XML-Applikationen ...................................................................
Die Java-APIs für XML ..............................................................................
13.3.1 Das Document Object Model (DOM) ........................................
13.3.2 Simple API for XML Parsing (SAX) ..............................................
13.3.3 Pull-API StAX ............................................................................
13.3.4 Java Document Object Model (JDOM) ......................................
803
803
804
804
804
806
809
811
813
813
814
814
814
814
21
Inhalt
13.3.5 JAXP als Java-Schnittstelle zu XML .............................................
13.3.6 DOM-Bäume einlesen mit JAXP .................................................
13.4 Serielle Verarbeitung mit StAX ..................................................................
13.4.1 Unterschiede der Verarbeitungsmodelle ....................................
13.4.2 XML-Dateien mit dem Cursor-Verfahren lesen ...........................
13.4.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten ................
13.4.4 Mit Filtern arbeiten ....................................................................
13.4.5 XML-Dokumente schreiben .......................................................
13.5 Serielle Verarbeitung von XML mit SAX ....................................................
13.5.1 Schnittstellen von SAX ...............................................................
13.5.2 SAX-Parser erzeugen ..................................................................
13.5.3 Die wichtigsten Methoden der Schnittstelle ContentHandler .....
13.5.4 ErrorHandler und EntityResolver ................................................
13.6 XML-Dateien mit JDOM verarbeiten ........................................................
13.6.1 JDOM beziehen .........................................................................
13.6.2 Paketübersicht ...........................................................................
13.6.3 Die Document-Klasse ................................................................
13.6.4 Eingaben aus der Datei lesen .....................................................
13.6.5 Das Dokument im XML-Format ausgeben ..................................
13.6.6 Der Dokumenttyp ......................................................................
13.6.7 Elemente ...................................................................................
13.6.8 Zugriff auf Elementinhalte ..........................................................
13.6.9 Liste mit Unterelementen erzeugen ...........................................
13.6.10 Neue Elemente einfügen und ändern .........................................
13.6.11 Attributinhalte lesen und ändern ...............................................
13.6.12 XPath ........................................................................................
13.7 Transformationen mit XSLT .......................................................................
13.7.1 Templates und XPath als Kernelemente von XSLT ......................
13.7.2 Umwandlung von XML-Dateien mit JDOM und JAXP ................
13.8 Java Architecture for XML Binding (JAXB) .................................................
13.9 HTML-Dokumente einlesen ......................................................................
13.10 Zum Weiterlesen ......................................................................................
815
815
816
816
818
820
821
822
824
825
826
826
828
829
829
830
831
832
833
833
834
836
838
839
841
844
847
847
849
850
852
853
14 Grafische Oberflächen mit Swing ....................................................... 855
14.1
14.2
22
Das Abstract-Window-Toolkit und Swing .................................................
14.1.1 Java Foundation Classes .............................................................
14.1.2 Was Swing vom AWT unterscheidet ..........................................
14.1.3 Peer-Klassen und Lightweight-Komponenten ............................
14.1.4 Die Klasse Toolkit ......................................................................
Fenster unter grafischen Oberflächen ........................................................
14.2.1 Swing-Fenster darstellen ............................................................
14.2.2 Fenster schließbar machen – setDefaultCloseOperation() ...........
855
855
857
857
858
859
859
860
Inhalt
14.3
14.4
14.5
14.6
14.7
14.8
14.2.3 AWT-Fenster darstellen .............................................................
14.2.4 Sichtbarkeit des Fensters ............................................................
14.2.5 Größe und Position des Fensters verändern ...............................
14.2.6 Unterklassen der Fenster-Klassen bilden ....................................
14.2.7 Fenster- und Dialog-Dekoration ................................................
14.2.8 Dynamisches Layout während einer Größenänderung ................
Beschriftungen über die Klasse JLabel .......................................................
14.3.1 Mehrzeiliger Text, HTML in der Darstellung ...............................
Es tut sich was – Ereignisse beim AWT ......................................................
14.4.1 Die Klasse AWTEvent ................................................................
14.4.2 Events auf verschiedenen Ebenen ..............................................
14.4.3 Ereignisquellen und Horcher (Listener) .......................................
14.4.4 Listener implementieren ............................................................
14.4.5 Listener bei dem Ereignisauslöser anmelden/abmelden ..............
14.4.6 Aufrufen der Listener im AWT-Event-Thread .............................
14.4.7 Adapterklassen nutzen ...............................................................
14.4.8 Innere Mitgliedsklassen und innere anonyme Klassen ................
14.4.9 Generic Listener .........................................................................
Schaltfläche ..............................................................................................
14.5.1 Der JButton ...............................................................................
14.5.2 Der aufmerksame ActionListener ...............................................
14.5.3 AbstractButton ..........................................................................
14.5.4 JToggleButton ............................................................................
Icon und ImageIcon für Bilder auf Swing-Komponenten ...........................
14.6.1 Die Schnittstelle Icon .................................................................
14.6.2 Was Icon und Image verbindet ..................................................
JComponent und Component als Basis aller Komponenten .......................
14.7.1 Ereignisse jeder Komponente .....................................................
14.7.2 Die Größe eine Komponente .....................................................
14.7.3 Die Position der Komponente ....................................................
14.7.4 Properties ..................................................................................
14.7.5 Fokus .........................................................................................
14.7.6 Komponenten-Ereignisse ...........................................................
14.7.7 Hinzufügen von Komponenten ..................................................
14.7.8 Zeichnen von Komponenten und die Undurchsichtigkeit ...........
14.7.9 Tooltips .....................................................................................
14.7.10 Rahmen (Border) .......................................................................
Container .................................................................................................
14.8.1 JPanel ........................................................................................
14.8.2 JScrollPane ................................................................................
14.8.3 JTabbedPane .............................................................................
14.8.4 JSplitPane ..................................................................................
861
861
862
863
864
864
864
868
868
868
869
871
872
874
875
875
877
878
879
879
880
882
885
885
887
888
889
889
892
892
893
893
894
896
896
897
898
900
901
901
902
903
23
Inhalt
14.9
14.10
14.11
14.12
14.13
14.14
14.15
14.16
14.17
24
Alles Auslegungssache: die Layoutmanager ...............................................
14.9.1 Übersicht über Layoutmanager ..................................................
14.9.2 Zuweisen eines Layoutmanagers ................................................
14.9.3 Im Fluss mit FlowLayout ............................................................
14.9.4 Mit BorderLayout in allen Himmelsrichtungen ...........................
14.9.5 Rasteranordnung mit GridLayout ...............................................
14.9.6 Der GridBagLayout-Manager .....................................................
14.9.7 Null-Layout ...............................................................................
14.9.8 BoxLayout .................................................................................
14.9.9 Weitere Layoutmanager .............................................................
Rollbalken und Slider ................................................................................
14.10.1 Der Schieberegler JSlider ...........................................................
14.10.2 Der Rollbalken JScrollBar ...........................................................
Kontrollfelder, Optionsfelder, Kontrollfeldgruppen ...................................
14.11.1 Kontrollfelder (JCheckBox) .........................................................
14.11.2 Ereignisse über ItemListener ......................................................
14.11.3 Sich gegenseitig ausschließende Optionen (JRadioButton) .........
Der Fortschrittsbalken JProgressBar ..........................................................
Menüs und Symbolleisten ........................................................................
14.13.1 Die Menüleisten und die Einträge ..............................................
14.13.2 Menüeinträge definieren ...........................................................
14.13.3 Einträge durch Action-Objekte beschreiben ...............................
14.13.4 Mnemonics und Shortcuts (Accelerator) ....................................
14.13.5 Symbolleisten alias Toolbars ......................................................
14.13.6 Popup-Menüs ............................................................................
14.13.7 System-Tray nutzen ..................................................................
Das Konzept des Model-View-Controllers ................................................
Auswahlmenüs, Listen und Spinner ..........................................................
14.15.1 Das Auswahlmenü JComboBox ..................................................
14.15.2 Zuordnung einer Taste mit einem Eintrag ...................................
14.15.3 Datumsauswahl .........................................................................
14.15.4 Die JList .....................................................................................
14.15.5 JSpinner .....................................................................................
Texteingabefelder .....................................................................................
14.16.1 Text in einer Eingabezeile ..........................................................
14.16.2 Die Oberklasse der JText-Komponenten: JTextComponent ........
14.16.3 JPasswordField ..........................................................................
14.16.4 Validierende Eingabefelder ........................................................
14.16.5 Mehrzeilige Textfelder ...............................................................
14.16.6 Die Editor-Klasse JEditorPane ....................................................
Bäume mit JTree-Objekten .......................................................................
14.17.1 Selektionen bemerken ...............................................................
904
904
905
906
908
910
912
916
917
918
918
918
920
924
924
926
928
930
932
932
934
935
937
939
941
945
946
948
948
951
952
953
956
957
958
959
960
960
961
964
966
968
Inhalt
14.18 Tabellen mit JTable ...................................................................................
14.18.1 Ein eigenes Tabellen-Model .......................................................
14.18.2 AbstractTableModel ..................................................................
14.18.3 DefaultTableModel ....................................................................
14.18.4 Ein eigener Renderer für Tabellen ..............................................
14.18.5 Zell-Editoren ..............................................................................
14.18.6 Größe und Umrandung der Zellen ..............................................
14.18.7 Spalteninformationen ................................................................
14.18.8 Tabellenkopf von Swing-Tabellen ..............................................
14.18.9 Selektionen einer Tabelle ...........................................................
14.18.10 Automatisches Sortieren und Filtern mit RowSorter ...................
14.18.11 Ein professionelles Tabellenlayout mit JGrid ...............................
14.19 JRootPane, JLayeredPane und JDesktopPane ............................................
14.19.1 JRootPane .................................................................................
14.19.2 JLayeredPane .............................................................................
14.19.3 JDesktopPane und die Kinder JInternalFrame ............................
14.20 Dialoge und Window-Objekte ..................................................................
14.20.1 JWindow und JDialog ................................................................
14.20.2 Modal oder nicht-modal ............................................................
14.20.3 Standarddialoge mit JOptionPane ..............................................
14.20.4 Der Farbauswahldialog JColorChooser .......................................
14.20.5 Der Dateiauswahldialog .............................................................
14.21 Flexibles Java-Look & Feel ........................................................................
14.21.1 L&F global setzten .....................................................................
14.21.2 UIManager ................................................................................
14.21.3 Verbessern des Aussehens unter Windows mit JGoodies
Looks .........................................................................................
14.21.4 Swing-Beschriftungen eine andere Sprache geben ......................
14.22 Die Zwischenablage (Clipboard) ...............................................................
14.22.1 Clipboard-Objekte .....................................................................
14.22.2 Auf den Inhalt zugreifen mit Transferable ...................................
14.22.3 DataFlavor ist das Format der Daten in der Zwischenablage .......
14.22.4 Einfügungen in der Zwischenablage erkennen ............................
14.22.5 Drag & Drop ..............................................................................
14.23 Undo durchführen ....................................................................................
14.24 AWT, Swing und die Threads ....................................................................
14.24.1 Swing ist nicht thread-sicher ......................................................
14.24.2 Swing-Elemente mit invokeLater() und invokeAndWait()
bedienen ...................................................................................
14.24.3 SwingWorker .............................................................................
14.24.4 Eigene Ereignisse in die Queue setzen .......................................
14.24.5 Auf alle Ereignisse hören ............................................................
969
970
971
974
975
979
980
980
981
981
982
983
983
984
984
984
986
987
987
987
989
991
995
995
995
997
997
998
998
999
1000
1002
1002
1003
1005
1006
1008
1009
1011
1012
25
Inhalt
14.25 Selbst definierte Cursor ............................................................................
14.26 Benutzerinteraktionen automatisieren ......................................................
14.26.1 Automatisch in die Tasten hauen ...............................................
14.26.2 Mausoperationen ......................................................................
14.26.3 Methoden zur Zeitsteuerung ......................................................
14.26.4 Screenshots ...............................................................................
14.26.5 Funktionsweise und Beschränkungen .........................................
14.26.6 MouseInfo und PointerInfo ........................................................
14.27 Zeitliches Ausführen mit dem javax.swing.Timer .......................................
14.28 Alternativen zu AWT und Swing ...............................................................
14.28.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor .........
14.28.2 SWT ..........................................................................................
14.29 Zum Weiterlesen ......................................................................................
1012
1014
1014
1015
1016
1016
1017
1017
1017
1018
1018
1019
1019
15 Grafikprogrammierung ........................................................................ 1021
15.1
15.2
15.3
15.4
15.5
26
Grundlegendes zum Zeichnen ................................................................... 1021
15.1.1 Die paint()-Methode für das AWT-Frame ................................... 1021
15.1.2 Zeichen von Inhalten mit JFrame ............................................... 1023
15.1.3 Auffordern zum Neuzeichnen mit repaint() ................................ 1024
15.1.4 Grundbegriffe: Koordinaten, Punkte, Pixel ................................. 1024
15.1.5 Die ereignisorientierte Programmierung ändert Fensterinhalte ... 1025
15.1.6 Java 2D-API ............................................................................... 1026
Einfache Zeichenfunktionen ...................................................................... 1027
15.2.1 Linien ........................................................................................ 1027
15.2.2 Rechtecke .................................................................................. 1028
15.2.3 Ovale und Kreisbögen ................................................................ 1028
15.2.4 Polygone und Polylines .............................................................. 1029
Zeichenketten schreiben und Fonts .......................................................... 1032
15.3.1 Zeichenfolgen schreiben ............................................................ 1032
15.3.2 Die Font-Klasse ......................................................................... 1032
15.3.3 Einen neuen Font aus einem gegebenen Font ableiten ............... 1034
15.3.4 Zeichensätze des Systems ermitteln ........................................... 1035
15.3.5 Neue TrueType-Fonts in Java nutzen .......................................... 1036
15.3.6 Font-Metadaten durch FontMetrics ........................................... 1036
Geometrische Objekte .............................................................................. 1039
15.4.1 Die Schnittstelle Shape .............................................................. 1041
15.4.2 Kreisförmiges ............................................................................. 1042
15.4.3 Kurviges .................................................................................... 1042
15.4.4 Area und die konstruktive Flächengeometrie ............................. 1042
15.4.5 Pfade ......................................................................................... 1043
Farben und die Paint-Schnittstelle, Linientypen ........................................ 1046
15.5.1 Zufällige Farbblöcke zeichnen .................................................... 1046
Inhalt
15.5.2 Farben mit der Klasse Color .......................................................
15.5.3 Die Farben des Systems über SystemColor .................................
15.5.4 Composite und Xor ....................................................................
15.5.5 Dicke und Art der Linien von Formen bestimmen ......................
15.6 Bilder .......................................................................................................
15.6.1 Eine Übersicht über die Bilder-Bibliotheken ...............................
15.6.2 Bilder mit ImageIO lesen ...........................................................
15.6.3 Ein Bild zeichnen .......................................................................
15.6.4 Programm-Icon/Fenster-Icon setzen ..........................................
15.6.5 Splash-Screen ............................................................................
15.6.6 Bilder im Speicher erzeugen .......................................................
15.6.7 Kein Flackern durch Double-Buffering .......................................
15.6.8 Bilder skalieren ..........................................................................
15.6.9 Schreiben mit ImageIO ..............................................................
15.6.10 Java Image Management Interface (JIMI) ...................................
15.6.11 Pixel für Pixel auslesen und schreiben ........................................
15.6.12 Asynchrones Laden mit getImage() und dem MediaTracker .......
15.6.13 VolatileImage ............................................................................
15.7 Clipping-Operationen ...............................................................................
15.8 Zeichenhinweise durch RenderingHints ....................................................
15.9 Transformationen mit einem AffineTransform-Objekt ...............................
15.10 Drucken ...................................................................................................
15.10.1 Drucken mit dem einfachen Ansatz ............................................
15.10.2 Ein PrintJob ...............................................................................
15.10.3 Drucken der Inhalte ...................................................................
15.10.4 Komponenten drucken ..............................................................
15.10.5 Den Drucker am Parallelport ansprechen ...................................
15.10.6 Bekannte Drucker ......................................................................
15.11 Grafikverarbeitung ohne grafische Oberfläche ...........................................
15.11.1 Xvfb-Server ................................................................................
15.11.2 Pure Java AWT Toolkit (PJA) ......................................................
15.12 Zum Weiterlesen ......................................................................................
1048
1051
1054
1055
1058
1059
1060
1062
1065
1065
1066
1067
1069
1070
1074
1074
1076
1077
1078
1081
1082
1084
1084
1085
1086
1088
1089
1090
1090
1091
1091
1091
16 Das Netz .............................................................................................. 1093
16.1
16.2
Grundlegende Begriffe ..............................................................................
16.1.1 Internet-Standards und RFC .......................................................
URI und URL ............................................................................................
16.2.1 URI ............................................................................................
16.2.2 Die Klasse URL ..........................................................................
16.2.3 Informationen über eine URL .....................................................
16.2.4 Der Zugriff auf die Daten über die Klasse URL ............................
16.2.5 Verbindungen durch einen Proxy-Server ....................................
1093
1094
1094
1094
1095
1097
1099
1101
27
Inhalt
16.3
Die Klasse URLConnection .......................................................................
16.3.1 Methoden und Anwendung von URLConnection .......................
16.3.2 Protokoll- und Content-Handler ................................................
16.3.3 Im Detail: vom URL zu URLConnection ......................................
16.3.4 Der Protokoll-Handler für Jar-Dateien ........................................
16.3.5 Verbindungen und Proxy-Authentifizierung mit
Basic Authentication ..................................................................
16.4 Mit GET und POST Daten übergen ...........................................................
16.4.1 Kodieren der Parameter für Serverprogramme ...........................
16.4.2 Eine Suchmaschine ansprechen ..................................................
16.5 Host- und IP-Adressen .............................................................................
16.5.1 Lebt der Rechner? ......................................................................
16.5.2 Das Netz ist Klasse … ................................................................
16.5.3 IP-Adresse des lokalen Hosts .....................................................
16.6 NetworkInterface .....................................................................................
16.7 Mit dem Socket zum Server ......................................................................
16.7.1 Das Netzwerk ist der Computer .................................................
16.7.2 Sockets ......................................................................................
16.7.3 Eine Verbindung zum Server aufbauen .......................................
16.7.4 Server unter Spannung: die Ströme ............................................
16.7.5 Die Verbindung wieder abbauen ................................................
16.7.6 Informationen über den Socket ..................................................
16.7.7 Reine Verbindungsdaten über SocketAddress ............................
16.8 Client/Server-Kommunikation ..................................................................
16.8.1 Warten auf Verbindungen ..........................................................
16.8.2 Ein Multiplikationsserver ...........................................................
16.8.3 Blockierendes Lesen ...................................................................
16.8.4 Von außen erreichbar sein .........................................................
16.9 Apache Jakarta Commons HttpClient und Net ..........................................
16.9.1 Jakarta Commons HttpClient ......................................................
16.9.2 Jakarta Commons Net ................................................................
16.10 Arbeitsweise eines Webservers .................................................................
16.10.1 Das Hypertext Transfer Protocol (HTTP) .....................................
16.10.2 Anfragen an den Server ..............................................................
16.10.3 Die Antworten vom Server .........................................................
16.10.4 Webserver mit com.sun.net.httpserver.HttpServer .....................
16.11 Datagram-Sockets ....................................................................................
16.11.1 Die Klasse DatagramSocket ........................................................
16.11.2 Datagramme und die Klasse DatagramPacket .............................
16.11.3 Auf ein hereinkommendes Paket warten ....................................
16.11.4 Ein Paket zum Senden vorbereiten .............................................
16.11.5 Methoden der Klasse DatagramPacket .......................................
16.11.6 Das Paket senden ......................................................................
28
1101
1102
1104
1105
1106
1107
1109
1109
1111
1111
1113
1114
1114
1115
1116
1116
1117
1117
1118
1119
1119
1121
1122
1122
1123
1126
1127
1128
1128
1129
1129
1129
1130
1133
1136
1137
1139
1140
1141
1142
1143
1144
Inhalt
16.12 E-Mail ......................................................................................................
16.12.1 Wie eine E-Mail um die Welt geht .............................................
16.12.2 Das Simple Mail Transfer Protocol und RFC 822 ........................
16.12.3 POP (Post Office Protocol) .........................................................
16.12.4 Die JavaMail API .......................................................................
16.12.5 E-Mails versenden .....................................................................
16.12.6 MimeMultipart-Nachrichten schicken ........................................
16.12.7 E-Mails mittels POP3 abrufen ....................................................
16.12.8 Ereignisse und Suchen ...............................................................
16.13 Tiefer liegende Netzwerkeigenschaften .....................................................
16.13.1 Internet Control Message Protocol (ICMP) .................................
16.13.2 MAC-Adresse ............................................................................
16.14 Zum Weiterlesen ......................................................................................
1145
1145
1145
1146
1146
1147
1148
1149
1150
1151
1151
1152
1153
17 JavaServer Pages und Servlets ............................................................ 1155
17.1
17.2
17.3
17.4
17.5
17.6
Dynamisch generierte Webseiten .............................................................
17.1.1 Was sind Servlets? .....................................................................
17.1.2 Was sind JavaServer Pages? .......................................................
Servlets und JSPs mit Tomcat entwickeln ..................................................
17.2.1 Servlet-Container .......................................................................
17.2.2 Entwicklung der Servlet/JSP-Spezifikationen ..............................
17.2.3 Webserver mit Servlet-Funktionalität .........................................
17.2.4 Tomcat ......................................................................................
17.2.5 Ablageort für eigene JSP-Seiten .................................................
17.2.6 Webapplikationen .....................................................................
17.2.7 Zuordnung von Webapplikationen zu physikalischen
Verzeichnissen ...........................................................................
17.2.8 Mit dem WTP ein Web-Projekt entwickeln ................................
JSP-Konstrukte .........................................................................................
17.3.1 Scriptlets ...................................................................................
17.3.2 Ausdrücke .................................................................................
17.3.3 Deklarationen ............................................................................
17.3.4 Kommentare ..............................................................................
17.3.5 Quoting .....................................................................................
17.3.6 Entsprechende XML-Tags ..........................................................
Implizite Objekte ......................................................................................
Formulardaten ..........................................................................................
Auf Beans zurückgreifen ...........................................................................
17.6.1 Die Bean-Klasse .........................................................................
17.6.2 Beans in JSP-Seiten anlegen .......................................................
17.6.3 Attribute setzen und erfragen ....................................................
17.6.4 Der schnelle Zugriff auf Parameter .............................................
1155
1156
1156
1157
1157
1158
1158
1159
1159
1160
1161
1161
1163
1164
1164
1165
1165
1166
1166
1166
1167
1169
1169
1170
1170
1171
29
Inhalt
17.7
17.8
17.9
17.10
17.11
17.12
17.13
17.14
17.15
17.16
17.17
30
Mit HttpServletRequest an die geschickten Browser-Daten ....................... 1171
17.7.1 Verarbeiten der Header ............................................................. 1172
17.7.2 Hilfsfunktion im Umgang mit Headern ....................................... 1172
17.7.3 Übersicht der Browser-Header ................................................... 1173
Das HttpServletResponse-Objekt .............................................................. 1174
17.8.1 Automatisches Neuladen ........................................................... 1174
17.8.2 Seiten umlenken ........................................................................ 1174
JSP-Direktiven .......................................................................................... 1175
17.9.1 page-Direktiven im Überblick .................................................... 1176
17.9.2 Die include-Direktive ................................................................. 1177
17.9.3 Mit JSPs Bilder generieren ......................................................... 1178
Aktionen .................................................................................................. 1179
17.10.1 Die Aktion include ..................................................................... 1179
17.10.2 Die Aktion forward .................................................................... 1179
17.10.3 Die Aktion plugin ...................................................................... 1179
Kleine Kekse: die Klasse Cookies .............................................................. 1180
17.11.1 Cookies erzeugen und setzen ..................................................... 1181
17.11.2 Cookies vom Servlet einlesen ..................................................... 1182
17.11.3 Cookie-Status ändern ................................................................. 1183
17.11.4 Langlebige Cookies .................................................................... 1184
Sitzungsverfolgung (Session Tracking) ....................................................... 1184
17.12.1 Das mit einer Sitzung verbundene Objekt HttpSession ............... 1185
17.12.2 Werte mit einer Sitzung assoziieren und auslesen ...................... 1185
17.12.3 URL-Rewriting ........................................................................... 1186
17.12.4 Zusätzliche Informationen .......................................................... 1187
JSTL und weitere Tag-Libraries ................................................................. 1189
17.13.1 Standard Tag Library (JSTL) ........................................................ 1189
17.13.2 Jakarta Taglibs Project ................................................................ 1191
Servlets .................................................................................................... 1191
17.14.1 Servlets compilieren ................................................................... 1192
17.14.2 Die Servlets in das classes-Verzeichnis bringen ........................... 1192
17.14.3 Servlet-Mapping ........................................................................ 1193
Der Lebenszyklus eines Servlets ................................................................ 1195
17.15.1 Abfragen bei service() ................................................................ 1196
17.15.2 Mehrere Anfragen beim Servlet und die Thread-Sicherheit ........ 1197
17.15.3 Das Ende eines Servlets ............................................................. 1197
Das HttpServletResponse-Objekt .............................................................. 1197
17.16.1 Wir generieren eine Webseite .................................................... 1197
17.16.2 Binärdaten senden ..................................................................... 1199
17.16.3 Noch mehr über Header, die der Server setzt ............................. 1200
Objekte und Dateien per POST verschicken .............................................. 1201
17.17.1 Datei-Upload ............................................................................. 1202
Inhalt
17.18 Servlets und Sessions ................................................................................
17.19 Weiterleiten und Einbinden von Servlet-Inhalten ......................................
17.20 Inter-Servlet-Kommunikation ...................................................................
17.20.1 Daten zwischen Servlets teilen ...................................................
17.21 Internationalisierung ................................................................................
17.21.1 Die Länderkennung des Anfragers auslesen ................................
17.21.2 Länderkennung für die Ausgabe setzen ......................................
17.21.3 Westeuropäische Texte senden ..................................................
17.22 Tomcat: Spezielles ....................................................................................
17.22.1 Tomcat als Service unter Windows NT ausführen .......................
17.23 Zum Weiterlesen ......................................................................................
1203
1204
1205
1205
1205
1206
1206
1206
1208
1208
1208
18 Verteilte Programmierung mit RMI und Web-Services ...................... 1211
18.1
18.2
18.3
18.4
18.5
18.6
18.7
18.8
Entfernte Objekte und Methoden .............................................................
18.1.1 Stellvertreter helfen bei entfernten Methodenaufrufen ..............
18.1.2 Standards für entfernte Objekte .................................................
Java Remote Method Invocation ..............................................................
18.2.1 Zusammenspiel von Server, Registry und Client .........................
18.2.2 Wie die Stellvertreter die Daten übertragen ...............................
18.2.3 Probleme mit entfernten Methoden ..........................................
18.2.4 Nutzen von RMI bei Middleware-Lösungen ...............................
18.2.5 Zentrale Klassen und Schnittstellen ............................................
18.2.6 Entfernte und lokale Objekte im Vergleich .................................
Auf der Serverseite ...................................................................................
18.3.1 Entfernte Schnittstelle deklarieren .............................................
18.3.2 Remote-Objekt-Implementierung ..............................................
18.3.3 Stellvertreterobjekte erzeugen ...................................................
18.3.4 Der Namensdienst (Registry) ......................................................
18.3.5 Remote-Objekt-Implementierung exportieren und beim
Namensdienst anmelden ............................................................
18.3.6 Einfaches Logging ......................................................................
18.3.7 Aufräumen mit dem DGC ..........................................................
Auf der Clientseite ....................................................................................
Entfernte Objekte übergeben und laden ...................................................
18.5.1 Klassen vom RMI-Klassenlader nachladen ..................................
Der Server startet die Registry selbst .........................................................
Weitere Eigenschaften von RMI ...............................................................
18.7.1 RMI und CORBA .......................................................................
18.7.2 RMI über HTTP getunnelt ..........................................................
18.7.3 Automatische Remote-Objekt-Aktivierung .................................
Daily Soap ................................................................................................
18.8.1 SOAP-Protokoll .........................................................................
1211
1211
1213
1213
1213
1213
1214
1216
1216
1217
1217
1217
1218
1219
1219
1220
1222
1222
1223
1224
1224
1225
1226
1226
1226
1227
1227
1228
31
Inhalt
18.8.2 Die technische Realisierung .......................................................
18.8.3 SOAP-Implementierungen .........................................................
18.8.4 @WebService in Java 6 .............................................................
18.8.5 Einen Web-Service definieren ....................................................
18.8.6 Web-Services veröffentlichen .....................................................
18.8.7 Einen JAX-WS-Client implementieren ........................................
18.9 Java Message Service (JMS) ......................................................................
18.10 Zum Weiterlesen ......................................................................................
1228
1229
1229
1229
1230
1231
1233
1233
19 Applets, Midlets und Sound ............................................................... 1235
19.1
19.2
19.3
19.4
19.5
19.6
Applets in der Wiege von Java .................................................................. 1235
19.1.1 (J)Applet und Applikationen ...................................................... 1235
19.1.2 Das erste Hallo-Applet ............................................................... 1235
19.1.3 Die Zyklen eines Applets ............................................................ 1237
19.1.4 Parameter an das Applet übergeben .......................................... 1237
19.1.5 Wie das Applet den Browser-Inhalt ändern kann ....................... 1239
19.1.6 Den Ursprung des Applets erfragen ............................................ 1239
19.1.7 Datenaustausch zwischen Applets .............................................. 1240
19.1.8 Was ein Applet alles darf ........................................................... 1243
Fehler in Applets finden ........................................................................... 1244
19.2.1 Ist Java im Browser aktiviert? ..................................................... 1244
19.2.2 Läuft das Applet unter Netscape oder Microsoft Explorer? ......... 1244
19.2.3 Datenaustausch zwischen Applets und JavaScript ....................... 1246
Musik in einem Applet und in Applikationen ............................................ 1246
19.3.1 Die Arbeit mit AudioClip ........................................................... 1247
19.3.2 Java Sound API .......................................................................... 1247
Webstart .................................................................................................. 1248
Java Micro Edition .................................................................................... 1249
19.5.1 Konfigurationen ......................................................................... 1249
19.5.2 Profile ........................................................................................ 1250
Zum Weiterlesen ...................................................................................... 1252
20 Datenbankmanagement mit JDBC ...................................................... 1253
20.1
20.2
20.3
32
Das relationale Modell .............................................................................
Datenbanken und Tools ............................................................................
20.2.1 HSQLDB ....................................................................................
20.2.2 Weitere Datenbanken ................................................................
20.2.3 Eclipse-Plugins zum Durchschauen von Datenbanken ................
JDBC und Datenbanktreiber .....................................................................
20.3.1 Treibertypen ..............................................................................
20.3.2 JDBC-Versionen .........................................................................
1253
1254
1254
1255
1256
1258
1259
1260
Inhalt
20.4
20.5
20.6
20.7
20.8
20.9
20.10
20.11
20.12
20.13
20.14
20.15
Eine Beispielabfrage .................................................................................
20.4.1 Schritte zur Datenbankabfrage ...................................................
20.4.2 Client für HSQLDB-Datenbank ...................................................
Mit Java an eine Datenbank andocken .....................................................
20.5.1 Der Treiber-Manager .................................................................
20.5.2 Den Treiber laden ......................................................................
20.5.3 Eine Aufzählung aller Treiber .....................................................
20.5.4 Log-Informationen .....................................................................
20.5.5 Verbindung zur Datenbank auf- und abbauen ............................
20.5.6 DataSource ................................................................................
20.5.7 Gepoolte Verbindungen .............................................................
Datenbankabfragen ..................................................................................
20.6.1 Abfragen über das Statement-Objekt .........................................
20.6.2 Ergebnisse einer Abfrage in ResultSet ........................................
20.6.3 Java und SQL-Datentypen ..........................................................
20.6.4 Unicode in der Spalte korrekt auslesen ......................................
20.6.5 wasNull() bei ResultSet ..............................................................
20.6.6 Wie viele Zeilen hat ein ResultSet? ............................................
Die Ausnahmen bei JDBC .........................................................................
Elemente einer Datenbank hinzufügen und aktualisieren ..........................
20.8.1 Batch-Updates ...........................................................................
ResultSets in Bohnen durch RowSet .........................................................
20.9.1 Die Schnittstelle RowSet ............................................................
20.9.2 Implementierungen von RowSet ................................................
20.9.3 Der Typ CachedRowSet .............................................................
20.9.4 Der Typ WebRowSet .................................................................
Vorbereitete Anweisungen (Prepared Statements) ....................................
20.10.1 PreparedStatement-Objekte vorbereiten ....................................
20.10.2 Werte für die Platzhalter eines PreparedStatement ....................
Transaktionen ...........................................................................................
Die LOBs (Large Objects) ..........................................................................
20.12.1 Einen BLOB besorgen ................................................................
Metadaten ...............................................................................................
20.13.1 Metadaten über die Tabelle .......................................................
20.13.2 Informationen über die Datenbank ............................................
Einführung in SQL ....................................................................................
20.14.1 Ein Rundgang durch SQL-Anfragen ............................................
20.14.2 Datenabfrage mit der Data Query Language (DQL) ....................
20.14.3 Tabellen mit der Data Definition Language (DDL) anlegen .........
Zum Weiterlesen ......................................................................................
1261
1261
1262
1263
1264
1264
1265
1266
1267
1270
1273
1273
1273
1275
1276
1279
1279
1280
1280
1281
1282
1283
1283
1284
1284
1285
1287
1288
1289
1290
1290
1291
1291
1291
1294
1295
1296
1297
1299
1300
33
Inhalt
21 Reflection und Annotationen .............................................................. 1301
21.1
21.2
21.3
21.4
21.5
21.6
Metadaten ...............................................................................................
21.1.1 Metadaten durch Java-Doc Tags ................................................
21.1.2 XDoclet .....................................................................................
Metadaten der Klassen mit dem Class-Objekt ...........................................
21.2.1 An ein Class-Objekt kommen .....................................................
21.2.2 Was das Class-Objekt beschreibt ...............................................
21.2.3 Der Name der Klasse .................................................................
21.2.4 Die Arbeit auf dem Feld .............................................................
21.2.5 instanceof mit Class-Objekten ....................................................
21.2.6 Oberklassen finden ....................................................................
21.2.7 Implementierte Interfaces einer Klasse oder eines Interfaces ......
21.2.8 Modifizierer und die Klasse Modifier .........................................
21.2.9 Die Attribute einer Klasse ..........................................................
21.2.10 Methoden einer Klasse erfragen .................................................
21.2.11 Konstruktoren einer Klasse ........................................................
21.2.12 Annotationen ............................................................................
Objekte manipulieren ...............................................................................
21.3.1 Objekte erzeugen ......................................................................
21.3.2 Die Belegung der Variablen erfragen ..........................................
21.3.3 Eine generische toString()-Funktion ...........................................
21.3.4 Variablen setzen ........................................................................
21.3.5 Private Attribute ändern ............................................................
Methoden aufrufen ..................................................................................
21.4.1 Statische Methoden aufrufen .....................................................
21.4.2 Dynamische Methodenaufrufe bei festen Methoden
beschleunigen ............................................................................
Informationen und Identifizierung von Paketen ........................................
21.5.1 Geladene Pakete ........................................................................
Annotationen ...........................................................................................
21.6.1 Neue Annotationen definieren ...................................................
21.6.2 Annotationen mit genau einem Element ....................................
21.6.3 Beliebige Schlüssel-Werte-Paare ................................................
21.6.4 Vorbelegte Elemente .................................................................
21.6.5 Annotieren von Annotationstypen .............................................
21.6.6 Annotationen zur Laufzeit ausgelesen ........................................
21.6.7 Mögliche Nachteile von Annotationen .......................................
1301
1301
1302
1302
1303
1305
1306
1308
1309
1310
1310
1311
1313
1315
1319
1321
1321
1321
1322
1324
1326
1328
1328
1330
1330
1332
1332
1332
1332
1333
1334
1337
1338
1340
1342
22 Komponenten durch Bohnen .............................................................. 1345
22.1
34
Grundlagen der Komponententechnik ...................................................... 1345
22.1.1 Brauchen wir überhaupt Komponenten? .................................... 1345
Inhalt
22.2
22.3
22.4
22.5
22.1.2 Visuelle und nichtvisuelle Komponenten ...................................
22.1.3 Komponenten-Technologien von Microsoft ...............................
Worauf JavaBeans basieren .......................................................................
Eigenschaften ...........................................................................................
22.3.1 Einfache Eigenschaften ..............................................................
22.3.2 Boolesche Eigenschaften ............................................................
22.3.3 Indizierte Eigenschaften .............................................................
Ereignisse .................................................................................................
22.4.1 Multicast und Unicast ................................................................
22.4.2 Namenskonvention ....................................................................
Weitere Eigenschaften ..............................................................................
22.5.1 Gebundene Eigenschaften ..........................................................
22.5.2 Anwendung von PropertyChange bei AWT-Komponenten .........
22.5.3 Veto-Eigenschaften – dagegen! ..................................................
1346
1346
1347
1348
1349
1349
1349
1351
1351
1351
1354
1354
1357
1357
23 Logging und Monitoring ..................................................................... 1359
23.1
23.2
23.3
23.4
23.5
23.6
23.7
Die Logging-API .......................................................................................
Überwachen von Systemzuständen ...........................................................
MBean-Typen, MBean-Server und weitere Begriffe ...................................
23.3.1 MXBeans des Systems ................................................................
Geschwätzige Programme und JConsole ...................................................
Der MBeanServer .....................................................................................
Eine eigene Standard-MBean ....................................................................
Zum Weiterlesen ......................................................................................
1359
1361
1362
1363
1365
1367
1368
1370
24 Sicherheitskonzepte ............................................................................ 1371
24.1
24.2
24.3
24.4
Zentrale Elemente der Java-Sicherheit ......................................................
24.1.1 Java Cryptography Architecture und Extension ...........................
Der Sandkasten (Sandbox) ........................................................................
Sicherheitsmanager (Security Manager) ....................................................
24.3.1 Der Sicherheitsmanager bei Applets ...........................................
24.3.2 Sicherheitsmanager aktivieren ....................................................
24.3.3 Wie nutzen die Java-Bibliotheken den Sicherheitsmanager? .......
24.3.4 Rechte durch Policy-Dateien vergeben ......................................
24.3.5 Erstellen von Rechte-Dateien mit dem grafischen Policy-Tool ....
24.3.6 Kritik an den Policies .................................................................
Signierung ................................................................................................
24.4.1 Warum signieren? ......................................................................
24.4.2 Digitale Ausweise und die Zertifizierungsstelle ...........................
24.4.3 Mit keytool Schlüssel erzeugen ..................................................
24.4.4 Signieren mit jarsigner ...............................................................
1371
1371
1372
1372
1374
1375
1376
1377
1379
1380
1381
1381
1382
1382
1383
35
Inhalt
24.5
24.6
24.7
Digitale Unterschriften ............................................................................. 1383
24.5.1 Die MDx-Reihe .......................................................................... 1384
24.5.2 Secure Hash Algorithm (SHA) ..................................................... 1384
24.5.3 Mit der Security-API einen Fingerabdruck berechnen ................. 1385
24.5.4 Die Klasse MessageDigest .......................................................... 1385
24.5.5 Unix-Crypt ................................................................................. 1387
Verschlüsseln von Daten(-strömen) .......................................................... 1387
24.6.1 Den Schlüssel bitte .................................................................... 1388
24.6.2 Verschlüsseln mit Cipher ............................................................ 1389
24.6.3 Verschlüsseln von Datenströmen ............................................... 1389
Zum Weiterlesen ...................................................................................... 1391
25 Java Native Interface (JNI) .................................................................. 1393
25.1
25.2
25.3
25.4
25.5
25.6
Java Native Interface und Invocation-API .................................................
Einbinden einer C-Funktion in ein Java-Programm ....................................
25.2.1 Schreiben des Java-Codes ..........................................................
25.2.2 Compilieren des Java-Programms ...............................................
25.2.3 Erzeugen der Header-Datei ........................................................
25.2.4 Implementierung der Methode in C ...........................................
25.2.5 Übersetzen der C-Programme und Erzeugen der dynamischen
Bibliothek ..................................................................................
25.2.6 Suchort der dynamischen Bibliothek ..........................................
Nativ die Stringlänge ermitteln .................................................................
Erweiterte JNI-Eigenschaften ....................................................................
25.4.1 Klassendefinitionen ....................................................................
25.4.2 Zugriff auf Attribute ...................................................................
Einfache Anbindung von existierenden Bibliotheken .................................
25.5.1 C++ Klassen ansprechen ............................................................
25.5.2 COM-Schnittstellen anzapfen ....................................................
Zum Weiterlesen ......................................................................................
1393
1394
1394
1395
1395
1396
1397
1399
1399
1400
1400
1401
1403
1403
1403
1403
26 Dienstprogramme für die Java-Umgebung ......................................... 1405
26.1
26.2
26.3
36
Die Werkzeuge im Überblick ....................................................................
Java-Compiler ...........................................................................................
26.2.1 Bytecode Compiler javac ............................................................
26.2.2 Native Compiler .........................................................................
26.2.3 Java-Programme in ein natives ausführbares Programm
einpacken ..................................................................................
Der Java-Interpreter java ..........................................................................
26.3.1 Der Unterschied zwischen java.exe und javaw.exe .....................
1405
1405
1405
1406
1407
1407
1408
Inhalt
26.4
26.5
26.6
26.7
26.8
26.9
Das Archivformat Jar ................................................................................
26.4.1 Das Dienstprogramm Jar benutzen .............................................
26.4.2 Das Manifest .............................................................................
26.4.3 Applikationen in Jar-Archiven starten ........................................
26.4.4 Applets in Jar-Archiven ..............................................................
Monitoringprogramme .............................................................................
26.5.1 jps .............................................................................................
26.5.2 jstat ...........................................................................................
26.5.3 jmap ..........................................................................................
26.5.4 jstack .........................................................................................
Ant ...........................................................................................................
26.6.1 Bezug und Installation von Ant ..................................................
26.6.2 Properties ..................................................................................
26.6.3 Externe und vordefinierte Properties ..........................................
26.6.4 Weitere Ant-Tasks .....................................................................
Decompiler und Obfuscatoren ..................................................................
26.7.1 Der Decompiler Jad ...................................................................
26.7.2 Das Decompilieren erschweren ..................................................
26.7.3 Das Obfuscator-Programm ProGuard .........................................
Sourcecode Beautifier ...............................................................................
Zum Weiterlesen ......................................................................................
1409
1409
1412
1412
1413
1414
1414
1414
1414
1415
1416
1416
1418
1419
1420
1420
1421
1423
1425
1425
1426
Anhang ....................................................................................................... 1427
A
Die Begleit-DVD .................................................................................................. 1427
Index ........................................................................................................................... 1429
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 kennen lernen, 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
83
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).
Grundsätzlich könnte Java-Quellcode in der Landessprache programmiert werden. Deutsche
Umlaute stellen für den Compiler ebenso wenig ein Hindernis dar wie griechische Symbole.
Allerdings ist es fragwürdig, ob ein solches Unicode-Programm sinnvoll ist, denn Editoren2
haben mit Unicode-Zeichen ihre Schwierigkeiten – genauso wie Dateisysteme.
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
Kaum ein Editor dürfte in der Lage sein, alle Unicode-Zeichen anzuzeigen. Beliebige UnicodeZeichen lassen sich für den Compiler über Unicode Escapes mit \uxxxx schreiben, wobei x
eine hexadezimale Ziffer ist – also 0...1, 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.
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. Unicode-Zeichen für deutsche Sonderzeichen sind
folgende:
Zeichen
Unicode
Ä, ä
\u00c4, \u00e4
Ö, ö
\u00d6, \u00f6
Ü, ü
\u00dc, \u00fc
ß
\u00df
Tabelle 2.1
Deutsche Sonderzeichen in Unicode
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 zum
2 Ein Unicode-Editor unter Windows ist SC UniPad unter http://www.unipad.org/main/.
84
Elemente der Programmiersprache Java
Beispiel 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.
85
2.1
2
Sprachbeschreibung
2.1.2
Literale
Ein Literal ist ein konstanter Ausdruck. Es gibt verschiedenen 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 – auch Identifizierer (von engl. identifier) genannt – vergeben, die die entsprechenden
Bausteine anschließend im Programm identifizieren. Unter Variablen sind dann Daten verfügbar, Methoden sind die Prozeduren 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 Cund 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 gesetzt.
class Main
{
public static void main( String[] args )
{
System.out.println( "Hallo Welt" );
}
}
Dass String 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, aber es ist
immer noch ein Klassentyp.
Jeder Java-Bezeichner ist eine Folge aus Java-Buchstaben und Java-Ziffern4, 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
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
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.
86
Elemente der Programmiersprache Java
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
kulliReimtSichAufUlli
class
IchWeißIchMussAndréAnrufen
hose gewaschen
RAPHAEL_IST_LIEB
hurtig!
€€€€$$$$€€€€
null
Tabelle 2.2
Beispiele für Bezeichner in Java
mami ist ein Bezeichner, der nur aus Alphazeichen besteht und daher korrekt ist. Auch kulliReimtSichAufUlli ist korrekt. Der Bezeichner zeigt zusätzlich die in Java übliche Bezeichner-
bildung; 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/
second_edition/html/lexical.doc.htmlges.
87
2.1
Index
- Subtraktions-Operator 115
#ifdef 59
#IMPLIED 809
#REQUIRED 808
$, innere Klasse 400, 405
%, Modulo-Operator 116
&&, logischer Operator 121
&amp 806
&apos 806
&gt 806
&lt 806
&quot 806
* Multiplikations-Operator 115
+ Additions-Operator 115
.class 1303
.java.policy 1378
.keystore 1382
.NET Remoting 1213
/ Divisions-Operator 115
// Zeilenkommentar 91
/dev/lp 1089
= Zuweisungsoperator 114
== 190
@author 428
@category 428
@exception 428
@link 428
@Override 354
@return 428
@see 428
@throws 428
@version 428
^ logischer Operator 121
|| logischer Operator 121
100% Java-Kompatibel 73
1099, Port rmiregistry 1220
200, OK 1134
404, Not Found 1134
500, Internal Server Error 1134
80, Http-Port 1130
8080, Http-Port 1130
A
Abhängigkeiten von Klassen 342
abort 880
abrunden 282
absolute Koordinaten des Cursors
893
Absolutwert 171
Abstract Syntax Notation One
1382
Abstract Window Toolkit 855
abstract, Schlüsselwort 368
AbstractBorder 898
AbstractButton 882
AbstractCollection 688
AbstractList 639, 688
AbstractMap 688
AbstractSequentialList 688
AbstractSet 688
AbstractTableModel 971
abstrakte Klassen 367
abstrakte Methode 368
Accelerator 937
Accepted 1134
Access Controller 1371
Accessibility 856
AccessibleObject 1314, 1328
ACTION_FIRST 882
ACTION_LAST 882
ACTION_PERFORMED 882
ActionEvent.
ACTION_PERFORMED 869
ActionListener 880
Activatable 1227
Activated Intelligence 1074
Activation Daemon 1227
activation.jar 1147
ActiveX 1346
Adapter 649
Adapter, MBean 1362
Adapterklasse 875
Adapterklassen 875
Addition 115
Adjazenzmatrizen 203
AdjustmentEvent 920
AdjustmentListener 923
Adobe Photoshop 1074
Advanced Research Projects
Agency 1116
AFC 856
affine Transformation 1082
Age, Response-Header 1135
Ahead-Of-Time Compiler 1406
AIFF 1247
aJ-100 56
Aktor 179
aktueller Parameter 150
Alignment 906
allgemeine Semaphore 574
Allow, Entity Header 1135
allowSystemProperty 1378
AllPermission 1379
Almaden 1295
AlphaComposite, Klasse 1054
AlreadyBoundException 1221
ALT_MASK 882
AM_PM 613
Amigos 178
Anführungszeichen 108
angehäufte if-Anweisungen 130
angepasster Exponent 275
Anhängen an Strings 231
Anhängen von Zeichen 240
Animierte Cursor 1013
Anmelde-/Versendesystem 1233
Annotationen 510
annotiert 1301
anonyme innere Klassen 404
Anpassung 1348
Antialiasing 1027, 1081
Anweisung 90
Anweisungssequenz 97
Anwendungsfall 179
ANY 808
Anzahl der Parameter 213
Anzahl Einträge 1299
Aoint, Klasse 177
Apache Axis 1229
Apache Commons Logging 1370
Apache Jakarta HttpClient 1128
APF 1074
Apple, Look-And-Feel 996
Applet 55, 62, 1235
AppletContext 1061, 1239, 1244,
1247
appletviewer 1405
Application Foundation Class 856
Applikations-Klassenlader 489
APRIL 610
1429
Index
Ära 621
Arc2D 1041
Arcus-Funktionen 281
Area, Klasse 1042
Argument der Funktion 150
Argumentübergabe 304
ArithmeticException 290
arithmetische Typen 98
arithmetischer Operator 115
ARPA 1116
Array 193
Array mit variabler Länge 645
Array-Grenze 59
ArrayList 634, 638
ArrayStoreException 650
Array-Typen 98
Array-Variablendeklaration 193
Artefakte 1072
Aschermittwoch 611
ASCII-Zeichen 83
ASN.1 1382
assert, Schlüsselwort 457
Assertion 457
assignment 114
Assoziation, Objektbeziehung
341
assoziativer Speicher 633
Astronomie 595
Atlantic City 62
atomar 545
atomare Komponente 864
Atomuhr 596
Attribute 177, 804
Attributinhalte 841
aufgeschobene Initialisierung
159
Aufruf einer Funktion 148
Aufrunden 282
Ausdruck 114
Ausdrucksanweisung 93
Ausführungsstrang 515
Ausgabeformatierung 596
Ausnahme 58
Ausnahmenbehandlung 58
Ausprägung 177
Ausprägungsvariable 181
Ausrichtung 906
ausschließendes Oder 122
äußere Schleife 140
Auszeichnungssprachen 803
authentication required 1101
1430
Authentifizierung 1381
Autoboxing 470
Automatische Typanpassung 109,
349
Autorisierung 1381
awk 248
AWT 855
AWTEvent 868
AWTEventMulticaster 1353
AWT-Event-Thread 875, 1005
AWT-Input 543
AWT-Motif 543
AWT-Thread 1005
B
Bad Gateway 1134
Bad Request 1134
barrier 539
Base64 265
Base64 Encoding 1146
baseline 1032
Basic Multilingual Plane 84
Beautifier 1425
bedingte Compilierung 59
Bedingungsoperator 124, 171
Behinderungen, Accessibility 856
Beispielprogramme der Insel 48
Benutzerdefinierter Klassenlader
490
Benutzerinteraktionen 1014
Beobachter-Pattern 497
Berkeley Software Distribution
1116
Berkeley-Socket Interface 1116
Betrag 286
Betriebssystemarchitektur 1375
Betriebssystemname 1375
Betriebssystemversion 1375
BevelBorder 898
Bezeichner 86
Bézier-Kurve 1042
Bias 275
biased exponent 275
BigDecimal 290
Big-Endian 291
BigInteger 290
Bilder skalieren 1069
Bildlaufleiste 918
Bildschirmabzug 1016
binäre Semaphore 574
binäre Suche (binary search) 683
binärer Operator 113
Binary and Floating-Point
Arithmetic 275
Binnenmajuskel 87
bin-Pfad 69
biometrisches System 1381
Birrel 1211
Bitmenge 689
BitSet 689
Bitttage 611
bitweise Manipulation 689
bitweises Exklusives Oder 165
bitweises Komplement 123
bitweises Oder 124, 165
bitweises Und 124, 165
bitweises Xor 124
BLOB 1290
Block 97
BMP 1074
Body 1233
Booch 178
boolean, Datentyp 99, 473
Bootstrap-Klassenlader 489
Border 898
BorderLayout 908
BOTH 914
Botschaft 303
Bound-Properties 1348
Boxing 471
BoxLayout 917
break 142
Brightness 1051
Browne, Dik 433
Browser-Version 478
Bruchzahlen 275
BSD, Berkeley Software
Distribution 1116
BufferedInputStream 724
BufferedReader 724
ButtonGroup 928
Byte 98
byte 104, 106
byte, Datentyp 99
Bytecode 55, 93
Bytecode Verifier 1371
C
C 53
C++ 53, 176
Index
Cache 1077
Cache-Control 1135
CAG (Constructive Area
Geometry) 1043
call by reference 190
call by value 150, 304
Call-Level-Interface (CLI) 1258
CANON_EQ 250
Canvas 1058
CAP_BUTT 1056
CAP_ROUND 1056, 1058
CAP_SQUARE 1056
Caret 959
CASE_INSENSITIVE 250
Cast 123
Cast, casten 109
catch 433
CDATA 808
CDC (Connected Device
Configuration) 1250
CENTER 906
Central European Time 603
CERN 1129
Certificate Authority, CA 1382
CET 603
char 108
char, Datentyp 99
CharSequence 381
Checkbox 924
checked exception 448
class 1311
class literal 386
Class Loader 487
Class.forName() 1303
Class-Loader 57
ClassLoader 1372
ClassNotFoundException 1304
Class-Objekt 1302
CLASSPATH 1407
Class-Path Wildcard 1408
CLI (Call-Level-Interface) 1258
Client 1117, 1213
Client/Server-Kommunikation
1122
Clip-Bereich 1022
Clipboard 937, 998
Clipper 1385
clipping 1055
Clipping-Bereich 1078
Clipping-Operation 1078
CLOB 1290
clone() 392
CloneNotSupportedException
393
Cloudscape 1254
cmd.exe 502
Coad/Yourdon 178
code point 83
Collator 244
Collection API 627
Collection, Schnittstelle 628
COM, Component Object Model
1346
com4j 1403
Command Model 871
Command not found 69
command.com 502
Compiler 93
Component Object Model 1346
ComponentEvent 870
ComponentListener 894
Components 889
ComponentUI 947
Componentware 1346
Composite, Schnittstelle 1054
CompoundBorder 898
Connected Limited Device
Configuration (CDC) 1249
Connection 1135
Connector/J 1255
Connector-Level 1362
const, Schlüsselwort 159–160
const-korrekt 160
Constraint 912
Constraint-Properties 1348
Contact Port 1117
Container 627
Content 1102
Content Handler 1104
Content-Base 1135
Content-Encoding 1135–1136
Content-Handler 1102
Content-Language 1135
Content-Length 1135
Content-Location 1135
Content-MD5 1135
Content-Pane 866
Content-Range 1135
Content-Type 1135
continue 142–143
Control-Center 72
Controller 946
CORBA 1226, 1346
CORBA (Common Object Request
Broker Architecture) 1213
Cosinus 281
Cosmo 163
Cp037 263
Cp850 263
Created 1134
Crimson 815
CSV (Comma Separated Values)
801
CTRL_MASK 882
CubicCurve2D 1041
CUR 1074
currency, Datentyp 108
Cursor 1012
custom tag library 1189
Customization 1348
CVM 1250
cxxwrap 1403
CyberNeko 853
D
dangling pointer 337
Dangling-Else Problem 128
dash attribute 1055
Data Hiding 309
Data Query Language 1297
Database Management Systems
1253
Datagramme 1139
Datagrammsockets 1137
DatagramSocket 1139
DataInput 1310
DataOutput 1310
DataSource 1270
DataTruncation 1280
DATE 613
Date, General Header Fields 1135
DateFormat 617, 623
Dateiauswahl-Dialog 991
Dateinamenendungen 229
Dateitrenner 1375
Datenbankausprägung 1253
Datenbankschema 1253
Datenbankverbindung 1268
Datenbasis 1253
Datenkompression 765
Datenstrukturen 627
Datentyp 97
1431
Index
Datumswerte 596
DAY_OF_MONTH 613
DAY_OF_WEEK 613
DAY_OF_WEEK_IN_MONTH
613
DAY_OF_YEAR 613
DB2 Express-C 1255
DB2 Universal Database Express
1255
DBMS 1253
DCOM 1346
Deadlock 516, 561
DECEMBER 610
DecimalFormat 271
Decompiler 1420
Decrement 123
default 132
DEFAULT_LAYER 984
Default-Konstruktor 184
Default-Paket 217
DefaultTableCellRenderer 976
DefaultTableModel 974
Dekonstuktor 397
Dekoration 864
delegate 73
Delegation Model 871
DELETE 1131
delete() 58
Delimiter 252, 259
Deployment-Descriptor 1160
deprecated 1406
Derby 1254
dereferenced-Meldungen 1222
Dereferenzierung 125
DES (Data Encryption Standard)
1387
Design-Pattern 497
Dezimalpunkt 275
DGC 1222
Dialog 986–987
Dialoge 987
Digitale Unterschriften 1383
DirectX 73
Distributed COM 1346
Distributed Component Object
Model (DCOM) 1213
distributed GC 1222
Divider 900
Division 115
Divisionsoperator 115
-Djava.security.manager 1375
1432
-Djava.security.policy 1378
dll-Dateien 1397
DnD, Drag & Drop 1002
DNS 1093, 1243
do/while-Schleife 136
Doc Comment 425
Doclet 1302
Doclets 428
DOCTYPE 809
Document 831
Document Object Model 814
Document Type Definition 807
DocumentBuilderFactory 816
Dokumentationskommentar 425
DOM 814
DOM Level 3 XPath 845
Domain Name Service 1093
Domain Name System 1139
Domain-Name-Server 1243
Doppel-Pufferung, Swing 901
DOS-Programme 502
DOTALL 250
double, Datentyp 99, 275
Double-Buffering 1067
Double-Buffering, Swing 901
DQL 1297
Drag and Drop 856, 1002
DriverInfo 1269
DriverManager 1267, 1270
Drucken 1084
DSN 1139
DST_OFFSET 613
DTD 807
Durchschnittswerte 1299
dynamic invocation 1329
dynamic linked libraries 1397
Dynamic MBeans 1362
Dynamische Datenstrukturen
627
Dynamische Methodenaufrufe
1330
Dynamisches Binden 362
Dynamisches Layout 864
E
EBCDIC-Zeichensatz 263
Echozeichen 960
Eclipse 71
Eclipse Translation Packs 73
ECML 1169
Editor-Kit 964
Eiche 54
EIFFEL 1421
Eigenschaft 1347
einfache Eigenschaft 1348
einfache Hochkommata 108
Einfachvererbung 343
Eingabezeile 958
eingeschränkte Eigenschaft 1348
Einschränkung 912
Einstelliger Operator 113
Electronic Commerce Modeling
Language 1169
Element 834
Element suchen 683–684
Element, XML 804
elementare Anweisung 96
Elementklasse 400
Ellipse, UML 179
Ellipse2D 1041
else 128
Elternklasse 343
Embedded Java 65
emotionale Bindung 880
EmptyBorder 898
enable assertions 458
encodings 263
end caps 1056
Ende der Welt 163
Endlosschleife 134
Endorsed-Verzeichnis 489
endorsed-Verzeichnis 494
Enterprise Edition 65
Entfernte Methoden 1211
entfernte Methodenaufrufe 1211
Entfernte Objekte 1217
Entitäten 806
Entity 1135
Entity-Body 1135
Entity-Header 1133, 1135
Entwurfsmuster 497
enum 323
Enum, Klasse 419
Enumerator 634
EoD (Ease of Development) 51
equals() 191–192, 388–389, 1098
ERA 613
Erdzeitalter 164
Ereignisauslöser 871
Ereignisschlange 1005
Ereignisse 1348
Index
Ergebnistyp 146
Erkennungsstring 884
erreichbar, catch 443
erreichbarer Quellcode 152
Error 443
Erweiterungs-Klassenlader 489
Erzeuger/Verbraucher 567
Escape-Sequenz 108
Escape-Zeichen 227
Escher, Maurits 173
ETag 1135
EtchedBorder 898
Eulersche Zahl 281
Euro-Zeichen 85
Event Queue 1005
Event-Dispatching-Thread 875
EventListener 1352
Eventquellen 871
EventQueue 1009
Events 1348
Event-Source 871
Exadel Studio 1208
Excelsior JET 1406
Exception 58, 443
Exemplar 177
Exemplarinitialisierer 335
Exemplarinitialisierungsblöcke
406
Exemplarvariable 181
Exemplar-Variablen 313
exit() 214
exklusives Oder 122
Expires 1135
explizite Typanpassung 109, 349
explizites Klassenladen 488
Explorer 63
Exponenten 275
Exponentialwert 284
expression 114
extend 343
eXtensible Markup Language 804
F
Fabrik 497
Facelets 1208
Factory 497
Faden 515
Fakultäten 294
Fall-Through 132
false 99
Farbauswahl 989
Farben 1048
Farbmodell 1051
Farbsättigung 1051
FEBRUARY 610
Fee, die gute 160
Fehler 444
Fehlercode 433
fehlerfreie Software 56
Feld 193
Feld-Typen 98
fencepost error 138
Fenster 859
Fenstermenüs 932
Field 1313–1314
FIFO-Prinzip 633
file.separator 1375
FileNotFoundException 434, 445
FilePermission 1379
fillInStackTrace(),Throwable 452
final 158, 319, 356, 1311
finale Klassen 356
finale Werte 334
finalize() 397
finally 440
Fingerabdruck 1383
Firewall 1226
First Person, Inc. 54
First-In-First-Out 633
Fitt’s Law 905
Five-Nine System 1380
flache Kopie 675
flache Kopie, clone() 394
Flaubert, Gustave 1405
Fließkommazahl 97, 107
Fließkommazahlen 275
Fließpunktzahlen 275
float 275
float, Datentyp 99
FlowLayout 906
Fluchtsymbole 108
FocusEvent 870
Fokus 893
Font 866
FontFormatException 1036
FontMetrics 1036
Forbidden 1134
formale Typ-Parameter 413
formaler Parameter 150, 304
Formatierungsanweisungen 618
Formatierungsstrings 621–622
Format-Objekte 266
Format-Spezifizierer 266
Format-String 266
for-Schleife 137
Forte 71
Fortschaltausdruck 138
Fortschrittsbalken 930
Fragezeichenoperator 113
Frame 859
FrameMaker 49
free() 58
Freiraum 906
Fronleichnam 611
FULL 619
Füllfaktor 676
Füllmuster 1057
Funktion 92, 148
Funktionsaufruf 93
Funktionszeiger 410
G
Ganzzahl 97
ganzzahliger Datentyp 104
gap 906
Garbage-Collector 58, 184, 325,
337
Gauß-Normalverteilung 290
GC 58, 325, 337
gebundene Eigenschaft 1348
Geburtsdatum 615
Geburtstagsparadoxon 1384
gegenseitigen Ausschluss 545
Geltungsbereich 102
General Header Fields 1135
General-Header 1133
Generic Connection Framework
1250
Generic Listener 878
Generics 413
generischer Typ 413
genkey 1382
geordnete Liste 632
Georg Shar 459
geprüfte Ausnahme 448
GERMAN 598
GERMANY 598
geschachtelte Alternative 130
geschachtelte Ausnahme 453
geschachtelte Top-Level Klassen
399
1433
Index
GET 1131
getContextClassLoader() 494
GET-Methode 1109, 1130
getResourceAsStream() 496
GetStringUTFChars 1399
getunnelt 1226
getXXX() 1326
ggT 290
GIF 1059
Gleichheit 191
Gleitkommazahlen 275
globale Variable 102
GMST 595
GNU Zip Packverfahren 1136
Goldsäule 163
Gosling, James 53
goto 144
Grady Booch 178
Grammatik 83
grant-Anweisungen 1377
Granularität von Threads 542
Graphics Interchange Format
1059
Green-OS 54
Green-Projekt 54
Green-Team 54
Greenwich Mean Siderial Time
595
GregorianCalendar 607
Gregorianischer Kalender 607–
608
grep 248
GridBagConstraints 912
GridBagLayout 912
GridLayout 910
Groß-/Kleinschreibung 87, 229,
232
Größenveränderung 895
größter gemeinsamer Teiler 290
GroupLayout, Klasse 904
Grundlinie 1032
Grundton 1051
Gruppenfunktionen 1299
guard 569
guarded action 569
guarded wait 569
GUI-Builder 1301
gültig, XML 807
Gültigkeitsbereich 102
gzip 1136
1434
H
I
Hägar 433
Halbierungssuche 683
Hashcode 395, 675
Hash-Funktion 395
Hashfunktion 675
HashMap 634, 668
Hash-Tabelle 668
Hashtable 668
Hash-Verfahren 1383
Hash-Wert 395
Haupt-Klasse 91
HEAD 1131
Header 1233
Header-Datei 59, 1395
HEAD-Methode 1130
Helligkeit 1051
Hemingway, Ernest 1393
hexadezimale Zahlen 105
Hexadezimalform 104
Hibernate 1300
HierarchyEvent 870
Hilfsklasse 339
Hoare 548
Horcher 871
HORIZONTAL 914, 921
Host 1093
Host-Adresse 1111
Host-Name 1093
HotJava 54
HotSpot 337
HOUR 613
HOUR_OF_DAY 613
HSB 1051
HTML 803, 1129
HTTP 1094, 1129
HTTP 0.9 1133
HTTP 1.0 1130
http.proxyHost 1101
http.proxyPort 1101
HttpClient 1128
https.ProxyHost 1101
https.ProxyPort 1101
Hue 1051
Hyperbolicus Funktionen 282
Hypertext Transfer Protocol
1094, 1129
IBM 1211, 1301
ICMP 1151
ICO 1060, 1074
Icon 866, 887
Identifizierer 86
Identität 191, 388
IEEE 754 117, 275
IETF 1093–1094
if-Anweisung 126
IFC 856
if-Kaskade 130
ignorierte Statusrückgabewerte
435
IIOP 1226
IllegalArgumentException 450
IllegalThreadStateException 519
Image 866, 1059
ImageIcon 885, 887
ImageIO 1059
Imagination 53
immutable 224
imperative Programmiersprache
90
implizites Klassenladen 488
import 185, 216
Increment 123
Index 193, 195
Indexed-Properties 1348
indexierte Variablen 195
IndexOutOfBoundException 197
Indizes 645
indizierte Eigenschaft 1348
InetAddress 1113
infinity 276
Initialisierte Array-Objekte 199
Initialisierung 102, 332
innere Klassen 399
innere Klassen beim AWT 877
innere Schleife 140
InputMethodEvent 870
InputStreamReader 264
InstallShields 1248
InstantiationException 369
Instanz 177
Instanzinitialisierer 335
Instanzvariable 181
instrumentalisierte Objekte 1362
int 104, 106
int, Datentyp 99
Index
Integer 314
integraler Typ 98
Integritätsprüfung von
Nachrichten 1384
Interaktionsdiagramm 180
Interface 62, 367, 370
Interface/Implementation-Pair
971
Interface-Typen 98
intermediate container 901
Internal Server Error 1134
Internet Control Message Protocol
1151
Internet Engineering Task Force
1093–1094
Internet Foundation Classes 856
Internet Media-Types 1135
Internet Protocol 1094
Internet-Explorer 63
Inter-ORB Protocol 1226
Interrupt 534
InterruptedException 535, 565,
572
Intersolv 1259
Intervall 139
Introspection 1301, 1347
Invarianz 418
Invocation-API 1393
InvocationEvent 1009
invokeAndWait() 1008
invokeLater() 1008
Invoker-Servlet 1193
IOException 434, 445
IP 1094
IP-Adressen 1112
ipconfig 1152
IP-Nummer 1093
ISO Country Code 597
ISO Language Code 597
ISO-639 Code 597
ISO8859-1 83
ISO-Abkürzung 598
Ist-Eine-Art-Von-Beziehung 367
ItemListener 930
ItemListener, Schnittstelle 926
Ivar Jacobson 178
J
J++ 72–73
J/Direct 73
J2EE 65
J2ME 65
JAAS 1381
Jad 1421
Jahr 613, 621
JAI 1060
Jakarta Commons/Net 1128–
1129
Jakarta Taglibs Project 1191
JANUARY 610
jar 1405, 1409
Jar-Datei 1106
jarsigner 1383, 1405
JarURLConnection 1106
Java 54, 1405
Java 2D API 856, 1026
Java API for XML Parsing 815
Java Authentication and
Authorization Service 1381
Java Cryptography Architecture
1371
Java Cryptography Extension
(JCE) 1371
Java Database Connectivity 1258
Java DB 1254
Java Decompiler 1421
Java Document Object Model
814
Java Foundation Classes 856
Java Image Management Interface
1060
Java Look&Feel 995
Java Management Beans 1363
Java Management Extensions
1362
Java Message Service 1233
Java Native Interface 1393
Java Network Launcher Protocol
1249
Java Object Serialization 781
Java Persistence API (JPA) 1300
Java Runtime Environment 1412
Java Secure Socket Extension
1101, 1153
Java Units Specification 297
Java Versionsnummer 1375
Java Virtual Machine 55
java.awt 182
java.class.version 1375
java.net 1093
java.prof 1408
java.security 1378
java.vendor 1375
java.version 1375
Java-Beans 1301
JavaBeans 1345
JavaBeans Activation Framework
1147
JavaBeans Activation Framework
(JAF) 709
JavaBeans Persistence 781
javac 1405
JavaCompiler 1406
Java-Cryptography-API 1371
JavaDoc 424
javadoc 1405
JavaDoc-Tags 1301
javah 1395
JavaMail API 1146
JavaScript 62, 1244
Java-Security-Model 57
JavaServer Faces 1208
JavaServer Page 1157
JavaSoft 55
javax 465
javax.sound 1247
Jawin 1403
Jaxen 831, 845
JAXP 815
JAX-WS 1229
JBP, JavaBeans Persistence 781
JCA 1371
JCheckBox 882
JColorChooser 989
JComboBox 948
jdb 1405
JDBC 1258
JDBC 1.0 1260
JDBC 2.0 API 1260
JDBC 2.0 Optional Package API
1260
JDBC 2.1 core API 1260
JDBC-ODBC Bridge Treiber 1259
JDOM 814
JDOMSource 849
JEditorPane 964
Jetty 1158
JFC 856
JGoodies Looks 997
JGrid 983
Jim Rumbaugh 178
Jimi 1060
1435
Index
Jindent 1426
JIT 55
JLayeredPane 984
jlGui 1247
JList 953
JMenuItem 882
JMS 1233
JMX 1362
JNI 1393
Johnson, Samuel 1372
JOIN_BEVEL 1056
JOIN_MITER 1056
JOIN_ROUND 1056
JOptionPane 436, 987
JOS, Java Object Serialization
781
JPA, Java Persistence API 1300
JPanel 901
JPasswordField 960
JPEG 1059
JProgressBar 930, 1008
JRadioButton 928
JRE 1412
JRMP (Java Remote Method
Protocol) 1226
JScrollBar 901, 920
JScrollPane 901–902
JSmooth 1407
JSP 1157
JSR-108 297
JSSE 1101
JSTL 1189
JTabbedPane 902
JTable 969
JTextField 960
JToggleButton 882, 885
JToolBar 939
JULY 610
JUNE 610
Just-In-Time Compiler 55
JViewport 901
JWindow 987
JXPath 853
K
kanonischer Pfad 696
kaufmännische Rundung 283
Keine Polymorphie 363
Keller 664
Kerberos 1381
1436
Key 633
KEY_ALPHA_INTERPOLATION
1082
KEY_COLOR_RENDERING 1082
KEY_DITHERING 1082
KEY_FRACTIONALMETRICS
1082
KEY_INTERPOLATION 1082
KEY_RENDERING 1082
KEY_TEXT_ANTIALIASING 1082
KeyEvent 870
Keystore 1383
keytool 1382, 1405
kill 880
Kindklasse 343
Klammerpaar 148
Klasse 177
Klasseneigenschaften 314
Klassenhierarchie 344
Klasseninitialisierer 318
Klassenkonzept 62
Klassenlader 57, 487, 1372
Klassen-Literal 386
Klassenmethode 149
Klassenobjekte 386
Klassen-Typen 98
Klassenvariablen 333
Klein, Calvin 515
Klonen 392
Kodierung, Zeichen 263
Kollaborationsdiagramm 180
Kollisionen, Signaturen 1384
Kollisionsangriff 1384
Kommaoperator 140
Kommentar 91
Komplement 165
Komponenten 889, 1345
Kompressionsfunktion 1384
Kompressionsstufen 1073
Komprimierungsfaktor 1059
Konkatenation 224
konkrete Klassen 367
konstante Zeichenketten 224
Konstantenpool 224–225
konstruktive Flächengeometrie
1043
Konstruktor 184, 325
Konstruktoraufruf 180
Konstruktoren 1319
Konstruktoren in Vererbung 345
Konstruktorweiterleitung 345
Kontextmenü 941
Kontraktionsfunktion 1384
Kontrollfeldgruppe 928
Kontrollstrukturen 126
Kopf 146
Kopfdefinition 806
Kouznetsov, Pavel 1421
kovariante Rückgabewerte 356
Kovarianz bei Arrays 351
Kreiszahl 281
kritische Abschnitte 544
kryptografische Prüfsumme 1384
kubische Kurvensegmente 1042
Kupfersäule 163
Kurven 1042
Kurzschlussoperator 122
L
Label 864
Länge des Strings 226
Large Object 1290
Last-Modified 1135
Laufzeitumgebung 55
launch4j 1407
lazy activation 1227
LCDUI 1251
LD_LIBRARY_PATH 1399
Lease 1223
Lebensdauer 102
leere Anweisung 96
leerer Block 97
leerer String 235
Leer-String 236
Leerzeichen 259
Leerzeichen entfernen 233
LEFT 906
Lexikalik 83
lib/security 1378
Library of Congress 1297
LIFO 664
Lightweight-Komponente 858
line joins 1055–1056
line.separator 1375
Line2D 1041
lineare Kongruenzen 288
LineBorder 898
Linien 1027
Linienenden 1055–1056
Linien-Pattern 1055
Linienverbindungen 1056
Index
Linieverbindungen 1056
LinkedList 634, 638, 647
Linking 487
Liskov'sches Substitutionsprinzip
348
Liskov, Barbara 348
Listen 638
Listen füllen 682
Listener 871
Literal 107
Load Factor 676
LOB 1290
Location, Response-Header 1135
Lock 554
Log4j 1370
logClass 1222
Logging, RMI 1222
Login-Module 1381
logisch atomar 566
logischer Operator 121
logisches Komplement 123
logisches Und 124
logisches Xor 124
lokale Klassen 403
lokale Objekte 1217
lokaler Host 1114
lokalisierten Zahlen 258
LONG 619
long 104
long, Datentyp 99
lower bound wildcard 419
LTP1 1089
Luxor 1019
LZW-Packverfahren 1059
M
MAC 1384
MAC-Adresse 1152
magische Zahlen 320
magische Zahlenwerte 1311
Mail User Agent 1145
main() 92, 495
main()-Funktion 70
Makro 59
Management Interface 1363
Manipulation Detection Code
1384
Mantisse 275
Map 633
MARCH 610
marshalling 1214
Matcher 248
Math.random() 198
Matisse 904
Matisse4MyEclipse 904
MatteBorder 898
Mausrad 891
maven 1416
MAX_INTEGER 313
MAX_PRIORITY 541
MAX_RADIX 222
Maximalwert 1299
Maximum 171, 286
MAY 610
MBean 1362
MBean-Server 1362
McNealy, Scott 54
MD 1383
MD2 1384
MD4 1384
MD5 1384
MDC 1384
MediaTracker 1076
MEDIUM 619
Megginson, David 814
mehrdimensionales Array 201
Mehrfachvererbung 375
Mehrfachverzweigung 130
mehrzeiliger Text 958
member class 400
memory leaks 337
Menge von Objekten 633
Menübalken 932
Menüeinträge 932
Menüs 932
Merant 1259
Merant DataDirect 1255
Merge-Sort 658
Meridian 595
MESA 53
Message Authentication Code
1384
Message Integrity Check 1384
Message Queues 1233
Message Store 1145
Message Transfer Agent 1145
Message Transfer System 1145
Message, javax.mail 1147
Message-Digest 1383
META_MASK 882
Metadaten 1133, 1291
Meta-Information 1135
Meta-Objekte 1303
Meta-Programming 1301
Metazeichen 274
Methode des Aufrufes 1131
Methoden 92, 145, 1316
aufrufen 1328
überladen 156
überschreiben 352
Methodenaufrufe 304
Methodenkopf 146
Methodenrumpf 146
MEZ 603
MIC 1384
Microsoft 63, 856
Microsoft Access 1255
Microsoft Development Kit 72
Microsoft SQL Server 1255
Middleware 1215–1216
MIDI 1248
Midlet 1250
MIDP (Mobile Information Device
Profile) 1250
MILLISECOND 613
Millisekunden 613
MIME 1145
MimeMessage, javax.mail 1147
MimeMultipart, javax.mail 1148
MIME-Nachrichten 1133
MIME-Typ 1104
Min/Max-Methoden 681
MIN_PRIORITY 540
MIN_RADIX 222
MIN_VALUE 278
Minimum 171, 286
MINUTE 613
Minute 613
Mitgliedsklasse 400
mitteleuropäische Zeit 603, 605
Mnemonic 937
Mobile Information Device Profile
(MIDP) 1250
modal 987
Model MBeans 1362
Modell 946
Model-View-Controller 946
Modifizierer 96, 1311
modifiziertes UTF-8 714
Modulo 117
Monat 613
Mönch 163
1437
Index
Monitoring 1361
MONTH 613
Motif 857
mouse wheel 891
MouseEvent 870
MouseInfo 1017
Moved Permanently 1134
Moved Temporarily 1134
MS 1145
MTA 1145
MTS 1145
MUA 1145
multicast 73
Multicast, Bean 1351
Multicast-Kommunikation 1153
Multilevel continue 144
MULTILINE 250
Multiple Choices 1134
Multiplikation 115
Multipurpose Internet Mail
Extensions 1145
multitaskingfähig 515
multithreaded 516
Muster 248
MVC 946
MXBeans 1363
MyEclipse 904
MySQL 1255
N
Nachricht 303
Namensdienst 1213, 1219
Namenskonvention 1351
Namensraum 811
Naming 1221
NaN 276, 278
narrowing conversion 109
native Methode 1393
Native Protocol All-Java Driver
1260
native Threads 516
native2ascii 264
Native-API Java Driver 1259
NativeCall 1403
nativer Compiler 1406
natural ordering 652
natürliche Ordnung 652
nearest neighbor algorithm 1070
Nebeneffekte 304
N-Ecke 1030
1438
NEGATIVE_INFINITY 278
negatives Vorzeichen 113
Nelson 1211
nested exception 453
nested top-level class 399
NetBeans 71
NetPermission 1379
Netscape 62, 856
Netscape Navigator 2.0 1132
netstat 1122
Network Filesystem 1139
Network Information Services
1093
Netz-Protoll All-Java Driver 1260
new line 477
newInstance() 369
new-Operator 180, 325
NFS 1139
nicht ausführend 565
nicht geprüfte Ausnahme 448
nicht-primitives Feld 198
nicht-rechteckiges Feld 201
NIS 1093
No Content 1134
No-Arg-Konstruktor 184
NoClassDefFoundError 1304
non-static method-Fehlermeldung
149
Normalverteilung 289
Not Found 1134
Not Implemented 1134
Not Modified 1134
Not-A-Number 278
Not-a-Number 276
Notation 178
notify() 564
notifyAll() 566
NOVEMBER 610
nowarn 1406
NULL 433
NullPointerException 186–187
Null-Referenz 186
Null-String 236
Number 467
NumberFormat 469
NumberFormatException 436
numeric promotion 115
numerische Umwandlung 115
numerischer Typ 114
O
Oak 53
Oberklasse 343
Oberklassen finden 1310
Oberlänge 1038
Obfuscator 1304, 1425
Object 386
Object Linking and Embedding
1346
Object Management Group 178,
1213, 1226
Objective-C 62
ObjectStreamField, Klasse 787
Objektansatz 177
Objekte erzeugen 1321
Objektgleichheit 388
Objektidentifikation 386
objektorientiert 56
objektorientierter Ansatz 62
Objektorientierung 95
Objektvariable 181
Observer/Observable 497
Observer-Pattern 946
OCTOBER 610
OCX 1346
ODBC 1258–1259
ODBC-DatenquellenAdministrator 1256
Oder 121
off-by-one error 138
OK 1134
Oktalform 104
OLE 1346
OLE Control Extension 1346
Olson, Ken 1345
OMG (Object Management
Group) 178, 1213
OMT 178
OO-Methode 178
OOSE/Objectory 178
Open Database Connectivity
Standard 1259
Open MBeans 1363
OpenDoc 1346
Operator 114
Optionsfelder 928
Oracle 1255
OracleDriver 1265
Ordinalzahl 420
Ordinalzahl, Aufzählung 420
Index
os.arch 1375
os.name 1375
os.version 1375
Ostersonntag 611
OutputStreamWriter 264
P
Pack200 766
Packet 1093
paint() 1021
Paintbrush 1074
Paket 184, 1093
PalmOS 1249
PalmPilot 65
Palmsonntag 611
Parallelport 1089
Parameter 150
Parameterliste 146, 148
Parameterübergabe 304, 1215
Parameterübergabemechanismus
150
parametrisierter Typ 413
Parsed Character Data 808
Passionssonntag 611
PATH 69
path.separator 1375
Patrick Naughton 54
Pattern 248
Payne, Jonathan 54
PCDATA 808
PCX 1074
PDA 65
PDAP 1252
Peer-Elemente 1006
Peer-Klassen 857
Perl 248
Permissions 1379
Persistenz 1348
Personal Digital Assistant Profile
1252
Personal Java 65
Pfade 1043
Pfadtrenner 1375
Pfingstsonntag 611
PI 313
PicoJava 56
PICT 1074
Picture Element 1025
pissing on at every opportunity
73
Pixel 1025
Pluggable Authentication Module
(PAM) 1381
Pluggable Look and Feel 856
Plugins, Eclipse 80
PNG 1074
PocketPC 1250
Point 330
Pointer 57
PointerInfo 1017
Point-Objekt 180
Point-to-Point 1233
Polar-Methode 289
Policy-Datei 1377
policytool 1379, 1405
Polygone 1029
Polylines 1029
Polymorphie 362
Pommes-Bude 49
POP before send 1148
Popup-Menü 941
Porphyr 163
Port 1234 1122
Port, RMI-Namensdienst 1220
Portable Network Graphics 1074
Port-Adresse 1117
Position des Fensters 862
POSITIVE_INFINITY 278
POST 1131
Post-Dekrement 119
Post-Inkrement 119
POST-Methode 1109, 1130
Potenz 284
Prä-Dekrement 119
Präfix 229
Präfix/Postfix 119
Pragma 1135
Prä-Inkrement 119
Preferences 483
Preimage-Angriffe 1384
primitiver Type 98
primitiver/einfacherDatentyp 56
Primzahlen 692
Principal 1381
print() 157
printf() 95
PrintJob 1085
println(), print() 94
Priorität 540
Prioritätswarteschlange 541
private 307, 309, 1311
Privatsphäre 307
PRN 1089
Process 504
Profil, J2ME 1250
Profiler 482
Profiling 480
Profiling-Informationen 1408
Programm 91
Programmicon 1065
Programmieren gegen
Schnittstellen 375
ProGuard 1425
Prolog 91
Properties 677, 1233, 1347
PropertyChangeEvent 1358
PropertyPermission 1379
Property-Sheet 1347
Proposed Standard 1094
protected 309, 347, 1311
Protocol Handler 1104
Protocols 62
Protokoll 1094
Protokoll-Handler 1104
Proxy-Authenticate, ResponseHeader 1135
Proxys 1211
Proxy-Server 1101
Prozess 515
PSD 1074
Pseudoprimzahl-Tests 290
PTP 1233
public 1311
Public, Response-Header 1135
Publish-Subscribe 1233
Pulldown-Menüs 932
Punkt 181, 1025
PUT 1131
Q
qNaNs 278
QuadCurve2D 1041
quadratische Kurvensegmente
1042
Quadratwurzel 284
QuantumDB 1257
Quartz 591
Quasiparallelität 515
Quellcodeverschönerer 1425
Query-String 1109
Queue 666
1439
Index
Quicksort 658
Quite NaN 278
Quoted Printing Encoding 1146
R
race condition 548
race hazard 548
Rahmen 898
Random 288
RandomAccessFile 434, 1310
Rang eines Operators 123
Range-Checking 59
Rat 627
Raw-Type 416
readLine() 434
Rechenungenauigkeit 135
Record Management System
1251
Rectangle2D 1041
RectangularShape 1041
reentrant 559
Reference Concrete Syntax 805
referenced 1222
Referenz 57
Referenzierung 125
Referenztyp 98, 114
Referenztyp, Vergleich mit ==
190
Referenz-Variable 180
Reflection 1301
ReflectPermission 1379
regedit 505
Registry 483, 1213, 1219
REGISTRY_PORT 1225
Registry-Editor 505
reguläre Ausdrücke 248
Reihung 193
Rekursionsform 161
rekursive Funktion 160
relationale Datenbanksysteme
1258
Relationaler Operator 120
RELATIVE 913
REMAINDER 913
Remainder Operator 116
Remote 1217
Remote Manager 1362
Remote Object Activation 1227
Remote Procedure Call 1213
RENDER_DEFAULT 1082
1440
RENDER_QUALITY 1082
RENDER_SPEED 1082
Rendering-Algorithmus 1081
Renderpack Pipelines 983
Rendezvous 537, 540
repaint() 1024
Request 1131
Request For Comment 1094
Request Header 1133
reservierte Schlüsselwörter 87
Response-Header 1133, 1135
Rest der Division 285
Restwert-Operator 115–116
Resultat 114
Re-throwing 452
Retry-After, Response-Header
1135
return 151
Reverse- und RoundtripEngineering 72
Rezeptoren 1048
RFC 1094
RFC 1521 265
RFC 2616 1129
RFC 792 1151
RGB 1051
Rhino 507
Rich Text Format 964
RIGHT 906
Ritchie, Dennis M. 67
RMI 1213
RMI Wire Protocol 1214
RMIClassLoader 1224
rmid 1227
RMI-Klassenlader 1224
RMI-Logging 1222
RMI-Transportschicht 1214
Robot 1016
Rollbalken 918
Rollenbasierte Rechtevergabe
1380
Rollrads 891
Rotation 1082
RoundRectangle2D 1041
Router 1093
Routinginformationen 1233
RPC 1213
RTF 50, 964
Rückgabetyp 146
Rückgabewert 148
Rumpf 146
Runden 282
Rundungsfehler 117
Runnable 518
Runtime 501
Runtime Packages 1371
RuntimeException 447–448
Run-Time-Interpreter 55
RuntimePermission 1379
r-Wert 114
S
San Jose 1295
Sandbox 1372
Saturation 1051
SAX 814
SAXBuilder 832
SCALE_AREA_AVERAGING
1069
SCALE_DEFAULT 1069
SCALE_FAST 1069
SCALE_REPLICATE 1069
SCALE_SMOOTH 1069
Schablonen-Muster 727
Schaltjahr 153, 596
Scheduler 515, 544
Schema 809
Schieberegler 918
Schlange 633
Schleifen 133
Schleifenbedingung 134, 136
Schleifen-Inkrement 138
Schleifentest 137
Schleifenzähler 138
Schlüssel 633
Schlüsselpaare 1382
Schlüsselspeicher 1383
Schlüsselwörter 87
Schnittstelle 62, 370
Schnittstellen implementieren
1310
Schnittstellen-Typen 98
Schriftlinie 1032
Schurken 595
Scope 102
Screen_Updater 543
Screenshots 1016
Scriptlets 1163
Scrollbar 918
Scrolling-Liste 954
SECOND 613
Index
Secure Hash Algorithm 1384
Secure Hash Standard 1384
Secure Sockets Layer 1153
SecurityManager 57, 1235, 1372
SecurityPermission 1379
sed 248
Seed 288–289
Seiteneffekte 304
Sekunden 613
Selbstbeobachtung 1347
selektiertes Element 953
Selektor 181
Sellers, Peter 252
Semantik 83
Separator 89
SEPTEMBER 610
SEQUEL 1295
Sequencer 1248
Sequenz 632
Sequenzdiagramm 180
SerializablePermission 1379
serialPersistentFields 787
Server 1117, 1213
Server, Response-Header 1135
Service Unavailable 1134
Service-Provider Implementation
465
Session, javax.mail 1147
setDoInput(), URLConnection
1104
setDoOutput(), URLConnection
1104
setSize() 862
Set-Top-Boxen 54
setXXX() 1326
SGML 803
SHA 1384
Shallow Copy 675
Shape 1080
shared objects 1397
Sheridan, Mike 54
Shift 123
SHIFT_MASK 882
Shift-Operator 167
Shlaer/Mellor 178
SHORT 619
short, Datentyp 99, 104, 106
Short-Circuit-Operator 122
SHS 1384
Sicherheitsmanager 1372, 1376
Sichtbarkeit 102, 307, 347
signaling NaN 278
Signierung 1381
Simple API for XML Parsing 814
SimpleDateFormat 617, 624
SimpleTimeZone 605
SIMULA 62
Simula-67 175
Single Inheritance 343
Sinus 281
sizeof 125
Skalierung 1082
Skipjack 1385
Skript-Engine 507
slider, Schieberegler 918
Slivka, Ben 73
Smalltalk 56, 175
Smart-Card 1381
SMB (Server Message Block) 710
Smiley 85
SMTP-Server 1146
sNaN 278
SOAP 1228
SOCK_DGRAM 1152
SOCK_STREAM 1152
SocketPermission 1379
Sockets 1116
SOCKS 1101
SoftBevelBorder 898
Solo 72
Sommer-/Winterzeit 603
Sommerzeit 605
Sommerzeitabweichung 613
SortedMap 633
SortedSet 633
sortieren 657
Soundbank 1247
Source-Code Beautifier 1425
SPI-Pakete 465
Splash-Screen 1065
Sprungmarken 144
SQL 1295
SQL 2 1296
SQL-Call-Level-Interface 1258
SQLException 1269, 1280
SQLWarning 1280
SQuirreL 1257
SSL 1153
SSLSocket 1153
SSLSocketFactory 1153
stabil sortieren 657
Stack 664
Stack-Inhalt 455
StackOverflowError 645
Standard Extension API 465
Standard Generalized Markup
Language 803
Standard MBeans 1362
Standard Tag Library 1189
Standard Widget Toolkit 1019
Standardberechtigungen 1378
Standard-Konstruktor 184, 327
Stapelspeicher 664
Star Seven 54
StarOffice 59
statements 90
static 96
static final 371
static, Schlüsselwort 149
Statische Blöcke 318
statische Eigenschaften 314
statische Methode 149
Statuscode 1133
Statuszeile 1133
Stellvertreterobjekte 1211, 1219
Sternzeit 595
stilles NaN 278
Store-and-Forward 1145
streng-typisiert 97
strictfp 287
StrictMath 287
String 94, 194, 222, 224
StringBuffer 224
Stringkonkatenation 123
String-Literalen 224
Stringobjekte 338
StringReader 725
Stringteile extrahieren 229
Stringteile vergleichen 229
StringTokenizer 258
Stroustrup, Bjarne 176
Structured English Query
Language 1295
Struts 1208
Stumpy 176
Subinterface 378
Subject 1381
Subklasse 343
Submenu 932
Subprotokoll 1267
Substitutionsprinzip 348
Subtraktion 115
Suffixe 229
1441
Index
Summe aller Einträge 1299
Sunraster 1074
SunWorld 54
super 355, 359
super() 346, 359
Superklasse 343
Surrogate-Paar 84
SWIG 1403
SwingUtilities 1009
SwingWT 1019
switch-Anweisung 130
Switzerdütsch 603
Swixml 1018
SWT 1019
symbolische Konstanten 319
Symbolleisten 939
Synchronisation 398, 544
synchronized 548
SynerJ 71
Syntax 83
System.err 95
System.in 502
System.out 95
Systemeigenschaften 69, 476
Systemfarben 1051
System-Klassenlader 489
T
TableCellRenderer 975
TableLayout, Klasse 918
TableModel 970
TableModelEvent 974
TableModelListener 970
Tabulator 259
Tag 613
Tag des Jahres 613
Tag Image File Format 1074
Tage im Monat 616
Tagesdatum 615
Taglib 1189
TagLib-Deskriptoren 1190
TAI 596
Taj Mahal 62
Tangens 281
Tango Desktop Projekt 887
Targa 1074
Tastatur-Shortcut 937
Tastenkürzel 937
TCP 1139
TCP/IP 1116
1442
Tear-Off-Menü 933
Teletubbies 1111
Template-Pattern 727
terminiert 542
TextArea 958, 961
TextComponent 958
Texteingabe 957
TextField 958
Textverarbeitung 49
TGA 1074
The network is the computer
1093
this und Vererbung 407
this$0, innere Klassen 403
this() 359
this(), Beschränkungen 331
this(), Konstruktoraufruf 329
this-Referenz 305, 359
this-Referenz bei statischen 316
this-Referenz in inneren Klassen
401
Thread 518
thread local storage (TLS) 580
ThreadDeath 536
ThreadGroup 583
Threadgruppe 586
ThreadLocal 580
thread-lokale Variablen 580
Thread-Pool 524
Threads, Zustände 530
Throwable 443
throws 437
Tick Marks 918
tiefe Kopie, clone() 394
TIFF 1074
Tim Berner-Lee 1129
timeout 1214
Timer 590
TimerTask 590
TimeZone 604
Titelleiste 861
TitledBorder 898
TLS 1153
toCharArray() 194
tödliche Umarmung 561
TogetherJ 72
Togethersoft 72
Token 88, 259
Tomcat 1158
Toolkit 858
Tooltip 897
TooManyListenersException
1351
Topics 1233
Toplevel-Container 859
Top-Level-Klassen 399
Transfer-Encoding 1135
Transformationen 1055
TransparentLayout 917
Transport Layer Security 1153
Transport, javax.mail 1147
Transportschicht 1214
TreeMap 633–634, 668
Trennlinie 934
Trennzeichen 88, 252
true 99
TrueZIP 766
try 433
Tupel 1253
Türme von Hanoi 163
Typanpassung 109
Typecast 109
typenlos 186
Typsichere Konstanten 321
Typ-Variable 413
Typvergleich 123
U
Überblendung, Grafik 1054
überdecken 364
überladen 95
überladene Methode 156
überladener Operator 60
überladenes Plus 124
überschreiben 352
Übersetzer 93
überwachten Warten 569
UDP 1139
UDP-Protokoll 1138
UIManagers 995
umbenannten Paket 217
Umgebungsvariablen,
Betriebssystem 479
Umkehrfunktionen 281
UML 178
Umlaut 84
Unable to create font 1036
unärer Operator 113
unäres Minus 117
unäres Plus/Minus 123
Unauthorized 1134
Index
UncaughtExceptionHandler 533
Und 121
UNDECIMBER 610
Unendlich 276
Unicast Verbindung 1153
Unicast, Beans 1351
Unicode escapes 84
UNICODE_CASE 250
Unicode-Zeichen 83
Unified Method 178
Uniform Resource Locater 1094
Universal Time 595
Universität von Berkeley 1116
Unix-Crypt 1387
unnamed package 217
UnsupportedOperationException
688
Unterklasse 343
Unterlänge 1038
Untermenü 932
Upgrade 1135
upper bound wildcard 419
URL 1095
URLConnection 1101
URLEncoder 1111
Urzidil 627
Use-Cases-Diagramm 179
useCodebaseOnly 1225
User 1145
UTC 596
UTF-16 806
UTF-16 Kodierung 84
UTF-8 806
UTF-8 Kodierung 714
Utility-Klasse 339
uUboxing 471
uuencode 1146
V
valid, XML 807
Value 633
varargs 204
variable Argumentanzahl 204
Variablendeklaration 100
Variableninitialisierung 365
Vary, Response-Header 1135
VBX 1346
Vector 638
veränderbare Zeichenketten 239
verbindungsloses Protokoll 1138
verbindungsorientiert 1138
verbose 1406, 1408
Verbundoperator 118
Verdecken von Variablen 305
vererbte Konstanten 378
Vererbung 342
Vergleich 228
Vergleichsoperator 120–121
Vergleichsstring 229
verkettete Liste 647
Verklemmungen 516
Verlaufsbalken 930
Verschiebeoperator 167
Verschiebung 1082
VERTICAL 914, 921
Vetorecht 1348
Via 1135
Video-Übertragungen 1077
View 946
Virtual Memory Management
1060
virtuelle Maschine 55
Visual Age for Java 71
Visual Basic 1346
Visual Basic Extension 1346
VMM 1060
void 149, 214
volatile 577
VolatileImage 1077
Vorschaubild 1060
Vorzeichenerweiterung 123
Vorzeichenumkehr 117
W
Wahrheitswert 97
Wahrheitswerte 98
wait() 564
Walters, Hellmut 855
War-Archiv 1160
Warenzeichen 1093
Warning, Response-Header 1135
Warning:Applet Window 1377
Watson, Thomas 1211
WAV 1247
Web Application Security 1209
Web-Applets 55
Webbrowser 964
WebRunner 54
Webstart 1248
Wechselknopf 885
WEEK_OF_MONTH 613
WEEK_OF_YEAR 613
Weichzeichnen 1027, 1081
Well-Known System Ports 1117
Wertebereiche 310
Werte-Objekte 466
Wertoperation 113
Wertübergabe 150
Wettlaufsituation 548
while-Schleife 133
White-Space 88
widening conversion 109
Widgets 855
Wiederverwendung per CopyUnd-Paste 113
Wilde 1235
Win32-API 73
WinCE 1249
WIND_NON_ZERO 1044
Winding Rule 1044
WindowListener 872
Windows Icon-Format 1060
Windows XP 1235
Windows-NT Konsole 263
Windows-Registry 504
Windungsregel 1044
Winkelfunktionen 281
WinZip 67, 1409
wissenschaftliche Notation 107
Woche 613
Woche des Monats 613
wohlgeformt 805
WORA 63
Word 49
Worker-Thread 1011
Workspace 74
World Wide Web 54
write once, run anywhere 63
Wurzelelement 835
WWW-Authenticate, ResponseHeader 1135
X
X.509 1382
X11 857
XAML 1018
X-BitMap 1074
XBM 1074
XDoclet 1302
Xerces 815
1443
Index
Xerox PARC 946
XHTML 813
XML 804
XML User Interface Language
1018
XMLOutputter 833
Xnoclassgc 1408
XOPEN SQL-Status 1280
XOR 1022
Xor 121, 166
XPath 844, 847
XPath-Wurzel 844
X-Pixmap 1074
XPM 1074
Xprof 1408
X-Server 1091
XSLT 847
XUL 1018
Xvfb-Server 1091
X-Virtual-Framebuffer-Server
1091
1444
Y
YEAR 613
Z
Zahlenwert, Unicode-Zeichen 83
Zeichen 97, 108
Zeichen ersetzen 233
Zeichenbereich 1055
Zeichenkette 94
Zeichenkodierung 263
Zeiger 57
Zeilenendezeichen 1375
Zeilenkommentar 91
Zeilentrenner 259
Zeilenumbruch 477–478
Zeitablauf 1214
Zeitgenauigkeit 605
Zeitmessung 480
Zeitverschiebung 605
Zeitzone 596, 603–604, 621
Zeitzonenabweichung 613
Zertifizierungsstelle 1382
ZipConstants 771
ZONE_OFFSET 613
Z-Order 984
Zufallszahl 286, 291
Zufallszahlengenerator 289
Zugriffsmethode 310
Zugriffsmodifizierer 1315
zusammengesetzte Bedingung
127
Zustandsänderung 1358
Zuweisung 124
Zuweisung mit Operation 124
Zuweisung pro Zeile 115
zweidimensionales Feld 201
Zweierkomplement 106
zweistelliger Operator 113
Zwischenablage 998
zyklische Redundanzprüfung 778
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement