Java ist auch eine Insel

1371.book Seite 1 Mittwoch, 17. Dezember 2008 1:39 13
Christian Ullenboom
Java ist auch eine Insel
Programmieren mit der Java Platform, Standard Edition 6
1371.book Seite 3 Mittwoch, 17. Dezember 2008 1:39 13
Auf einen Blick
1
Java ist auch eine Sprache ....................................................................
55
2
Sprachbeschreibung .............................................................................
87
3
Klassen und Objekte ............................................................................
181
4
Der Umgang mit Zeichenketten ...........................................................
237
5
Mathematisches ...................................................................................
299
6
Eigene Klassen schreiben .....................................................................
327
7
Angewandte Objektorientierung .........................................................
429
8
Exceptions ............................................................................................
455
9
Generics, innere Klassen ......................................................................
481
10
Die Klassenbibliothek ..........................................................................
501
11
Threads und nebenläufige Programmierung ........................................
557
12
Datenstrukturen und Algorithmen .......................................................
637
13
Raum und Zeit ......................................................................................
713
14
Dateien und Datenströme ....................................................................
743
15
Die eXtensible Markup Language (XML) .............................................
855
16
Grafische Oberflächen mit Swing .........................................................
913
17
Grafikprogrammierung ......................................................................... 1075
18
Netzwerkprogrammierung ................................................................... 1145
19
Verteilte Programmierung mit RMI und Web-Services ....................... 1207
20
JavaServer Pages und Servlets ............................................................. 1231
21
Applets ................................................................................................. 1267
22
Midlets und die Java ME ...................................................................... 1283
23
Datenbankmanagement mit JDBC ....................................................... 1291
24
Reflection und Annotationen ............................................................... 1339
25
Logging und Monitoring ...................................................................... 1385
26
Sicherheitskonzepte ............................................................................. 1401
27
Java Native Interface (JNI) ................................................................... 1423
28
Dienstprogramme für die Java-Umgebung .......................................... 1435
1371.book Seite 5 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
Vorwort ......................................................................................................................
39
1
Java ist auch eine Sprache ...................................................................
55
1.1
1.2
1.3
55
55
57
57
58
59
59
60
60
61
62
62
63
64
65
66
66
66
67
68
68
68
69
69
69
71
71
72
74
74
75
75
75
76
77
77
1.4
1.5
1.6
1.7
1.8
1.9
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 benutzerdefinierten überladenen Operatoren ...................
1.3.9
Java als Sprache, Laufzeitumgebung und Bibliothek ...................
1.3.10 Wofür sich Java weniger eignet ..................................................
1.3.11 Java im Vergleich zu anderen Sprachen ......................................
1.3.12 Java ist Open Source ..................................................................
Die Rolle von Java im Web .......................................................................
1.4.1
Vollwertige Applikationen statt Applets .....................................
Java-Plattformen: Java SE, Java EE und Java ME ........................................
1.5.1
Java SE-Plattform .......................................................................
1.5.2
Java für die Kleinen ....................................................................
1.5.3
Java für die Großen ....................................................................
Installation von Suns Java Platform Standard Edition (Java SE) ..................
1.6.1
Das Java SE von Sun ..................................................................
1.6.2
Download vom JDK ...................................................................
1.6.3
Java SE unter Windows installieren ............................................
Das erste Programm compilieren und testen .............................................
1.7.1
Ein Quadratzahlen-Programm ....................................................
1.7.2
Der Compilerlauf .......................................................................
1.7.3
Die Laufzeitumgebung ...............................................................
1.7.4
Häufige Compiler- und Interpreterprobleme ..............................
Entwicklungsumgebungen im Allgemeinen ...............................................
1.8.1
Die Entwicklungsumgebung Eclipse ...........................................
1.8.2
NetBeans von Sun .....................................................................
1.8.3
Ein Wort zu Microsoft, Java und zu J++ ......................................
Eclipse im Speziellen ................................................................................
1.9.1
Eclipse starten ...........................................................................
5
1371.book Seite 6 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
1.9.2
Das erste Projekt anlegen ..........................................................
1.9.3
Eine Klasse hinzufügen ...............................................................
1.9.4
Übersetzen und Ausführen .........................................................
1.9.5
JDK statt JRE .............................................................................
1.9.6
Start eines Programms ohne Speicheraufforderung .....................
1.9.7
Projekt einfügen, Workspace für die Programme wechseln ........
1.9.8
Plugins für Eclipse ......................................................................
Zum Weiterlesen ......................................................................................
78
80
81
82
82
83
84
84
Sprachbeschreibung ............................................................................
87
1.10
2
2.1
2.2
2.3
2.4
6
Elemente der Programmiersprache Java ....................................................
2.1.1
Token ........................................................................................
2.1.2
Textkodierung durch Unicode-Zeichen .......................................
2.1.3
Literale ......................................................................................
2.1.4
Bezeichner .................................................................................
2.1.5
Reservierte Schlüsselwörter ........................................................
2.1.6
Kommentare ..............................................................................
2.1.7
Die API-Dokumentation ............................................................
Anweisungen formen Programme .............................................................
2.2.1
Anweisungen .............................................................................
2.2.2
Eine Klasse bildet den Rahmen ..................................................
2.2.3
Die Reise beginnt am main() ......................................................
2.2.4
Funktionsaufrufe als Anweisungen .............................................
2.2.5
print(), println() und printf() für Bildschirmausgaben ..................
2.2.6
Ausdrucksanweisung ..................................................................
2.2.7
Erste Idee der Objektorientierung ..............................................
2.2.8
Modifizierer ...............................................................................
2.2.9
Anweisungen und Blöcke ...........................................................
Datentypen, Typisierung, Variablen und Zuweisungen ..............................
2.3.1
Primitive Datentypen im Überblick ............................................
2.3.2
Variablendeklarationen ..............................................................
2.3.3
Zuweisungsoperator ..................................................................
2.3.4
Variablendeklaration mit Wertinitialisierung ..............................
2.3.5
Wahrheitswerte .........................................................................
2.3.6
Ganzzahlige Datentypen ............................................................
2.3.7
Die Fließkommazahlen float und double ....................................
2.3.8
Alphanumerische Zeichen ..........................................................
2.3.9
Gute Namen, schlechte Namen ..................................................
Blöcke, Initialisierung und Sichtbarkeit .....................................................
2.4.1
Blöcke und Anweisungen ...........................................................
2.4.2
Initialisierung von lokalen Variablen ..........................................
2.4.3
Sichtbarkeit und Gültigkeitsbereich ............................................
87
87
88
90
90
92
93
94
95
95
96
97
98
98
100
100
101
102
102
103
105
106
106
108
108
110
111
112
113
113
113
114
1371.book Seite 7 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
2.5
2.6
2.7
2.8
2.9
Ausdrücke, Operanden und Operatoren ...................................................
2.5.1
Arithmetische Operatoren .........................................................
2.5.2
Unäres Minus und Plus ..............................................................
2.5.3
Zuweisung mit Operation ..........................................................
2.5.4
Präfix- oder Postfix-Inkrement und -Dekrement .........................
2.5.5
Die relationalen Operatoren und die Gleichheitsoperatoren .......
2.5.6
Logische Operatoren Und, Oder, Xor, Nicht ..............................
2.5.7
Rang der Operatoren in der Auswertungsreihenfolge .................
2.5.8
Die Typanpassung (das Casting) .................................................
2.5.9
Überladenes Plus für Strings .......................................................
Bedingte Anweisungen oder Fallunterscheidungen ...................................
2.6.1
Die if-Anweisung .......................................................................
2.6.2
Die Alternative mit einer if/else-Anweisung wählen ...................
2.6.3
Die switch-Anweisung bietet die Alternative .............................
Schleifen ..................................................................................................
2.7.1
Die while-Schleife ......................................................................
2.7.2
Die do-while-Schleife ................................................................
2.7.3
Die for-Schleife ..........................................................................
2.7.4
Schleifenbedingungen und Vergleiche mit == ............................
2.7.5
Ausbruch planen mit break und Wiedereinstieg mit continue ....
2.7.6
break und continue mit Sprungmarken ......................................
Methoden einer Klasse .............................................................................
2.8.1
Bestandteil einer Funktion .........................................................
2.8.2
Signatur-Beschreibung in der Java-API .......................................
2.8.3
Aufruf einer Methode ................................................................
2.8.4
Methoden ohne Parameter deklarieren ......................................
2.8.5
Statische Methoden (Klassenmethoden) ....................................
2.8.6
Parameter, Argument und Wertübergabe ..................................
2.8.7
Methoden vorzeitig mit return beenden ....................................
2.8.8
Nicht erreichbarer Quellcode bei Funktionen .............................
2.8.9
Rückgabewerte ..........................................................................
2.8.10 Methoden überladen .................................................................
2.8.11 Vorgegebener Wert für nicht aufgeführte Argumente ................
2.8.12 Finale lokale Variablen ...............................................................
2.8.13 Rekursive Methoden ..................................................................
Weitere Operatoren .................................................................................
2.9.1
Bits und Bytes ............................................................................
2.9.2
Operationen auf Bit-Ebene ........................................................
2.9.3
Die Verschiebeoperatoren .........................................................
2.9.4
Ein Bit setzen, löschen, umdrehen und testen ............................
2.9.5
Bit-Funktionen der Integer- und Long-Klasse .............................
2.9.6
Der Bedingungsoperator ............................................................
115
116
119
120
120
122
123
124
126
132
133
133
135
137
140
141
142
143
146
148
151
152
153
153
155
155
156
157
159
159
160
163
165
165
167
169
169
170
172
174
175
176
7
1371.book Seite 8 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
2.10
2.11
3
Klassen und Objekte ........................................................................... 181
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
8
2.9.7
Operator vermisst ...................................................................... 177
Einfache Benutzereingaben ....................................................................... 178
Zum Weiterlesen ...................................................................................... 179
Objektorientierte Programmierung ...........................................................
3.1.1
Warum überhaupt OOP? ...........................................................
3.1.2
Denk ich an Java, denk ich an Wiederverwendbarkeit ................
Eigenschaften einer Klasse ........................................................................
3.2.1
Die Klasse Point .........................................................................
Die UML (Unified Modeling Language) .....................................................
3.3.1
Hintergrund und Geschichte zur UML ........................................
3.3.2
Wichtige Diagrammtypen der UML ............................................
3.3.3
UML-Werkzeuge .......................................................................
Neue Objekte erzeugen ............................................................................
3.4.1
Anlegen eines Exemplars einer Klasse mit dem new-Operator ....
3.4.2
Deklarieren von Referenzvariablen .............................................
3.4.3
Zugriff auf Variablen und Methoden mit dem ».« .......................
3.4.4
Konstruktoren nutzen ................................................................
Pakete und import-Deklarationen nutzen .................................................
3.5.1
Volle Qualifizierung und import-Deklaration ..............................
3.5.2
import * .....................................................................................
Mit Referenzen arbeiten ...........................................................................
3.6.1
Zuweisungen bei Referenzen .....................................................
3.6.2
Methoden mit nicht-primitiven Parametern ...............................
Identität und Gleichheit ...........................................................................
3.7.1
Identität von Objekten ..............................................................
3.7.2
Gleichheit und die Methode equals() .........................................
3.7.3
Die null-Referenz .......................................................................
Wrapper-Klassen und Autoboxing ............................................................
3.8.1
Erzeugen von Wrapper-Objekten ...............................................
3.8.2
Konvertierungen in eine String-Repräsentation ..........................
3.8.3
Die Klasse Integer ......................................................................
3.8.4
Die Klassen Double und Float für Fließkommazahlen .................
3.8.5
Die Basisklasse Number für numerische Wrapper-Objekte .........
3.8.6
Die Boolean-Klasse ....................................................................
3.8.7
Autoboxing: Boxing und Unboxing ............................................
Compilationseinheiten und eigene Pakete schnüren .................................
3.9.1
Die package-Anweisung .............................................................
3.9.2
Importieren von Klassen mit import ...........................................
3.9.3
Hierarchische Strukturen und das Default-Package .....................
3.9.4
Paketnamen ...............................................................................
181
181
182
183
183
184
184
185
186
187
187
189
189
192
193
193
194
195
195
196
197
197
198
200
201
202
203
204
205
206
207
208
211
211
211
212
213
1371.book Seite 9 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
3.10
3.11
3.12
4
3.9.5
Klassen mit gleichen Namen in unterschiedlichen Paketen .........
3.9.6
Compilationseinheit (Compilation Unit) .....................................
3.9.7
Statischer Import .......................................................................
3.9.8
Eine Verzeichnisstruktur für eigene Projekte ..............................
Arrays .......................................................................................................
3.10.1 Deklaration von Arrays ..............................................................
3.10.2 Arrays mit Inhalt ........................................................................
3.10.3 Die Länge eines Arrays über das Attribut length .........................
3.10.4 Zugriff auf die Elemente über den Index ....................................
3.10.5 Array-Objekte mit new erzeugen ...............................................
3.10.6 Fehler bei Arrays ........................................................................
3.10.7 Die erweiterte for-Schleife .........................................................
3.10.8 Arrays mit nicht-primitiven Elementen .......................................
3.10.9 Mehrdimensionale Arrays ..........................................................
3.10.10 Vorinitialisierte Arrays ................................................................
3.10.11 Mehrere Rückgabewerte ............................................................
3.10.12 Methode mit variabler Argumentanzahl (Vararg) ........................
3.10.13 Klonen kann sich lohnen – Arrays vermehren .............................
3.10.14 Feldinhalte kopieren ..................................................................
3.10.15 Die Klasse Arrays zum Vergleichen, Füllen und Suchen ..............
Der Einstiegspunkt für das Laufzeitsystem: main() .....................................
3.11.1 Kommandozeilen-Argumente verarbeiten ..................................
3.11.2 Der Rückgabewert von main() und System.exit() ........................
Zum Weiterlesen ......................................................................................
213
213
213
214
215
215
216
216
216
217
218
219
221
222
224
226
226
228
228
229
235
235
236
236
Der Umgang mit Zeichenketten .......................................................... 237
4.1
4.2
4.3
4.4
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 String-Repräsentationen konvertieren
4.3.2
String in primitives Element konvertieren ...................................
Veränderbare Zeichenketten mit StringBuilder/StringBuffer ......................
4.4.1
Anlegen von StringBuilder-/StringBuffer-Objekten .....................
4.4.2
Die Länge eines StringBuilder-/StringBuffer-Objekts ..................
237
238
242
242
243
245
247
249
251
253
256
256
257
259
259
260
9
1371.book Seite 10 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
4.5
4.6
4.7
4.8
4.9
4.10
5
261
262
263
264
264
264
267
269
269
269
271
273
273
274
275
276
277
278
283
285
288
288
289
289
290
291
291
294
295
297
Mathematisches .................................................................................. 299
5.1
5.2
5.3
5.4
10
4.4.3
Daten anhängen ........................................................................
4.4.4
Zeichen(folgen) setzen, erfragen, löschen und umdrehen ...........
4.4.5
Vergleichen von String/StringBuilder/StringBuffer ......................
4.4.6
hashCode() bei StringBuffer/StringBuilder ..................................
Sprachabhängiges Vergleichen und Normalisierung ..................................
4.5.1
Die Klasse Collator .....................................................................
4.5.2
Effiziente interne Speicherung für die Sortierung ........................
4.5.3
Normalisierung ..........................................................................
Reguläre Ausdrücke ..................................................................................
4.6.1
Arbeiten mit der Fassade: String.matches() ................................
4.6.2
Die Klassen Pattern und Matcher ...............................................
4.6.3
Quantifizierer und Wiederholungen ...........................................
4.6.4
Finden und nicht matchen .........................................................
4.6.5
Gierige und nicht gierige Operatoren .........................................
4.6.6
Mit MatchResult alle Ergebnisse einsammeln .............................
Zerlegen von Zeichenketten ......................................................................
4.7.1
Splitten von Zeichenketten mit split() ........................................
4.7.2
Die Klasse Scanner .....................................................................
4.7.3
StringTokenizer ..........................................................................
4.7.4
BreakIterator als Zeichen-, Wort-, Zeilen- und Satztrenner .........
Zeichenkodierungen und Base64 ..............................................................
4.8.1
Über die Klasse String Kodierungen vornehmen .........................
4.8.2
Konvertieren mit OutputStreamWriter-Klassen ..........................
4.8.3
Das Paket java.nio.charset .........................................................
4.8.4
Base64-Kodierung .....................................................................
Formatieren von Ausgaben .......................................................................
4.9.1
Formatieren mit format() aus String ...........................................
4.9.2
Die Format-Klassen im Überblick ...............................................
4.9.3
Zahlen, Prozente und Währungen mit NumberFormat und
DecimalFormat formatieren .......................................................
Zum Weiterlesen ......................................................................................
Repräsentation ganzer Zahlen – das Zweierkomplement ...........................
Fließkommaarithmetik in Java ...................................................................
5.2.1
Mantisse und Exponent .............................................................
5.2.2
Spezialwerte Unendlich, Null, NaN ............................................
Wertebereich eines Typs und Überlaufkontrolle ........................................
5.3.1
Behandlung des Überlaufs ..........................................................
Die Eigenschaften der Klasse Math ...........................................................
5.4.1
Attribute ....................................................................................
5.4.2
Absolutwerte und Maximum/Minimum .....................................
299
300
300
301
303
304
305
307
307
1371.book Seite 11 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
5.5
5.6
5.7
5.8
6
5.4.3
Winkelfunktionen ......................................................................
5.4.4
Runden von Werten ..................................................................
5.4.5
Wurzel und Exponentialfunktionen ............................................
5.4.6
Der Logarithmus ........................................................................
5.4.7
Rest der ganzzahligen Division ...................................................
5.4.8
Zufallszahlen ..............................................................................
Mathe bitte strikt .....................................................................................
5.5.1
Strikt Fließkomma mit strictfp ....................................................
5.5.2
Die Klassen Math und StrictMath ..............................................
Die Random-Klasse ..................................................................................
5.6.1
Objekte aufbauen und der Seed .................................................
5.6.2
Zufallszahlen erzeugen ...............................................................
5.6.3
Pseudo-Zufallszahlen in der Normalverteilung ............................
Große Zahlen ............................................................................................
5.7.1
Die Klasse BigInteger .................................................................
5.7.2
Methoden von BigInteger ..........................................................
5.7.3
Ganz lange Fakultäten ...............................................................
5.7.4
Große Fließkommazahlen mit BigDecimal ..................................
5.7.5
Mit MathContext komfortabel die Rechengenauigkeit setzen ....
Zum Weiterlesen ......................................................................................
308
309
311
311
312
313
313
314
314
314
315
315
316
316
316
319
321
322
324
325
Eigene Klassen schreiben .................................................................... 327
6.1
6.2
6.3
Eigene Klassen mit Eigenschaften deklarieren ...........................................
6.1.1
Attribute deklarieren .................................................................
6.1.2
Methoden deklarieren ...............................................................
6.1.3
Die this-Referenz .......................................................................
Privatsphäre und Sichtbarkeit ...................................................................
6.2.1
Für die Öffentlichkeit: public .....................................................
6.2.2
Kein Public Viewing – Passwörter sind privat .............................
6.2.3
Wieso nicht freie Methoden und Variablen für alle? ...................
6.2.4
Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht .......
6.2.5
Zugriffsmethoden für Attribute deklarieren ................................
6.2.6
Setter und Getter nach der JavaBeans-Spezifikation ...................
6.2.7
Paketsichtbar .............................................................................
6.2.8
Zusammenfassung zur Sichtbarkeit .............................................
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 Variablen zum Datenaustausch ....................................
6.3.6
Statische Eigenschaften und Objekteigenschaften ......................
327
327
328
332
335
335
336
337
337
338
339
341
342
344
344
345
346
346
347
348
11
1371.book Seite 12 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
12
Konstanten und Aufzählungen ..................................................................
6.4.1
Konstanten über öffentliche statische finale Variablen ...............
6.4.2
Eincompilierte Belegungen der Klassenvariablen ........................
6.4.3
Typ(un)sichere Aufzählungen .....................................................
6.4.4
Aufzählungen mit enum .............................................................
Objekte anlegen und zerstören .................................................................
6.5.1
Konstruktoren schreiben ............................................................
6.5.2
Der Default-Konstruktor ............................................................
6.5.3
Parametrisierte und überladene Konstruktoren ..........................
6.5.4
Copy-Konstruktor ......................................................................
6.5.5
Einen anderen Konstruktor der gleichen Klasse aufrufen ............
6.5.6
Ihr fehlt uns nicht – der Garbage-Collector .................................
6.5.7
Private Konstruktoren, Utility-Klassen, Singleton, Fabriken ........
Klassen- und Objektinitialisierung ............................................................
6.6.1
Initialisierung von Objektvariablen .............................................
6.6.2
Statische Blöcke als Klasseninitialisierer .....................................
6.6.3
Initialisierung von Klassenvariablen ............................................
6.6.4
Exemplarinitialisierer (Instanzinitialisierer) ..................................
6.6.5
Finale Werte im Konstruktor und in statischen Blöcken setzen ...
Assoziationen zwischen Objekten .............................................................
6.7.1
Unidirektionale 1:1-Beziehung ...................................................
6.7.2
Bidirektionale 1:1-Beziehungen .................................................
6.7.3
Unidirektionale 1:n-Beziehung ...................................................
Vererbung ................................................................................................
6.8.1
Vererbung in Java ......................................................................
6.8.2
Spielobjekte modelliert ..............................................................
6.8.3
Implizite Basisklasse java.lang.Object .........................................
6.8.4
Einfach- und Mehrfachvererbung ...............................................
6.8.5
Sichtbarkeit protected ...............................................................
6.8.6
Konstruktoren in der Vererbung und super ................................
Typen in Hierarchien ................................................................................
6.9.1
Automatische und explizite Typanpassung .................................
6.9.2
Das Substitutionsprinzip ............................................................
6.9.3
Typen mit dem binären Operator instanceof testen ....................
Methoden überschreiben .........................................................................
6.10.1 Methoden in Unterklassen mit neuem Verhalten ausstatten .......
6.10.2 Mit super an die Eltern ..............................................................
6.10.3 Finale Klassen und finale Methoden ..........................................
6.10.4 Kovariante Rückgabetypen ........................................................
6.10.5 Array-Typen und Kovarianz ........................................................
Dynamisches Binden/Polymorphie ............................................................
6.11.1 Unpolymorph bei privaten, statischen und finalen Methoden ....
6.11.2 Polymorphie bei Konstruktoraufrufen ........................................
349
349
350
351
352
355
355
356
357
359
360
362
364
366
366
368
368
369
371
373
373
374
375
377
378
378
380
380
380
381
385
385
387
389
390
390
393
395
396
397
398
401
403
1371.book Seite 13 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
6.12
6.13
6.14
7
Abstrakte Klassen und abstrakte Methoden ..............................................
6.12.1 Abstrakte Klassen ......................................................................
6.12.2 Abstrakte Methoden ..................................................................
Schnittstellen ...........................................................................................
6.13.1 Deklarieren von Schnittstellen ...................................................
6.13.2 Implementieren von Schnittstellen .............................................
6.13.3 Markierungsschnittstellen ..........................................................
6.13.4 Ein Polymorphie-Beispiel mit Schnittstellen ...............................
6.13.5 Die Mehrfachvererbung bei Schnittstellen ..................................
6.13.6 Keine Kollisionsgefahr bei Mehrfachvererbung ...........................
6.13.7 Erweitern von Interfaces – Subinterfaces ....................................
6.13.8 Vererbte Konstanten bei Schnittstellen ......................................
6.13.9 Abstrakte Klassen und Schnittstellen im Vergleich .....................
Dokumentationskommentare mit JavaDoc ................................................
6.14.1 Einen Dokumentationskommentar setzen ..................................
6.14.2 Mit javadoc eine Dokumentation erstellen .................................
6.14.3 HTML-Tags in Dokumentationskommentaren ............................
6.14.4 Generierte Dateien ....................................................................
6.14.5 Dokumentationskommentare im Überblick ................................
6.14.6 JavaDoc und Doclets .................................................................
6.14.7 Veraltete (deprecated) Typen und Eigenschaften ........................
404
405
406
409
409
410
411
412
413
416
417
418
419
420
421
423
423
423
424
425
426
Angewandte Objektorientierung ........................................................ 429
7.1
7.2
7.3
7.4
Schnittstellen in der Anwendung ..............................................................
7.1.1
CharSequence als Beispiel einer Schnittstelle .............................
7.1.2
Die Schnittstelle Iterable ............................................................
7.1.3
Funktionszeiger .........................................................................
Design-Pattern (Entwurfsmuster) ..............................................................
7.2.1
Motivation für Design-Pattern ...................................................
7.2.2
Das Beobachter-Pattern (Observer/Observable) .........................
7.2.3
Ereignisse über Listener .............................................................
Service-Factory .........................................................................................
7.3.1
Arbeiten mit dem ServiceLoader ................................................
7.3.2
Utility-Klasse Lookup als ServiceLoader-Fassade ........................
JavaBean ..................................................................................................
7.4.1
Properties (Eigenschaften) .........................................................
7.4.2
Einfache Eigenschaften ..............................................................
7.4.3
Indizierte Eigenschaften .............................................................
7.4.4
Gebundene Eigenschaften ..........................................................
7.4.5
Veto-Eigenschaften – dagegen! ..................................................
429
429
431
433
435
435
436
439
443
443
444
445
446
446
447
447
450
13
1371.book Seite 14 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
8
Exceptions ........................................................................................... 455
8.1
8.2
8.3
8.4
8.5
8.6
9
455
455
456
458
458
459
462
465
466
466
467
468
469
470
471
471
473
474
475
476
476
477
478
479
480
Generics, innere Klassen ..................................................................... 481
9.1
9.2
14
Problembereiche einzäunen ......................................................................
8.1.1
Exceptions in Java mit try und catch ..........................................
8.1.2
Eine Datei mit RandomAccessFile auslesen ................................
8.1.3
Ablauf einer Ausnahmesituation ................................................
8.1.4
Wiederholung abgebrochener Bereiche .....................................
8.1.5
throws im Methodenkopf angeben ............................................
8.1.6
Abschlussbehandlung mit finally ................................................
8.1.7
Nicht erreichbare catch-Klauseln ...............................................
Die Klassenhierarchie der Fehler ...............................................................
8.2.1
Die Exception-Hierarchie ...........................................................
8.2.2
Oberausnahmen auffangen ........................................................
8.2.3
Alles geht als Exception durch ...................................................
8.2.4
RuntimeException muss nicht aufgefangen werden ....................
8.2.5
Harte Fehler: Error .....................................................................
Auslösen eigener Exceptions .....................................................................
8.3.1
Mit throw Ausnahmen auslösen .................................................
8.3.2
Neue Exception-Klassen deklarieren ..........................................
8.3.3
Abfangen und Weiterleiten ........................................................
8.3.4
Geschachtelte Ausnahmen .........................................................
Rückgabewerte bei ausgelösten Ausnahmen .............................................
Der Stack-Trace ........................................................................................
8.5.1
Stack-Trace erfragen ..................................................................
Assertions .................................................................................................
8.6.1
Assertions in eigenen Programmen nutzen .................................
8.6.2
Assertions aktivieren ..................................................................
Generische Datentypen ............................................................................
9.1.1
Einfache Klassenschablonen .......................................................
9.1.2
Einfache Methodenschablonen ..................................................
9.1.3
Umsetzen der Generics, Typlöschung und Raw-Types ................
9.1.4
Generics und Arrays ...................................................................
9.1.5
Einschränken der Typen .............................................................
9.1.6
Generics und Vererbung, Invarianz ............................................
9.1.7
Wildcards ..................................................................................
Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen ....................
9.2.1
Statische innere Klassen und Schnittstellen ................................
9.2.2
Mitglieds- oder Elementklassen .................................................
9.2.3
Lokale Klassen ...........................................................................
481
482
483
484
486
487
488
489
490
491
492
496
1371.book Seite 15 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
9.2.4
9.2.5
Anonyme innere Klassen ............................................................ 496
this und Vererbung .................................................................... 499
10 Die Klassenbibliothek ......................................................................... 501
10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
Die Java-Klassenphilosophie .....................................................................
10.1.1 Übersicht über die Pakete der Standardbibliothek ......................
Object ist die Mutter aller Klassen ............................................................
10.2.1 Klassenobjekte ...........................................................................
10.2.2 Objektidentifikation mit toString() .............................................
10.2.3 Objektgleichheit mit equals() und Identität ................................
10.2.4 Klonen eines Objekts mit clone() ...............................................
10.2.5 Hashcodes über hashCode() liefern ............................................
10.2.6 Aufräumen mit finalize() ............................................................
10.2.7 Synchronisation .........................................................................
Die Spezial-Oberklasse Enum ...................................................................
10.3.1 Methoden auf Enum-Objekten ..................................................
10.3.2 enum mit eigenen Konstruktoren und Methoden ......................
Klassenlader (Class Loader) .......................................................................
10.4.1 Woher die kleinen Klassen kommen ..........................................
10.4.2 Setzen des Klassenpfades ...........................................................
10.4.3 Die wichtigsten drei Typen von Klassenladern ............................
10.4.4 Der java.lang.ClassLoader ..........................................................
10.4.5 Hot Deployment mit dem URL-Classloader ................................
10.4.6 Das jre/lib/endorsed-Verzeichnis ...............................................
Die Utility-Klasse System und Properties ..................................................
10.5.1 Systemeigenschaften der Java-Umgebung ..................................
10.5.2 line.separator .............................................................................
10.5.3 Property von der Konsole aus setzen .........................................
10.5.4 Umgebungsvariablen des Betriebssystems ..................................
10.5.5 Einfache Zeitmessung und Profiling ............................................
Ausführen externer Programme und Skripte .............................................
10.6.1 ProcessBuilder und Prozesskontrolle mit Process .......................
10.6.2 Einen Browser/E-Mail-Client/Editor aufrufen .............................
10.6.3 Ausführen von Skripten .............................................................
Benutzereinstellungen ..............................................................................
10.7.1 Benutzereinstellungen speichern ................................................
10.7.2 Einträge einfügen, auslesen und löschen ....................................
10.7.3 Auslesen der Daten und Schreiben in anderem Format ..............
10.7.4 Auf Ereignisse horchen ..............................................................
10.7.5 Zugriff auf die gesamte Windows-Registry .................................
Musik abspielen .......................................................................................
10.8.1 Die Arbeit mit AudioClip ...........................................................
501
501
508
508
509
510
514
517
520
522
522
523
525
528
528
529
530
531
532
535
535
536
537
538
539
540
540
541
544
545
547
547
548
550
550
551
552
552
15
1371.book Seite 16 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
10.8.2 Java Sound API ..........................................................................
10.9 Annotationen ...........................................................................................
10.9.1 Annotationstypen @Override, @Deprecated,
@SuppressWarnings ..................................................................
10.9.2 Annotationen für Web-Services .................................................
10.10 Zum Weiterlesen ......................................................................................
552
554
554
556
556
11 Threads und nebenläufige Programmierung ....................................... 557
11.1
11.2
11.3
11.4
11.5
16
Nebenläufigkeit ........................................................................................
11.1.1 Threads und Prozesse ................................................................
11.1.2 Wie parallele Programme die Geschwindigkeit steigern können .
11.1.3 Was Java für Nebenläufigkeit alles bietet ...................................
Threads erzeugen .....................................................................................
11.2.1 Threads über die Schnittstelle Runnable implementieren ...........
11.2.2 Thread mit Runnable starten ......................................................
11.2.3 Der Name eines Threads ............................................................
11.2.4 Die Klasse Thread erweitern ......................................................
11.2.5 Wer bin ich? ..............................................................................
Die Zustände eines Threads ......................................................................
11.3.1 Threads schlafen ........................................................................
11.3.2 Mit yield() auf Rechenzeit verzichten .........................................
11.3.3 Das Ende eines Threads .............................................................
11.3.4 UncaughtExceptionHandler für unbehandelte Ausnahmen .........
11.3.5 Einen Thread höflich mit Interrupt beenden ...............................
11.3.6 Der stop() von außen und die Rettung mit ThreadDeath ............
11.3.7 Ein Rendezvous mit join() ..........................................................
11.3.8 Barrier und Austausch mit Exchanger .........................................
11.3.9 Arbeit niederlegen und wieder aufnehmen ................................
11.3.10 Priorität .....................................................................................
11.3.11 Der Thread als Dämon ...............................................................
Der Ausführer (Executor) kommt ..............................................................
11.4.1 Die Schnittstelle Executor ..........................................................
11.4.2 Die Thread-Pools .......................................................................
11.4.3 Threads mit Rückgabe über Callable ..........................................
11.4.4 Mehrere Callable abarbeiten ......................................................
11.4.5 Mit ScheduledExecutorService wiederholende Ausgaben und
Zeitsteuerungen .........................................................................
Synchronisation über kritische Abschnitte .................................................
11.5.1 Gemeinsam genutzte Daten .......................................................
11.5.2 Probleme beim gemeinsamen Zugriff und kritische Abschnitte ...
11.5.3 Punkte parallel initialisieren .......................................................
11.5.4 i++ sieht atomar aus, ist es aber nicht ........................................
557
557
559
560
561
561
562
563
563
566
566
567
569
569
570
571
573
574
576
577
577
578
580
580
581
583
585
586
586
586
587
588
589
1371.book Seite 17 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
11.5.5 Kritische Abschnitte schützen ....................................................
11.5.6 Schützen mit ReentrantLock ......................................................
11.5.7 Synchronisieren mit synchronized ..............................................
11.5.8 Synchronized-Methoden der Klasse StringBuffer ........................
11.5.9 Mit synchronized synchronisierte Blöcke ....................................
11.5.10 Dann machen wir doch gleich alles synchronisiert! .....................
11.5.11 Lock-Freigabe im Fall von Exceptions .........................................
11.5.12 Mit synchronized nachträglich synchronisieren ..........................
11.5.13 Monitore sind reentrant – gut für die Geschwindigkeit ..............
11.5.14 Synchronisierte Methodenaufrufe zusammenfassen ...................
11.5.15 Deadlocks ..................................................................................
11.6 Synchronisation über Warten und Benachrichtigen ...................................
11.6.1 Die Schnittstelle Condition ........................................................
11.6.2 It’s Disco-Time ..........................................................................
11.6.3 Warten mit wait() und Aufwecken mit notify() ...........................
11.6.4 Falls der Lock fehlt: IllegalMonitorStateException ......................
11.6.5 Semaphor ..................................................................................
11.7 Atomare Operationen und frische Werte mit volatile ................................
11.7.1 Der Modifizierer volatile bei Objekt-/Klassenvariablen ...............
11.7.2 Das Paket java.util.concurrent.atomic ........................................
11.8 Mit dem Thread verbundene Variablen ....................................................
11.8.1 ThreadLocal ...............................................................................
11.8.2 InheritableThreadLocal ..............................................................
11.9 Gruppen von Threads in einer Thread-Gruppe ..........................................
11.9.1 Aktive Threads in der Umgebung ...............................................
11.9.2 Etwas über die aktuelle Thread-Gruppe herausfinden ................
11.9.3 Threads in einer Thread-Gruppe anlegen ...................................
11.9.4 Methoden von Thread und ThreadGroup im Vergleich ...............
11.10 Zeitgesteuerte Abläufe .............................................................................
11.10.1 Die Klassen Timer und TimerTask ..............................................
11.10.2 Job-Scheduler Quartz ................................................................
11.11 Einen Abbruch der virtuellen Maschine erkennen .....................................
11.12 Zum Weiterlesen ......................................................................................
590
591
596
597
598
599
600
600
601
602
603
605
606
609
613
615
616
619
619
620
621
622
624
625
626
626
628
631
632
633
634
635
636
12 Datenstrukturen und Algorithmen ...................................................... 637
12.1
Datenstrukturen und die Collection-API ...................................................
12.1.1 Designprinzip mit Schnittstellen, abstrakten und konkreten
Klassen ......................................................................................
12.1.2 Die Basis-Schnittstellen Collection und Map ..............................
12.1.3 Das erste Programm mit Container-Klassen ................................
12.1.4 Die Schnittstelle Collection ........................................................
12.1.5 Schnittstellen, die Collection erweitern, und Map ......................
637
638
639
639
640
642
17
1371.book Seite 18 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
12.2
12.3
12.4
12.5
12.6
12.7
12.8
18
12.1.6 Konkrete Container-Klassen .......................................................
12.1.7 Welche Klasse nehmen? ............................................................
12.1.8 Generische Datentypen in der Collection-API ............................
12.1.9 Die Schnittstelle Iterable und das erweiterte for .........................
Mit einem Iterator durch die Daten wandern ...........................................
12.2.1 Die Schnittstellen Enumeration und Iterator ..............................
12.2.2 Iteratoren von Sammlungen und das erweiterte for ....................
12.2.3 Fail-Fast Iterator und die ConcurrentModificationException .......
Listen .......................................................................................................
12.3.1 Auswahlkriterium ArrayList oder LinkedList ...............................
12.3.2 Die Schnittstelle List ..................................................................
12.3.3 ArrayList ....................................................................................
12.3.4 LinkedList ..................................................................................
12.3.5 Der Feld-Adapter Arrays.asList() ................................................
12.3.6 toArray() von Collection verstehen – die Gefahr einer Falle
erkennen ...................................................................................
12.3.7 Primitive Elemente in den Collection-Datenstrukturen ...............
Vergleichen von Objekten ........................................................................
12.4.1 Die Schnittstellen Comparator und Comparable .........................
12.4.2 Algorithmen mit Such- und Sortiermöglichkeiten .......................
12.4.3 Den größten und kleinsten Wert einer Collection finden ............
12.4.4 Sortieren ....................................................................................
Mengen (Sets) ..........................................................................................
12.5.1 HashSet .....................................................................................
12.5.2 TreeSet – die Menge durch Bäume .............................................
12.5.3 LinkedHashSet ...........................................................................
Stack (Kellerspeicher, Stapel) ....................................................................
12.6.1 Die Methoden von Stack ...........................................................
12.6.2 Ein Stack ist ein Vector – aha! ....................................................
Queues (Schlangen) und Deques ..............................................................
12.7.1 Die Schnittstelle Queue .............................................................
12.7.2 Blockierende Queues und Prioritätswarteschlangen ...................
12.7.3 Deque-Klassen ...........................................................................
Assoziative Speicher .................................................................................
12.8.1 Die Klassen HashMap und TreeMap ..........................................
12.8.2 Einfügen und Abfragen der Datenstruktur ..................................
12.8.3 equals(), hashCode() und IdentityHashMap ................................
12.8.4 Das Problem von veränderbaren Elementen ...............................
12.8.5 Aufzählungen und Sichten auf den Assoziativspeicher ................
12.8.6 Der Gleichheitstest, Hash-Wert und Klon einer Hash-Tabelle .....
12.8.7 Die Arbeitsweise einer Hash-Tabelle ..........................................
12.8.8 Multi-Maps ...............................................................................
644
645
645
646
647
647
649
651
651
652
652
659
661
662
663
666
666
666
669
669
671
674
676
677
680
680
680
681
682
682
683
684
684
684
686
689
691
691
694
694
697
1371.book Seite 19 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
12.9
Die Properties-Klasse ...............................................................................
12.9.1 Properties setzen und lesen .......................................................
12.9.2 Properties verketten ..................................................................
12.9.3 Eigenschaften ausgeben .............................................................
12.9.4 Hierarchische Eigenschaften .......................................................
12.9.5 Properties speichern ..................................................................
12.9.6 Klassenbeziehungen: Properties und Hashtable ..........................
12.10 Algorithmen in Collections .......................................................................
12.10.1 Ersetzen, Kopieren, Füllen, Umdrehen, Rotieren, Durchmischen
12.10.2 Mit der Halbierungssuche nach Elementen fahnden ...................
12.10.3 Nicht-änderbare Datenstrukturen ..............................................
12.10.4 Häufigkeit eines Elements ..........................................................
12.10.5 nCopies() ...................................................................................
12.10.6 Singletons ..................................................................................
12.11 Synchronisation der Datenstrukturen ........................................................
12.11.1 Lock-free-Algorithmen aus java.util.concurrent ..........................
12.11.2 Wrapper zur Synchronisation .....................................................
12.11.3 CopyOnWriteArrayList und CopyOnWriteArraySet .....................
12.12 Die Klasse BitSet für Bitmengen ................................................................
12.12.1 Ein BitSet anlegen, füllen und erfragen .......................................
12.12.2 Mengenorientierte Operationen ................................................
12.12.3 Methodenübersicht ...................................................................
12.12.4 Primzahlen in einem BitSet verwalten ........................................
697
697
697
699
699
699
701
701
702
703
705
705
705
706
707
707
708
709
709
709
710
711
712
13 Raum und Zeit ..................................................................................... 713
13.1
13.2
13.3
13.4
13.5
13.6
Weltzeit ...................................................................................................
Wichtige Datum-Klassen im Überblick ......................................................
Sprachen der Länder .................................................................................
13.3.1 Sprachen und Regionen über Locale-Objekte .............................
Internationalisierung und Lokalisierung ....................................................
13.4.1 ResourceBundle-Objekte und Ressource-Dateien ......................
13.4.2 Ressource-Dateien zur Lokalisierung ..........................................
13.4.3 Die Klasse ResourceBundle ........................................................
13.4.4 Ladestrategie für ResourceBundle-Objekte ................................
Die Klasse Date ........................................................................................
13.5.1 Objekte erzeugen und Methoden nutzen ...................................
13.5.2 Date-Objekte nicht immutable ..................................................
Calendar und GregorianCalendar ..............................................................
13.6.1 Die abstrakte Klasse Calendar ....................................................
13.6.2 Der gregorianische Kalender ......................................................
13.6.3 Ostertage ...................................................................................
13.6.4 Abfragen und Setzen von Datumselementen ..............................
713
714
714
715
718
719
719
719
720
722
722
723
724
724
726
728
729
19
1371.book Seite 20 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
13.7
13.8
Formatieren und Parsen von Datumsangaben ...........................................
13.7.1 Ausgaben mit printf() .................................................................
13.7.2 Mit DateFormat und SimpleDateFormat formatieren .................
13.7.3 Parsen von Datumswerten .........................................................
Zum Weiterlesen ......................................................................................
735
735
735
740
742
14 Dateien und Datenströme ................................................................... 743
14.1
14.2
14.3
14.4
20
Datei und Verzeichnis ...............................................................................
14.1.1 Dateien und Verzeichnisse mit der Klasse File ............................
14.1.2 Verzeichnis oder Datei? Existiert es? ..........................................
14.1.3 Verzeichnis- und Dateieigenschaften/-attribute .........................
14.1.4 Wurzelverzeichnis, Laufwerksnamen, Plattenspeicher ................
14.1.5 Umbenennen und Verzeichnisse anlegen ...................................
14.1.6 Verzeichnisse listen und Dateien filtern ......................................
14.1.7 Dateien berühren, neue Dateien anlegen, temporäre Dateien ....
14.1.8 Dateien und Verzeichnisse löschen ............................................
14.1.9 Verzeichnisse nach Dateien iterativ durchsuchen .......................
14.1.10 URL- und URI-Objekte aus einem File-Objekt ableiten ..............
14.1.11 Mit Locking Dateien sperren ......................................................
14.1.12 Sicherheitsprüfung .....................................................................
Dateien mit wahlfreiem Zugriff .................................................................
14.2.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen ............
14.2.2 Aus dem RandomAccessFile lesen ..............................................
14.2.3 Schreiben mit RandomAccessFile ...............................................
14.2.4 Die Länge des RandomAccessFile ...............................................
14.2.5 Hin und her in der Datei ............................................................
Stream-Klassen und Reader/Writer am Beispiel von Dateien .....................
14.3.1 Mit dem FileWriter Texte in Dateien schreiben ..........................
14.3.2 Zeichen mit der Klasse FileReader lesen .....................................
14.3.3 Kopieren mit FileOutputStream und FileInputStream .................
14.3.4 Das FileDescriptor-Objekt ..........................................................
Basisklassen für die Ein-/Ausgabe .............................................................
14.4.1 Die abstrakten Basisklassen ........................................................
14.4.2 Übersicht über Ein-/Ausgabeklassen ..........................................
14.4.3 Die abstrakte Basisklasse OutputStream .....................................
14.4.4 Die Schnittstellen Closeable und Flushable ................................
14.4.5 Ein Datenschlucker ....................................................................
14.4.6 Die abstrakte Basisklasse InputStream ........................................
14.4.7 Ressourcen aus dem Klassenpfad und aus Jar-Archiven laden .....
14.4.8 Ströme mit SequenceInputStream zusammensetzen ...................
14.4.9 Die abstrakte Basisklasse Writer .................................................
14.4.10 Die Schnittstelle Appendable .....................................................
744
744
746
747
749
752
752
755
756
758
759
759
760
761
762
762
764
765
765
766
767
768
769
772
773
773
773
775
776
777
777
778
779
781
782
1371.book Seite 21 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
14.4.11 Die abstrakte Basisklasse Reader ................................................
14.5 Formatierte Textausgaben ........................................................................
14.5.1 Die Klassen PrintWriter und PrintStream ...................................
14.5.2 System.out, System.err und System.in ........................................
14.5.3 Geschützte Passwort-Eingaben mit der Klasse Console ...............
14.6 Schreiben und Lesen aus Strings und Byte-Feldern ...................................
14.6.1 Mit dem StringWriter ein String-Objekt füllen ...........................
14.6.2 CharArrayWriter ........................................................................
14.6.3 StringReader und CharArrayReader ............................................
14.6.4 Mit ByteArrayOutputStream in ein Byte-Feld schreiben .............
14.6.5 Mit ByteArrayInputStream aus einem Byte-Feld lesen ................
14.7 Datenströme filtern und verketten ............................................................
14.7.1 Streams als Filter verketten ........................................................
14.7.2 Gepufferte Ausgaben mit BufferedWriter/BufferedOutputStream
14.7.3 Gepufferte Eingaben mit BufferedReader/BufferedInputStream ..
14.7.4 LineNumberReader zählt automatisch Zeilen mit .......................
14.7.5 Daten mit der Klasse PushbackReader zurücklegen ....................
14.7.6 DataOutputStream/DataInputStream .........................................
14.7.7 Basisklassen für Filter .................................................................
14.7.8 Die Basisklasse FilterWriter ........................................................
14.7.9 Ein LowerCaseWriter .................................................................
14.7.10 Eingaben mit der Klasse FilterReader filtern ...............................
14.8 Vermittler zwischen Byte-Streams und Unicode-Strömen .........................
14.8.1 Datenkonvertierung durch den OutputStreamWriter .................
14.8.2 Automatische Konvertierungen mit dem InputStreamReader .....
14.9 Kommunikation zwischen Threads mit Pipes ............................................
14.9.1 PipedOutputStream und PipedInputStream ...............................
14.9.2 PipedWriter und PipedReader ...................................................
14.10 Datenkompression ...................................................................................
14.10.1 Java-Unterstützung beim Komprimieren ....................................
14.10.2 Datenströme komprimieren .......................................................
14.10.3 Zip-Archive ................................................................................
14.10.4 Jar-Archive ................................................................................
14.11 Prüfsummen .............................................................................................
14.11.1 Die Schnittstelle Checksum ........................................................
14.11.2 Die Klasse CRC32 ......................................................................
14.11.3 Die Adler32-Klasse ....................................................................
14.12 Persistente Objekte und Serialisierung ......................................................
14.12.1 Objekte mit der Standard-Serialisierung speichern und lesen .....
14.12.2 Zwei einfache Anwendungen der Serialisierung ..........................
14.12.3 Die Schnittstelle Serializable ......................................................
14.12.4 Nicht serialisierbare Attribute aussparen ....................................
783
785
785
790
792
792
793
794
795
796
797
797
798
798
800
802
803
805
805
806
807
808
809
809
810
812
812
814
815
816
817
821
827
827
827
828
830
830
831
834
835
836
21
1371.book Seite 22 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
14.12.5 Das Abspeichern selbst in die Hand nehmen ............................
14.12.6 Tiefe Objektkopien ..................................................................
14.12.7 Versionenverwaltung und die SUID .........................................
14.12.8 Wie die ArrayList serialisiert .....................................................
14.12.9 Probleme mit der Serialisierung ...............................................
14.12.10 Serialisieren in XML-Dateien ....................................................
14.12.11 JavaBeans Persistence ..............................................................
14.12.12 XStream ...................................................................................
14.13 Tokenizer .................................................................................................
14.13.1 StreamTokenizer ......................................................................
14.13.2 CSV-Dateien verarbeiten .........................................................
14.14 Zum Weiterlesen ......................................................................................
838
841
843
845
845
846
846
848
849
849
852
853
15 Die eXtensible Markup Language (XML) ............................................ 855
15.1
15.2
15.3
15.4
15.5
22
Auszeichnungssprachen ............................................................................
15.1.1 Die Standard Generalized Markup Language (SGML) .................
15.1.2 Extensible Markup Language (XML) ...........................................
Eigenschaften von XML-Dokumenten .......................................................
15.2.1 Elemente und Attribute .............................................................
15.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten ...
15.2.3 Schema – eine Alternative zu DTD .............................................
15.2.4 Namensraum (Namespace) ........................................................
15.2.5 XML-Applikationen ...................................................................
Die Java-APIs für XML ..............................................................................
15.3.1 Das Document Object Model (DOM) ........................................
15.3.2 Simple API for XML Parsing (SAX) ..............................................
15.3.3 Pull-API StAX ............................................................................
15.3.4 Java Document Object Model (JDOM) ......................................
15.3.5 JAXP als Java-Schnittstelle zu XML .............................................
15.3.6 DOM-Bäume einlesen mit JAXP .................................................
Serielle Verarbeitung mit StAX ..................................................................
15.4.1 Unterschiede der Verarbeitungsmodelle ....................................
15.4.2 XML-Dateien mit dem Cursor-Verfahren lesen ...........................
15.4.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten ................
15.4.4 Mit Filtern arbeiten ....................................................................
15.4.5 XML-Dokumente schreiben .......................................................
Serielle Verarbeitung von XML mit SAX ....................................................
15.5.1 Schnittstellen von SAX ...............................................................
15.5.2 SAX-Parser erzeugen ..................................................................
15.5.3 Operationen der Schnittstelle ContentHandler ...........................
15.5.4 ErrorHandler und EntityResolver ................................................
855
855
856
856
856
858
861
863
865
865
866
866
866
866
867
867
868
868
870
872
873
874
876
877
877
878
880
1371.book Seite 23 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
15.6
XML-Dateien mit JDOM verarbeiten ........................................................
15.6.1 JDOM beziehen .........................................................................
15.6.2 Paketübersicht ...........................................................................
15.6.3 Die Document-Klasse ................................................................
15.6.4 Eingaben aus der Datei lesen .....................................................
15.6.5 Das Dokument im XML-Format ausgeben ..................................
15.6.6 Der Dokumenttyp ......................................................................
15.6.7 Elemente ...................................................................................
15.6.8 Zugriff auf Elementinhalte ..........................................................
15.6.9 Liste mit Unterelementen erzeugen ...........................................
15.6.10 Neue Elemente einfügen und ändern .........................................
15.6.11 Attributinhalte lesen und ändern ...............................................
15.6.12 XPath ........................................................................................
15.7 Transformationen mit XSLT ......................................................................
15.7.1 Templates und XPath als Kernelemente von XSLT ......................
15.7.2 Umwandlung von XML-Dateien mit JDOM und JAXP ................
15.8 Java Architecture for XML Binding (JAXB) .................................................
15.8.1 Beans für JAXB aufbauen ...........................................................
15.8.2 JAXBContext und die Marshaller/Unmarshaller ..........................
15.8.3 Weitere JAXB-Annotationen ......................................................
15.9 HTML-Dokumente einlesen ......................................................................
15.10 Zum Weiterlesen ......................................................................................
881
881
882
883
884
885
885
886
889
891
891
894
896
899
899
901
902
902
904
905
910
912
16 Grafische Oberflächen mit Swing ....................................................... 913
16.1
16.2
16.3
16.4
Das Abstract Window Toolkit und Swing ..................................................
16.1.1 SwingSet-Demos .......................................................................
16.1.2 Abstract Window Toolkit (AWT) ................................................
16.1.3 Java Foundation Classes .............................................................
16.1.4 Was Swing von AWT unterscheidet ...........................................
16.1.5 Die Klasse Toolkit ......................................................................
Fenster unter grafischen Oberflächen .......................................................
16.2.1 Swing-Fenster darstellen ............................................................
16.2.2 Fenster schließbar machen – setDefaultCloseOperation() ...........
16.2.3 AWT-Fenster darstellen .............................................................
16.2.4 Sichtbarkeit des Fensters ............................................................
16.2.5 Größe und Position des Fensters verändern ...............................
16.2.6 Unterklassen der Fenster-Klassen bilden ....................................
16.2.7 Fenster- und Dialog-Dekoration, Transparenz ............................
16.2.8 Dynamisches Layout während einer Größenänderung ................
Beschriftungen (JLabel) .............................................................................
16.3.1 Mehrzeiliger Text, HTML in der Darstellung ...............................
Icon und ImageIcon für Bilder auf Swing-Komponenten ...........................
913
913
913
914
917
918
918
919
920
920
921
921
923
923
924
924
928
928
23
1371.book Seite 24 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
16.5
Es tut sich was – Ereignisse beim AWT ......................................................
16.5.1 Die Klasse AWTEvent ................................................................
16.5.2 Events auf verschiedenen Ebenen ..............................................
16.5.3 Swings Ereignisquellen und Horcher (Listener) ...........................
16.5.4 Listener implementieren ............................................................
16.5.5 Listener bei dem Ereignisauslöser anmelden/abmelden ..............
16.5.6 Aufrufen der Listener im AWT-Event-Thread ..............................
16.5.7 Adapterklassen nutzen ...............................................................
16.5.8 Innere Mitgliedsklassen und innere anonyme Klassen ................
16.6 Schaltflächen ............................................................................................
16.6.1 Normale Schaltflächen (JButton) ................................................
16.6.2 Der aufmerksame ActionListener ...............................................
16.6.3 Basisklasse AbstractButton .........................................................
16.6.4 Wechselknopf (JToggleButton) ...................................................
16.7 Swing Action ............................................................................................
16.8 JComponent und Component als Basis aller Komponenten .......................
16.8.1 Tooltips .....................................................................................
16.8.2 Rahmen (Border) .......................................................................
16.8.3 Fokus und Navigation ................................................................
16.8.4 Ereignisse jeder Komponente .....................................................
16.8.5 Die Größe und Position einer Komponente ................................
16.8.6 Komponenten-Ereignisse ...........................................................
16.8.7 Hinzufügen von Komponenten ..................................................
16.8.8 UI-Delegate – der wahre Zeichner ..............................................
16.8.9 Undurchsichtige (opake) Komponente .......................................
16.8.10 Properties und Listener für Änderungen .....................................
16.9 Container .................................................................................................
16.9.1 Standardcontainer (JPanel) .........................................................
16.9.2 Bereich mit automatischen Rollbalken (JScrollPane) ...................
16.9.3 Reiter (JTabbedPane) .................................................................
16.9.4 Teilungs-Komponente (JSplitPane) .............................................
16.10 Alles Auslegungssache: die Layoutmanager ...............................................
16.10.1 Übersicht über Layoutmanager ..................................................
16.10.2 Zuweisen eines Layoutmanagers ................................................
16.10.3 Im Fluss mit FlowLayout ............................................................
16.10.4 Mit BorderLayout in allen Himmelsrichtungen ...........................
16.10.5 Rasteranordnung mit GridLayout ...............................................
16.10.6 Der GridBagLayout-Manager .....................................................
16.10.7 Null-Layout ...............................................................................
16.10.8 BoxLayout .................................................................................
16.10.9 Weitere Layoutmanager .............................................................
24
930
930
931
933
934
936
937
937
939
940
941
942
944
946
947
948
949
949
951
952
955
956
957
957
960
960
960
961
961
962
964
964
964
965
966
968
970
972
976
977
978
1371.book Seite 25 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
16.11 Rollbalken und Schieberegler ...................................................................
16.11.1 Schieberegler (JSlider) ................................................................
16.11.2 Rollbalken (JScrollBar) ................................................................
16.12 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen ...................................
16.12.1 Kontrollfelder (JCheckBox) .........................................................
16.12.2 ItemSelectable, ItemListener und das ItemEvent ........................
16.12.3 Sich gegenseitig ausschließende Optionen (JRadioButton) .........
16.13 Fortschritte bei Operationen überwachen .................................................
16.13.1 Fortschrittsbalken (JProgressBar) ................................................
16.13.2 Dialog mit Fortschrittsanzeige (ProgressMonitor) .......................
16.14 Menüs und Symbolleisten ........................................................................
16.14.1 Die Menüleisten und die Einträge ..............................................
16.14.2 Menüeinträge definieren ...........................................................
16.14.3 Einträge durch Action-Objekte beschreiben ...............................
16.14.4 Mit der Tastatur: Mnemonics und Shortcut ................................
16.14.5 Der Tastatur-Shortcut (Accelerator) ...........................................
16.14.6 Tastenkürzel (Mnemonics) .........................................................
16.14.7 Symbolleisten alias Toolbars ......................................................
16.14.8 Popup-Menüs ............................................................................
16.14.9 System-Tray nutzen ..................................................................
16.15 Das Model-View-Controller-Konzept .......................................................
16.16 Auswahlmenüs, Listen und Spinner ..........................................................
16.16.1 Auswahlmenü (JComboBox) ......................................................
16.16.2 Zuordnung einer Taste mit einem Eintrag ...................................
16.16.3 Datumsauswahl .........................................................................
16.16.4 Listen (JList) ...............................................................................
16.16.5 Drehfeld (JSpinner) ....................................................................
16.17 Texteingabefelder .....................................................................................
16.17.1 Text in einer Eingabezeile ..........................................................
16.17.2 Die Oberklasse der Text-Komponenten (JTextComponent) ........
16.17.3 Geschützte Eingaben (JPasswordField) .......................................
16.17.4 Validierende Eingabefelder (JFormattedTextField) ......................
16.17.5 Einfache mehrzeilige Textfelder (JTextArea) ...............................
16.17.6 Editor-Klasse (JEditorPane) ........................................................
16.18 Tabellen (JTable) ......................................................................................
16.18.1 Ein eigenes Tabellen-Model .......................................................
16.18.2 Basisklasse für eigene Modelle (AbstractTableModel) ................
16.18.3 Vorgefertigtes Standard-Modell (DefaultTableModel) ................
16.18.4 Ein eigener Renderer für Tabellen ..............................................
16.18.5 Zell-Editoren ..............................................................................
16.18.6 Größe und Umrandung der Zellen ..............................................
16.18.7 Spalteninformationen ................................................................
978
978
980
984
985
986
987
989
989
991
991
991
993
994
995
996
997
998
1000
1004
1005
1007
1007
1010
1011
1011
1016
1017
1018
1019
1020
1021
1022
1024
1027
1028
1029
1032
1033
1036
1037
1038
25
1371.book Seite 26 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
16.19
16.20
16.21
16.22
16.23
16.24
16.25
16.26
16.27
16.28
16.29
26
16.18.8 Tabellenkopf von Swing-Tabellen ............................................
16.18.9 Selektionen einer Tabelle .........................................................
16.18.10 Automatisches Sortieren und Filtern mit RowSorter .................
Bäume (JTree) ...........................................................................................
16.19.1 JTree und sein TreeModel und TreeNode .................................
16.19.2 Selektionen bemerken .............................................................
16.19.3 Das TreeModel von JTree ........................................................
JRootPane und JDesktopPane ...................................................................
16.20.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane)
16.20.2 JDesktopPane und die Kinder JInternalFrame ..........................
Dialoge und Window-Objekte ..................................................................
16.21.1 JWindow und JDialog ..............................................................
16.21.2 Modal oder nicht-modal ..........................................................
16.21.3 Standarddialoge mit JOptionPane ............................................
16.21.4 Der Dateiauswahldialog ...........................................................
Flexibles Java-Look-and-Feel ....................................................................
16.22.1 Look and Feel global setzen .....................................................
16.22.2 UIManager ..............................................................................
16.22.3 Windowsoptik mit JGoodies Looks verbessern .........................
Die Zwischenablage (Clipboard) ................................................................
16.23.1 Clipboard-Objekte ...................................................................
16.23.2 Auf den Inhalt zugreifen mit Transferable .................................
16.23.3 DataFlavor ist das Format der Daten in der Zwischenablage .....
16.23.4 Einfügungen in der Zwischenablage erkennen ..........................
16.23.5 Drag & Drop ............................................................................
Undo durchführen ....................................................................................
AWT, Swing und die Threads ....................................................................
16.25.1 Ereignisschlange (EventQueue) und AWT-Event-Thread ...........
16.25.2 Swing ist nicht Thread-sicher ...................................................
16.25.3 invokeLater() und invokeAndWait() .........................................
16.25.4 SwingWorker ...........................................................................
16.25.5 Eigene Ereignisse in die Queue setzen .....................................
16.25.6 Auf alle Ereignisse hören ..........................................................
Barrierefreiheit mit der Java Accessibility API ............................................
Zeitliches Ausführen mit dem javax.swing.Timer .......................................
Alternativen zu AWT und Swing ...............................................................
16.28.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor .......
16.28.2 SWT (Standard Widget Toolkit) ...............................................
Zum Weiterlesen ......................................................................................
1039
1039
1040
1041
1041
1043
1043
1045
1046
1046
1048
1048
1048
1049
1051
1054
1054
1055
1056
1056
1056
1057
1058
1060
1060
1061
1063
1063
1064
1065
1066
1068
1069
1069
1070
1071
1071
1072
1073
1371.book Seite 27 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
17 Grafikprogrammierung ........................................................................ 1075
17.1
17.2
17.3
17.4
17.5
17.6
Grundlegendes zum Zeichnen ...................................................................
17.1.1 Die paint()-Methode für das AWT-Frame ...................................
17.1.2 Zeichnen von Inhalten mit JFrame .............................................
17.1.3 Auffordern zum Neuzeichnen mit repaint() ................................
17.1.4 Grundbegriffe: Koordinaten, Punkte, Pixel .................................
17.1.5 Die ereignisorientierte Programmierung ändert Fensterinhalte ...
17.1.6 Java 2D-API ...............................................................................
Einfache Zeichenmethoden ......................................................................
17.2.1 Linien ........................................................................................
17.2.2 Rechtecke ..................................................................................
17.2.3 Ovale und Kreisbögen ...............................................................
17.2.4 Polygone und Polylines ..............................................................
Zeichenketten schreiben und Fonts ..........................................................
17.3.1 Zeichenfolgen schreiben ............................................................
17.3.2 Die Font-Klasse .........................................................................
17.3.3 Einen neuen Font aus einem gegebenen Font ableiten ...............
17.3.4 Zeichensätze des Systems ermitteln ...........................................
17.3.5 Neue TrueType-Fonts in Java nutzen ..........................................
17.3.6 Font-Metadaten durch FontMetrics ...........................................
Geometrische Objekte ..............................................................................
17.4.1 Die Schnittstelle Shape ..............................................................
17.4.2 Kreisförmiges .............................................................................
17.4.3 Kurviges ....................................................................................
17.4.4 Area und die konstruktive Flächengeometrie .............................
17.4.5 Pfade .........................................................................................
17.4.6 Punkt in einer Form, Schnitt von Linien, Abstand Punkt/Linie ....
Das Innere und Äußere einer Form ...........................................................
17.5.1 Farben und die Paint-Schnittstelle .............................................
17.5.2 Farben mit der Klasse Color .......................................................
17.5.3 Die Farben des Systems über SystemColor .................................
17.5.4 Composite und Xor ....................................................................
17.5.5 Dicke und Art der Linien von Formen bestimmen über Stroke ...
Bilder .......................................................................................................
17.6.1 Eine Übersicht über die Bilder-Bibliotheken ...............................
17.6.2 Bilder mit ImageIO lesen ...........................................................
17.6.3 Ein Bild zeichnen .......................................................................
17.6.4 Programm-Icon/Fenster-Icon setzen ..........................................
17.6.5 Splash-Screen ............................................................................
17.6.6 Bilder im Speicher erzeugen .......................................................
17.6.7 Pixel für Pixel auslesen und schreiben ........................................
17.6.8 Bilder skalieren ..........................................................................
1075
1075
1077
1078
1078
1079
1080
1081
1081
1082
1083
1084
1085
1085
1086
1088
1089
1089
1090
1094
1095
1096
1097
1097
1097
1100
1102
1102
1103
1107
1111
1111
1116
1116
1117
1119
1122
1123
1123
1125
1127
27
1371.book Seite 28 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
17.7
17.8
17.9
17.6.9 Schreiben mit ImageIO ..............................................................
17.6.10 Asynchrones Laden mit getImage() und dem MediaTracker ........
Weitere Eigenschaften von Graphics .........................................................
17.7.1 Eine Kopie von Graphics erstellen ..............................................
17.7.2 Koordinatensystem verschieben .................................................
17.7.3 Beschnitt (Clipping) ...................................................................
17.7.4 Zeichenhinweise durch RenderingHints ......................................
17.7.5 Transformationen mit einem AffineTransform-Objekt .................
Drucken ...................................................................................................
17.8.1 Drucken der Inhalte ...................................................................
17.8.2 Bekannte Drucker ......................................................................
Zum Weiterlesen ......................................................................................
1129
1133
1134
1134
1135
1135
1138
1139
1140
1140
1143
1144
18 Netzwerkprogrammierung .................................................................. 1145
18.1
18.2
18.3
18.4
18.5
18.6
18.7
28
Grundlegende Begriffe ..............................................................................
18.1.1 Internet-Standards und RFC .......................................................
URI und URL ............................................................................................
18.2.1 URI ............................................................................................
18.2.2 Die Klasse URL ..........................................................................
18.2.3 Informationen über eine URL .....................................................
18.2.4 Der Zugriff auf die Daten über die Klasse URL ............................
18.2.5 Verbindungen durch einen Proxy-Server ....................................
Die Klasse URLConnection .......................................................................
18.3.1 Methoden und Anwendung von URLConnection .......................
18.3.2 Protokoll- und Content-Handler ................................................
18.3.3 Im Detail: vom URL zur URLConnection .....................................
18.3.4 Der Protokoll-Handler für Jar-Dateien ........................................
18.3.5 Basic Authentication/Proxy-Authentifizierung ............................
Mit GET und POST Daten übergeben .......................................................
18.4.1 Kodieren der Parameter für Serverprogramme ...........................
18.4.2 Eine Suchmaschine ansprechen ..................................................
Host- und IP-Adressen .............................................................................
18.5.1 Lebt der Rechner? ......................................................................
18.5.2 IP-Adresse des lokalen Hosts .....................................................
18.5.3 Das Netz ist Klasse … ................................................................
NetworkInterface .....................................................................................
Mit dem Socket zum Server ......................................................................
18.7.1 Das Netzwerk ist der Computer .................................................
18.7.2 Sockets ......................................................................................
18.7.3 Eine Verbindung zum Server aufbauen .......................................
18.7.4 Server unter Spannung: die Ströme ............................................
18.7.5 Die Verbindung wieder abbauen ................................................
1145
1145
1146
1146
1146
1149
1150
1152
1153
1153
1155
1156
1157
1159
1160
1161
1162
1163
1165
1166
1167
1167
1168
1168
1168
1169
1170
1171
1371.book Seite 29 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
18.8
18.9
18.10
18.11
18.12
18.13
18.14
18.7.6 Informationen über den Socket ..................................................
18.7.7 Reine Verbindungsdaten über SocketAddress ............................
Client-Server-Kommunikation ..................................................................
18.8.1 Warten auf Verbindungen ..........................................................
18.8.2 Ein Multiplikationsserver ...........................................................
18.8.3 Blockierendes Lesen ..................................................................
18.8.4 Von außen erreichbar sein .........................................................
Apache Jakarta Commons HttpClient und Net ..........................................
18.9.1 Jakarta Commons HttpClient ......................................................
18.9.2 Jakarta Commons Net ................................................................
Arbeitsweise eines Webservers .................................................................
18.10.1 Das Hypertext Transfer Protocol (HTTP) .....................................
18.10.2 Anfragen an den Server ..............................................................
18.10.3 Die Antworten vom Server .........................................................
18.10.4 Webserver mit com.sun.net.httpserver.HttpServer .....................
Datagram-Sockets ....................................................................................
18.11.1 Die Klasse DatagramSocket ........................................................
18.11.2 Datagramme und die Klasse DatagramPacket ............................
18.11.3 Auf ein hereinkommendes Paket warten ....................................
18.11.4 Ein Paket zum Senden vorbereiten .............................................
18.11.5 Methoden der Klasse DatagramPacket .......................................
18.11.6 Das Paket senden ......................................................................
E-Mail ......................................................................................................
18.12.1 Wie eine E-Mail um die Welt geht .............................................
18.12.2 Das Simple Mail Transfer Protocol und RFC 822 ........................
18.12.3 POP (Post Office Protocol) .........................................................
18.12.4 Die JavaMail API .......................................................................
18.12.5 E-Mails mittels POP3 abrufen ....................................................
18.12.6 E-Mails versenden .....................................................................
18.12.7 Ereignisse und Suchen ...............................................................
Tiefer liegende Netzwerkeigenschaften .....................................................
18.13.1 Internet Control Message Protocol (ICMP) .................................
18.13.2 MAC-Adresse ............................................................................
Zum Weiterlesen ......................................................................................
1171
1172
1173
1174
1175
1178
1179
1179
1180
1180
1181
1181
1181
1184
1187
1189
1190
1192
1192
1193
1194
1195
1196
1196
1196
1197
1197
1198
1201
1203
1204
1204
1204
1205
19 Verteilte Programmierung mit RMI und Web-Services ...................... 1207
19.1
19.2
Entfernte Objekte und Methoden .............................................................
19.1.1 Stellvertreter helfen bei entfernten Methodenaufrufen ..............
19.1.2 Standards für entfernte Objekte .................................................
Java Remote Method Invocation ..............................................................
19.2.1 Zusammenspiel von Server, Registry und Client .........................
19.2.2 Wie die Stellvertreter die Daten übertragen ...............................
1207
1207
1209
1209
1209
1209
29
1371.book Seite 30 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
19.3
19.4
19.5
19.6
19.7
19.8
19.9
19.2.3 Probleme mit entfernten Methoden .......................................... 1210
19.2.4 Nutzen von RMI bei Middleware-Lösungen ............................... 1211
19.2.5 Zentrale Klassen und Schnittstellen ............................................ 1212
19.2.6 Entfernte und lokale Objekte im Vergleich ................................. 1213
Auf der Serverseite ................................................................................... 1213
19.3.1 Entfernte Schnittstelle deklarieren ............................................. 1213
19.3.2 Remote-Objekt-Implementierung .............................................. 1214
19.3.3 Stellvertreterobjekte .................................................................. 1215
19.3.4 Der Namensdienst (Registry) ...................................................... 1215
19.3.5 Remote-Objekt-Implementierung exportieren und beim
Namensdienst anmelden ............................................................ 1217
19.3.6 Einfaches Logging ...................................................................... 1219
19.3.7 Aufräumen mit dem DGC .......................................................... 1220
Auf der Clientseite .................................................................................... 1220
Entfernte Objekte übergeben und laden ................................................... 1221
19.5.1 Klassen vom RMI-Klassenlader nachladen .................................. 1222
Weitere Eigenschaften von RMI ................................................................ 1222
19.6.1 RMI und CORBA ........................................................................ 1222
19.6.2 RMI über HTTP getunnelt .......................................................... 1223
19.6.3 Automatische Remote-Objekt-Aktivierung ................................. 1223
Daily Soap ................................................................................................ 1224
19.7.1 SOAP-Protokoll ......................................................................... 1224
19.7.2 Die technische Realisierung ....................................................... 1225
19.7.3 SOAP-Implementierungen ......................................................... 1225
19.7.4 @WebService in Java 6 ............................................................. 1226
19.7.5 Einen Web-Service definieren .................................................... 1226
19.7.6 Web-Services veröffentlichen ..................................................... 1227
19.7.7 Einen JAX-WS-Client implementieren ........................................ 1228
Java Message Service (JMS) ...................................................................... 1229
Zum Weiterlesen ...................................................................................... 1230
20 JavaServer Pages und Servlets ............................................................ 1231
20.1
20.2
30
Dynamisch generierte Webseiten .............................................................
20.1.1 Was sind Servlets? .....................................................................
20.1.2 Was sind JavaServer Pages? ........................................................
Servlets und JSPs mit Tomcat entwickeln ..................................................
20.2.1 Servlet-Container .......................................................................
20.2.2 Entwicklung der Servlet-/JSP-Spezifikationen .............................
20.2.3 Webserver mit Servlet-Funktionalität .........................................
20.2.4 Tomcat installieren ....................................................................
20.2.5 Ablageort für eigene JSPs ...........................................................
20.2.6 Web-Applikationen ...................................................................
1231
1231
1232
1233
1233
1234
1234
1234
1235
1236
1371.book Seite 31 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
20.2.7
Zuordnung von Web-Applikationen zu physikalischen
Verzeichnissen ...........................................................................
20.2.8 Web-Projekt mit Eclipse IDE for Java EE Developers ..................
20.3 Statisches und Dynamisches .....................................................................
20.3.1 Statischer Template-Code ..........................................................
20.3.2 Dynamische Inhalte ...................................................................
20.3.3 Kommentare ..............................................................................
20.4 Die Expression Language (EL) ...................................................................
20.4.1 Operatoren der EL .....................................................................
20.4.2 Literale ......................................................................................
20.4.3 Implizite EL-Objekte ..................................................................
20.5 Formulardaten ..........................................................................................
20.5.1 Einen Parameter auslesen ..........................................................
20.5.2 HTML-Formulare .......................................................................
20.6 Auf Beans zurückgreifen ...........................................................................
20.6.1 Beans in JSPs anlegen ................................................................
20.6.2 Properties einer Bean im EL-Ausdruck erfragen ..........................
20.6.3 Properties mit <jsp:setProperty> setzen .....................................
20.6.4 Bean-Klasse zum Testen von E-Mail-Adressen ...........................
20.6.5 Parameterwerte in Bean übertragen ...........................................
20.7 JSP-Tag-Libraries ......................................................................................
20.7.1 Standard Tag Library (JSTL) ........................................................
20.8 Einbinden und Weiterleiten ......................................................................
20.8.1 Einbinden von Inhalten ..............................................................
20.8.2 Forward und Redirect ................................................................
20.8.3 Applets einbinden .....................................................................
20.9 Scripting-Elemente in JSPs ........................................................................
20.9.1 Scriptlets ...................................................................................
20.9.2 JSP-Ausdrücke ...........................................................................
20.9.3 JSP-Deklarationen ......................................................................
20.9.4 Quoting .....................................................................................
20.9.5 Entsprechende XML-Tags ..........................................................
20.9.6 Implizite Objekte für Scriptlets und JSP-Ausdrücke ....................
20.10 JSP-Direktiven ..........................................................................................
20.10.1 page-Direktiven im Überblick ....................................................
20.10.2 Mit JSPs Bilder generieren .........................................................
20.11 Sitzungsverfolgung (Session Tracking) .......................................................
20.11.1 Lösungen für Sitzungsverfolgung ................................................
20.11.2 Auf Session-Dateien zurückgreifen .............................................
20.12 Servlets ....................................................................................................
20.12.1 Servlets compilieren ...................................................................
20.12.2 Servlet-Mapping ........................................................................
1237
1237
1238
1238
1239
1239
1240
1240
1241
1241
1242
1242
1242
1244
1244
1244
1244
1245
1246
1247
1247
1251
1251
1252
1253
1253
1254
1254
1254
1255
1255
1255
1256
1256
1257
1258
1259
1260
1260
1261
1262
31
1371.book Seite 32 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
20.12.3 Der Lebenszyklus eines Servlets .................................................
20.12.4 Mehrere Anfragen beim Servlet und die Thread-Sicherheit ........
20.12.5 Servlets und Sessions .................................................................
20.12.6 Weiterleiten und Einbinden von Servlet-Inhalten .......................
20.13 Zum Weiterlesen ......................................................................................
1263
1263
1263
1264
1265
21 Applets ................................................................................................ 1267
21.1
21.2
21.3
Applets in der Wiege von Java ..................................................................
21.1.1 (J)Applet und Applikationen ......................................................
21.1.2 Das erste Hallo-Applet ...............................................................
21.1.3 HTML Converter ........................................................................
21.1.4 Fehler in Applets finden .............................................................
Die Applet-API .........................................................................................
21.2.1 Die Zyklen eines Applets ............................................................
21.2.2 Parameter an das Applet übergeben ..........................................
21.2.3 Wie das Applet den Browser-Inhalt ändern kann .......................
21.2.4 Den Ursprung des Applets erfragen ............................................
21.2.5 Datenaustausch zwischen Applets ..............................................
21.2.6 Was ein Applet alles darf ...........................................................
21.2.7 Ist Java im Browser aktiviert? .....................................................
21.2.8 Applet unter Netscape oder Microsoft Internet Explorer? ..........
Webstart ..................................................................................................
1267
1268
1268
1270
1272
1272
1272
1272
1274
1274
1275
1278
1279
1279
1280
22 Midlets und die Java ME ..................................................................... 1283
22.1
22.2
22.3
22.4
22.5
22.6
Java Platform, Micro Edition (Java ME) .....................................................
Konfigurationen .......................................................................................
22.2.1 Connected Limited Device Configuration (CLDC) .......................
22.2.2 Connected Device Configuration (CDC) ......................................
Profile ......................................................................................................
22.3.1 Mobile Information Device Profile (MIDP) .................................
22.3.2 Weitere Profile ..........................................................................
Wireless Toolkits ......................................................................................
22.4.1 Sun Java Wireless Toolkit for CLDC ............................................
22.4.2 Eclipse-Plugin ............................................................................
Die Midlet-API .........................................................................................
22.5.1 Paketstruktur Mobile Information Device Profile (2.0) ...............
Zum Weiterlesen ......................................................................................
1283
1283
1284
1284
1284
1285
1285
1285
1285
1286
1289
1289
1290
23 Datenbankmanagement mit JDBC ...................................................... 1291
23.1
32
Das relationale Modell ............................................................................. 1291
1371.book Seite 33 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
23.2
23.3
23.4
23.5
23.6
23.7
23.8
23.9
23.10
23.11
23.12
23.13
Datenbanken und Tools ...........................................................................
23.2.1 HSQLDB ....................................................................................
23.2.2 Weitere Datenbanken ................................................................
23.2.3 Eclipse-Plugins zum Durchschauen von Datenbanken ................
JDBC und Datenbanktreiber .....................................................................
23.3.1 Treibertypen ..............................................................................
23.3.2 JDBC-Versionen .........................................................................
Eine Beispielabfrage .................................................................................
23.4.1 Schritte zur Datenbankabfrage ...................................................
23.4.2 Client für HSQLDB-Datenbank ...................................................
Mit Java an eine Datenbank andocken .....................................................
23.5.1 Der Treiber-Manager .................................................................
23.5.2 Den Treiber laden ......................................................................
23.5.3 Eine Aufzählung aller Treiber .....................................................
23.5.4 Log-Informationen .....................................................................
23.5.5 Verbindung zur Datenbank auf- und abbauen ............................
23.5.6 DataSource ................................................................................
23.5.7 Gepoolte Verbindungen .............................................................
Datenbankabfragen ..................................................................................
23.6.1 Abfragen über das Statement-Objekt .........................................
23.6.2 Ergebnisse einer Abfrage in ResultSet ........................................
23.6.3 Java und SQL-Datentypen ..........................................................
23.6.4 Unicode in der Spalte korrekt auslesen ......................................
23.6.5 Eine SQL-NULL und wasNull() bei ResultSet ..............................
23.6.6 Wie viele Zeilen hat ein ResultSet? ............................................
Die Ausnahmen bei JDBC .........................................................................
Elemente einer Datenbank hinzufügen und aktualisieren ..........................
23.8.1 Batch-Updates ...........................................................................
ResultSets in Bohnen durch RowSet .........................................................
23.9.1 Die Schnittstelle RowSet ............................................................
23.9.2 Implementierungen von RowSet ................................................
23.9.3 Der Typ CachedRowSet .............................................................
23.9.4 Der Typ WebRowSet .................................................................
Vorbereitete Anweisungen (Prepared Statements) ....................................
23.10.1 PreparedStatement-Objekte vorbereiten ....................................
23.10.2 Werte für die Platzhalter eines PreparedStatement ....................
Transaktionen ...........................................................................................
Metadaten ...............................................................................................
23.12.1 Metadaten über die Tabelle .......................................................
23.12.2 Informationen über die Datenbank ............................................
Einführung in SQL ....................................................................................
23.13.1 Ein Rundgang durch SQL-Abfragen ............................................
1292
1292
1293
1295
1297
1298
1299
1300
1300
1301
1302
1303
1303
1304
1305
1305
1308
1310
1311
1311
1313
1314
1317
1318
1318
1319
1320
1320
1322
1322
1322
1323
1324
1326
1326
1327
1328
1329
1329
1332
1333
1334
33
1371.book Seite 34 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
23.13.2 Datenabfrage mit der Data Query Language (DQL) .................... 1335
23.13.3 Tabellen mit der Data Definition Language (DDL) anlegen ......... 1337
23.14 Zum Weiterlesen ...................................................................................... 1337
24 Reflection und Annotationen .............................................................. 1339
24.1
24.2
24.3
24.4
24.5
24.6
24.7
34
Metadaten ...............................................................................................
24.1.1 Metadaten durch JavaDoc-Tags .................................................
Metadaten der Klassen mit dem Class-Objekt ...........................................
24.2.1 An ein Class-Objekt kommen .....................................................
24.2.2 Was das Class-Objekt beschreibt ...............................................
24.2.3 Der Name der Klasse .................................................................
24.2.4 instanceof mit Class-Objekten ....................................................
24.2.5 Oberklassen finden ....................................................................
24.2.6 Implementierte Interfaces einer Klasse oder eines Interfaces ......
24.2.7 Modifizierer und die Klasse Modifier .........................................
24.2.8 Die Arbeit auf dem Feld .............................................................
Attribute, Methoden und Konstruktoren ..................................................
24.3.1 Reflections – Gespür für Attribute einer Klasse ...........................
24.3.2 Methoden einer Klasse erfragen .................................................
24.3.3 Properties einer Bean erfragen ...................................................
24.3.4 Konstruktoren einer Klasse ........................................................
24.3.5 Annotationen ............................................................................
Objekte erzeugen und manipulieren .........................................................
24.4.1 Objekte erzeugen ......................................................................
24.4.2 Die Belegung der Variablen erfragen ..........................................
24.4.3 Eine generische toString()-Funktion ...........................................
24.4.4 Variablen setzen ........................................................................
24.4.5 Private Attribute ändern ............................................................
Methoden aufrufen ..................................................................................
24.5.1 Statische Methoden aufrufen .....................................................
24.5.2 Dynamische Methodenaufrufe bei festen Methoden
beschleunigen ............................................................................
Annotationen ...........................................................................................
24.6.1 Neue Annotationen definieren ...................................................
24.6.2 Annotationen mit genau einem Element ....................................
24.6.3 Beliebige Schlüssel-Werte-Paare ................................................
24.6.4 Vorbelegte Elemente .................................................................
24.6.5 Annotieren von Annotationstypen .............................................
24.6.6 Annotationen zur Laufzeit auslesen ............................................
24.6.7 Mögliche Nachteile von Annotationen .......................................
24.6.8 XDoclet .....................................................................................
Zum Weiterlesen ......................................................................................
1339
1339
1340
1340
1342
1344
1346
1347
1348
1348
1350
1351
1351
1354
1358
1358
1360
1361
1361
1362
1364
1366
1368
1368
1369
1370
1372
1372
1372
1374
1377
1378
1380
1382
1383
1384
1371.book Seite 35 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
25 Logging und Monitoring ..................................................................... 1385
25.1
25.2
25.3
25.4
25.5
25.6
25.7
Logging mit Java .......................................................................................
25.1.1 Logging-APIs .............................................................................
25.1.2 Logging mit log4j .......................................................................
Überwachen von Systemzuständen ...........................................................
MBean-Typen, MBean-Server und weitere Begriffe ...................................
25.3.1 MXBeans des Systems ................................................................
Geschwätzige Programme und JConsole ...................................................
25.4.1 JConsole ....................................................................................
Der MBeanServer .....................................................................................
Eine eigene Standard-MBean ....................................................................
25.6.1 Management-Schnittstelle .........................................................
25.6.2 Implementierung der Managed-Ressource .................................
25.6.3 Anmeldung beim Server .............................................................
25.6.4 Eigene Bean in JConsole ............................................................
Zum Weiterlesen ......................................................................................
1385
1385
1386
1388
1389
1390
1392
1392
1393
1395
1395
1395
1396
1396
1399
26 Sicherheitskonzepte ............................................................................ 1401
26.1
26.2
26.3
26.4
26.5
26.6
Zentrale Elemente der Java-Sicherheit ......................................................
26.1.1 Security-API der Java SE .............................................................
26.1.2 Cryptographic Service Providers .................................................
Der Sandkasten (Sandbox) ........................................................................
Sicherheitsmanager (Security Manager) ....................................................
26.3.1 Der Sicherheitsmanager bei Applets ...........................................
26.3.2 Sicherheitsmanager aktivieren ....................................................
26.3.3 Rechte durch Policy-Dateien vergeben ......................................
26.3.4 Erstellen von Rechtedateien mit dem grafischen Policy-Tool ......
26.3.5 Kritik an den Policies .................................................................
Signierung ................................................................................................
26.4.1 Warum signieren? ......................................................................
26.4.2 Digitale Ausweise und die Zertifizierungsstelle ...........................
26.4.3 Mit keytool Schlüssel erzeugen ..................................................
26.4.4 Signieren mit jarsigner ...............................................................
Digitale Unterschriften .............................................................................
26.5.1 Die MDx-Reihe ..........................................................................
26.5.2 Secure Hash Algorithm (SHA) .....................................................
26.5.3 Mit der Security-API einen Fingerabdruck berechnen ................
26.5.4 Die Klasse MessageDigest ..........................................................
Verschlüsseln von Daten(-strömen) ..........................................................
26.6.1 Den Schlüssel bitte ....................................................................
1401
1401
1402
1403
1404
1405
1406
1408
1410
1410
1412
1412
1412
1413
1414
1414
1415
1415
1416
1416
1418
1418
35
1371.book Seite 36 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
26.7
26.6.2 Verschlüsseln mit Cipher ............................................................ 1420
26.6.3 Verschlüsseln von Datenströmen ............................................... 1420
Zum Weiterlesen ...................................................................................... 1421
27 Java Native Interface (JNI) .................................................................. 1423
27.1
27.2
27.3
27.4
27.5
27.6
Java Native Interface und Invocation-API .................................................
Einbinden einer C-Funktion in ein Java-Programm ....................................
27.2.1 Schreiben des Java-Codes ..........................................................
27.2.2 Compilieren des Java-Programms ...............................................
27.2.3 Erzeugen der Header-Datei ........................................................
27.2.4 Implementierung der Funktion in C ...........................................
27.2.5 Übersetzen der C-Programme und Erzeugen der dynamischen
Bibliothek ..................................................................................
27.2.6 Suchort der dynamischen Bibliothek ..........................................
Nativ die Stringlänge ermitteln .................................................................
Erweiterte JNI-Eigenschaften ....................................................................
27.4.1 Klassendefinitionen ....................................................................
27.4.2 Zugriff auf Attribute ...................................................................
Einfache Anbindung von existierenden Bibliotheken .................................
27.5.1 C++ Klassen ansprechen ............................................................
27.5.2 COM-Schnittstellen anzapfen ....................................................
Zum Weiterlesen ......................................................................................
1423
1424
1424
1425
1425
1426
1427
1429
1429
1430
1430
1431
1433
1433
1433
1434
28 Dienstprogramme für die Java-Umgebung ......................................... 1435
28.1
28.2
28.3
28.4
28.5
36
Die Werkzeuge im Überblick ....................................................................
Java-Compiler ...........................................................................................
28.2.1 Bytecode-Compiler javac ...........................................................
28.2.2 Native Compiler .........................................................................
28.2.3 Java-Programme in ein natives ausführbares Programm
einpacken ..................................................................................
Der Java-Interpreter java ..........................................................................
28.3.1 Der Unterschied zwischen java.exe und javaw.exe .....................
Das Archivformat Jar ................................................................................
28.4.1 Das Dienstprogramm Jar benutzen .............................................
28.4.2 Das Manifest .............................................................................
28.4.3 Applikationen in Jar-Archiven starten ........................................
28.4.4 Applets in Jar-Archiven ..............................................................
Monitoringprogramme .............................................................................
28.5.1 jps .............................................................................................
28.5.2 jstat ...........................................................................................
28.5.3 jmap ..........................................................................................
28.5.4 jstack .........................................................................................
1435
1435
1435
1436
1437
1437
1439
1439
1440
1442
1442
1443
1444
1444
1444
1445
1445
1371.book Seite 37 Mittwoch, 17. Dezember 2008 1:39 13
Inhalt
28.6
28.7
28.8
Ant ...........................................................................................................
28.6.1 Bezug und Installation von Ant ..................................................
28.6.2 Properties ..................................................................................
28.6.3 Externe und vordefinierte Properties ..........................................
28.6.4 Weitere Ant-Tasks .....................................................................
28.6.5 Das Obfuscator-Programm ProGuard .........................................
Weitere Dienstprogramme .......................................................................
28.7.1 Sourcecode Beautifier ................................................................
28.7.2 Java-Programme als Systemdienst ausführen ..............................
Zum Weiterlesen ......................................................................................
1446
1446
1448
1449
1449
1450
1451
1451
1452
1453
Index ........................................................................................................................... 1455
37
1371.book Seite 55 Mittwoch, 17. Dezember 2008 1:39 13
Wir produzieren heute Informationen en masse, so wie früher Autos.
– John Naisbitt
1
Java ist auch eine Sprache
1.1
Der erste Kontakt
Java ist mittlerweile zum Modewort geworden und in aller Munde – doch nicht so sehr, weil
Java1 eine schöne Insel, eine reizvolle Wandfarbe oder eine Pinte mit brasilianischen Rhythmen in Paris ist, sondern vielmehr, weil es sich um eine robuste objektorientierte Programmiersprache mit einem großen Satz von Bibliotheken handelt. Um im Mainstream der Softwareentwicklung unter den vielen konkurrierenden Sprachen die bevorzugte Sprache zu sein,
muss Java schon einiges zu bieten haben, insbesondere wenn über 6 Millionen Softwareentwickler mit der Sprache ihre Brötchen verdienen und es 10 Millionen Downloads von
Suns Laufzeitumgebung in der Woche gibt.2 Im ersten Kapitel sollen daher kurz die wesentlichen Konzepte der »Internetprogrammiersprache« vorgestellt werden.
1.2
Historischer Hintergrund
In den 1970er Jahren wollte Bill Joy eine Programmiersprache schaffen, die alle Vorteile von
MESA und C vereinigt. Diesen Wunsch konnte sich Joy zunächst nicht erfüllen, und erst
Anfang der 1990er Jahre beschrieb er in dem Artikel »Further«, wie eine neue objektorientierte Sprache aussehen könnte; sie sollte in den Grundzügen auf C++ aufbauen. Erst später
wurde ihm bewusst, dass C++ als Basissprache ungeeignet und für große Programme unhandlich ist.
Zu jener Zeit arbeitete James Gosling am SGML-Editor »Imagination«. Er entwickelte in C++
und war mit dieser Sprache ebenfalls nicht zufrieden. Aus diesem Unmut heraus entstand die
neue Sprache Oak. Der Name fiel Gosling ein, als er aus dem Fenster seines Arbeitsraums
schaute – und eine Eiche erblickte (engl. oak). Doch vielleicht ist das nur eine Legende. Patrick
Naughton startete im Dezember 1990 das Green-Projekt, in das Gosling und Mike Sheridan
involviert waren. Überbleibsel aus dem Green-Projekt ist der Duke, der zum bekannten Symbol wurde.3
1 Nicht wieder ein anderes Akronym (Just Another Vague Acronym).
2 Quelle: http://de.sun.com/sunnews/events/2007/20071203/pdf/TD_FRA_GoslingKeynote.pdf
3 Er sieht ein bisschen wie ein Zahn aus und könnte deshalb auch die Werbung eines Zahnarztes sein. Das
Design stammt übrigens von Joe Palrang.
55
1371.book Seite 56 Mittwoch, 17. Dezember 2008 1:39 13
1
Java ist auch eine Sprache
Die Idee hinter diesem Projekt war die Entwicklung von Software für interaktives Fernsehen und andere Geräte der Konsumelektronik. Bestandteile dieses Projekts waren das
Betriebssystem Green-OS, Goslings Interpreter Oak und
einige Hardwarekomponenten. Joy zeigte den Mitgliedern
des Green-Projekts seinen Further-Aufsatz und begann mit
der Implementierung einer grafischen Benutzeroberfläche.
Gosling schrieb den Originalcompiler in C, und anschließend entwarfen Naughton, Gosling
und Sheridan den Runtime-Interpreter ebenfalls in C – die Sprache C++ kam nie zum Einsatz.
Oak führte die ersten Programme im August 1991 aus. So entwickelte das Green-Dream-Team
ein Gerät mit der Bezeichnung *7 (Star Seven), das es im Herbst 1992 intern vorstellte. SunChef Scott McNealy war von *7 beeindruckt, und aus dem Team wurde im November die
Firma First Person, Inc. Nun ging es um die Vermarktung von Star Seven.
Anfang 1993 hörte das Team von einer Anfrage von Time Warner bezüglich eines Systems für
Set-Top-Boxen. (Set-Top-Boxen sind elektronische Geräte für Endbenutzer.) First Person richtete den Blick vom Consumer-Markt auf die Set-Top-Boxen. Leider zeigte sich Time Warner
später nicht mehr interessiert, aber First Person entwickelte (sich) weiter. Nach vielen Richtungswechseln konzentrierte sich die Entwicklung auf das World Wide Web (kurz Web
genannt, selten W3). Die Programmiersprache sollte Programmcode über das Netzwerk empfangen können, und fehlerhafte Programme sollten keinen Schaden anrichten. Damit konnten
die meisten Konzepte aus C(++) schon abgehakt werden – Zugriffe über ungültige Zeiger, die
wild den Speicher beschreiben, sind ein Beispiel. Die Mitglieder des ursprünglichen Projektteams erkannten, dass Oak alle Eigenschaften aufwies, die nötig waren, um es im Web einzusetzen – perfekt, obwohl ursprünglich für einen ganz anderen Zweck entwickelt. Die Sprache
Oak erhielt den Namen »Java«, da der Name »Oak«, wie sich später herausstellte, aus Gründen
des Copyrights nicht verwendet werden konnte: Eine andere Programmiersprache schmückte
sich bereits mit diesem Namen. Nach der Überlieferung fiel die Entscheidung für den Namen
Java in einem Coffeeshop. In Java führte Patrick Naughton den Prototyp des Browsers
»WebRunner« vor, der an einem Wochenende entstanden sein soll. Nach geringfügiger Überarbeitung durch Jonathan Payne wurde der Browser »HotJava« getauft und im Mai auf der
SunWorld ’95 der Öffentlichkeit vorgestellt.
Zunächst konnten sich nur wenige Anwender mit HotJava anfreunden. So war es ein großes
Glück, dass Netscape sich entschied, die Java-Technologie zu lizenzieren. Sie wurde in der
Version 2.0 des Netscape Navigators implementiert. Der Navigator kam im Dezember 1995
auf den Markt. Im Januar 1996 wurde das JDK 1.0 freigegeben, was den Programmierern die
erste Möglichkeit gab, Java-Applikationen und Web-Applets (Applet: »A Mini Application«)
zu programmieren. Kurz vor der Fertigstellung des JDK 1.0 gründeten die verbliebenen Mitglieder des Green-Teams die Firma JavaSoft. Und so begann der Siegeszug.
56
1371.book Seite 57 Mittwoch, 17. Dezember 2008 1:39 13
Eigenschaften von Java
1.3
Eigenschaften von Java
Java ist eine objektorientierte Programmiersprache, die sich durch einige zentrale Eigenschaften auszeichnet. Diese machen sie universell einsetzbar und für die Industrie als robuste Programmiersprache interessant. Da Java objektorientiertes Programmieren ermöglicht, können
Entwickler moderne und wiederverwertbare Softwarekomponenten programmieren.
1.3.1
Bytecode und die virtuelle Maschine
Zunächst ist Java eine Programmiersprache wie jede andere. Doch im Gegensatz zu herkömmlichen Übersetzern einer Programmiersprache, die Maschinencode für eine spezielle Plattform und einen bestimmten Prozessor generieren, erzeugt der Java-Compiler Programmcode,
den so genannten Bytecode, für eine virtuelle Maschine. Bytecode ist vergleichbar mit Mikroprozessorcode für einen erdachten Prozessor, der Anweisungen wie arithmetische Operationen, Sprünge und weiteres kennt. Der Java-Compiler von Sun und der Java-Compiler der Entwicklungsumgebung Eclipse sind selbst in Java implementiert und generieren diesen
Bytecode. (Es gibt aber auch Java-Compiler in C++, wie den Jikes-Compiler4.)
Damit der Programmcode des virtuellen Prozessors ausgeführt werden kann, führt nach der
Übersetzungsphase die Laufzeitumgebung (auch Runtime-Interpreter genannt), die Java Virtual Machine (JVM), den Bytecode aus.5 Somit ist Java eine compilierte, aber auch interpretierte Programmiersprache – von der Hardwaremethode einmal abgesehen.
4 http://tutego.com/go/jikes
5 Die Idee des Bytecodes (FrameMaker schlägt hier als Korrekturvorschlag »Bote Gottes« vor) ist schon alt.
Die Firma Datapoint schuf um 1970 die Programmiersprache PL/B, die Programme auf Bytecode abbildet.
Auch verwendet die Originalimplementierung von UCSD-Pascal, die etwa Anfang 1980 entstand, einen
Zwischencode – kurz p-code.
57
1.3
1371.book Seite 58 Mittwoch, 17. Dezember 2008 1:39 13
1
Java ist auch eine Sprache
Das pure Interpretieren bereitet natürlich Geschwindigkeitsprobleme, da das Erkennen,
Dekodieren und Ausführen der Befehle Zeit kostet. Java-Programme der ersten Stunde waren
deutlich langsamer als übersetzte C(++)-Programme. Die Technik der Just-in-Time-(JIT-)Compiler6 löste das Problem. Ein JIT-Compiler beschleunigt die Ausführung der Programme,
indem er zur Laufzeit die Programmanweisungen der virtuellen Maschine in Maschinencode
der jeweiligen Plattform übersetzt. Anschließend steht ein an die Architektur angepasstes Programm im Speicher, das der physikalische Prozessor ohne Interpretation schnell ausführt. Mit
dieser Technik entspricht die Geschwindigkeit der anderer übersetzter Sprachen.
Java on a chip
Neben einer Laufzeitumgebung, die den Java-Bytecode interpretiert und in den Maschinencode eines Wirtssystems übersetzt, wurde auch ein Prozessor in Silizium gegossen, der in der
Hardware Bytecode ausführt. Die Entwicklung ging verstärkt von Sun aus, und einer der ersten Prozessoren war PicoJava. Bei der Entwicklung des Prozessors stand nicht die maximale
Geschwindigkeit im Vordergrund, sondern die Kosten pro Chip, um ihn in jedes Haushaltsgerät einbauen zu können. Das Interesse an Java auf einem Chip zieht nach einer Flaute wieder
an, denn viele mobile Endgeräte wollen mit schnellen Ausführungseinheiten versorgt werden.
Die ARM-Technologie des Unternehmens ARM Limited erlaubt über Jazelle DBX eine sehr
schnelle Ausführung von Java-Bytecode. Mit dem Prozessor S5L8900 hat Samsung die ARMTechnologie ARM1176JZ(F)-S zusammen mit Speicherschnittstellen und Teile für Connectivity, Peripherie und Multimedia-Möglichkeiten in Silizium gegossen, und als 667-MHz-Prozessor sitzt er nun in Apples iPhone. Ironie des Schicksals ist jedoch, dass Apple im iPhone bisher keine Java-Unterstützung vorsieht.
Der aJ-100 von aJile Systems Inc. ist ein weiterer Prozessor. Und wenn wir den Pressemitteilungen von Azul Systems7 glauben können, gibt es auch bald einen 64-Bit-Prozessor mit 48
Kernen, der Java- und auch .NET-Bytecode ausführt. Ein Doppelherz tut auch Java gut.
1.3.2
Objektorientierung in Java
Die Sprache Java ist nicht bis zur letzten Konsequenz objektorientiert, so wie Smalltalk es vorbildlich demonstriert. Primitive Datentypen wie Ganzzahlen oder Fließkommazahlen werden
nicht als Objekte verwaltet. Der Design-Grund war vermutlich, dass der Compiler und die
Laufzeitumgebung mit der Trennung besser in der Lage waren, die Programme zu optimieren.
Allerdings zeigt die virtuelle Maschine von Microsoft für die .NET-Plattform deutlich, dass
auch ohne die Trennung eine gute Performance möglich ist.
Java ist als Sprache entworfen worden, die es einfach machen soll, fehlerfreie Software zu
schreiben. In C-Programmen erwartet uns statistisch gesehen alle 55 Programmzeilen ein Fehler. Selbst in großen Softwarepaketen (ab einer Million Codezeilen) findet sich, unabhängig
6 Diese Idee ist auch schon alt: HP hatte um 1970 JIT-Compiler für BASIC-Maschinen.
7 http://www.azulsystems.com/
58
1371.book Seite 59 Mittwoch, 17. Dezember 2008 1:39 13
Eigenschaften von Java
von der zugrundeliegenden Programmiersprache, im Schnitt alle 200 Programmzeilen ein
Fehler. Selbstverständlich gilt es, diese Fehler zu beheben, obwohl bis heute noch keine
umfassende Strategie für die Softwareentwicklung im Großen gefunden wurde. Viele Arbeiten der Informatik beschäftigen sich mit der Frage, wie Tausende Programmierer über Jahrzehnte miteinander arbeiten und Software entwerfen können. Dieses Problem ist nicht einfach zu lösen und wurde im Zuge der Softwarekrise in den 1960er Jahren heftig diskutiert.
1.3.3
Java-Security-Modell
Das Java-Security-Modell gewährleistet den sicheren Programmablauf auf den verschiedensten Ebenen. Der Verifier liest Code und überprüft die strukturelle Korrektheit und Typsicherheit. Der Klassenlader (engl. class loader) lädt Dateien entweder von einem externen Medium
wie der Festplatte oder auch einem Netzwerk und überträgt die Java-Binärdaten zum Interpreter. Dort überwacht ein Security-Manager Zugriffe auf das Dateisystem, die NetzwerkPorts, externe Prozesse und die Systemressourcen. Treten Sicherheitsprobleme auf, werden
diese durch Exceptions zur Laufzeit gemeldet. Das Sicherheitsmodell ist vom Programmierer
erweiterbar.
1.3.4
Zeiger und Referenzen
In Java gibt es keine Zeiger (engl. pointer), wie sie aus anderen Programmiersprachen bekannt
und gefürchtet sind. Da eine objektorientierte Programmiersprache ohne Verweise aber nicht
funktioniert, werden Referenzen eingeführt. Eine Referenz repräsentiert ein Objekt, und eine
Variable speichert diese Referenz. Die Referenz hat einen Typ, der sich nicht ändern kann. Ein
Auto bleibt ein Auto und kann nicht als Laminiersystem angesprochen werden. Eine Referenz
unter Java ist nicht als Zeiger auf Speicherbereiche zu verstehen.
Beispiel Das folgende Programm zeigt, dass das Pfuschen in C++ leicht möglich ist und wir
Zugriff auf private Elemente über eine Zeigerarithmetik bekommen können. Für uns Java-Programmierer ist dies ein abschreckendes Beispiel.
#include <string.h>
#include <iostream.h>
class Ganz_unsicher {
public:
Ganz_unsicher() { strcpy(passwort, "geheim"); }
private:
char passwort[100];
};
void main()
{
Ganz_unsicher gleich_passierts;
char *boesewicht = (char*)&gleich_passierts;
cout << "Passwort: " << boesewicht << endl;
}
59
1.3
1371.book Seite 1455 Mittwoch, 17. Dezember 2008 1:39 13
Index
#ifdef 61
#IMPLIED 861
#REQUIRED 860
$, innere Klasse 492, 497
%%, Format-Spezifizierer 291
%, Modulo-Operator 117
%, Operator 312
%b, Format-Spezifizierer 291
%c, Format-Spezifizierer 291
%d, Format-Spezifizierer 291
%e, Format-Spezifizierer 291
%f, Format-Spezifizierer 291
%n, Format-Spezifizierer 291
%s, Format-Spezifizierer 291
%t, Format-Spezifizierer 291
%tD, Format-Spezifizierer 735
%tR, Format-Spezifizierer 735
%tT, Format-Spezifizierer 735
%x, Format-Spezifizierer 291
&&, logischer Operator 123
&, Generics 488
&amp 858
&apos 858
&gt 858
&lt 858
&quot 858
*, Multiplikationsoperator 116
*7, Projekt 56
+, Additionsoperator 116
, Ant 1428
-, Subtraktionsoperator 116
.class 508, 1340
.java.policy 1409
.keystore 1413
.NET Remoting 1209
/, Divisionsoperator 116
//, Zeilenkommentar 96
=, Zuweisungsoperator 106
==, Vergleichsoperator 197
?, Generics 489
@author, JavaDoc 422
@category, JavaDoc 422
@code, JavaDoc 422
@Deprecated, Annotation 428,
554, 1339
@deprecated, JavaDoc 427
@deprecated, JavaDoc-Tag 555
@Documented, Annotation 1379
@exception, JavaDoc 422
@javax.management.MXBean
1395
@link, JavaDoc 422
@linkplain, JavaDoc 422
@literal, JavaDoc 422
@OneWay, Annotation 1226
@Override, Annotation 392,
411, 554, 1372
@param, JavaDoc 422
@Retention, Annotation 1379
@return, JavaDoc 422
@see, JavaDoc 422
@SOAPBinding, Annotation
1226
@SuppressWarnings, Annotation
554, 639, 1372
@Target, Annotation 1378
@throws, JavaDoc 422
@version, JavaDoc 422
@WebMethod, Annotation 1226
@WebParam, Annotation 1226
@WebResult, Annotation 1226
@WebService, Annotation 1226
@XmlElement, Annotation 903
@XmlRootElement, Annotation
903
[L 1345
^, logischer Operator 123
||, logischer Operator 123
…, variable Argumentlisten 226
1099, Port rmiregistry 1216
200, OK HTTP-Statuscode 1185
404, Not Found HTTP-Statuscode 1185
500, Internal Server Error 1185
80, HTTP-Port 1181
8080, HTTP-Port 1181
A
Abrunden 309
abs(), Math 307
Absolutwert 176
Abstract Syntax Notation One
1413
Abstract Window Toolkit 913
abstract, Schlüsselwort 405–406
AbstractAction, Klasse 947
AbstractBorder, Klasse 950
AbstractButton, Klasse 944
AbstractTableModel, Klasse 1029
abstrakte Klasse 404
abstrakte Methode 406
Absturz der Ariane 5 131
Accelerator 995
accept(), ServerSocket 1174
Access Controller 1401
Accessibility 915
Accessible, Schnittstelle 1070
AccessibleObject, Klasse 1352,
1368
Action, Schnittstelle 947, 994
ACTION_PERFORMED,
ActionEvent 930
Action-Command 946
ActionListener, Schnittstelle 933,
941–942
Activatable, Klasse 1224
Activation Daemon 1224
activation.jar 1198
Adapter 663
Adapter, MBean 1389
Adapterklasse 937
add(), Container 925, 957
addActionListener(), JButton 942
addItem(), JComboBox 1008
Addition 116
addKeyListener(), Component
953
addWindowListener() 936
Adjazenzmatrize 224
Adjustable, Schnittstelle 981
AdjustmentEvent, Klasse 980
AdjustmentListener, Schnittstelle 982
Adleman, Leonard M. 1415
Adler32, Klasse 830
Affine Transformation 1139
AffineTransform, Klasse 1139
Age, Response-Header 1186
Aggregationsfunktion 1336
Ahead-Of-Time Compiler 1436
1455
1371.book Seite 1456 Mittwoch, 17. Dezember 2008 1:39 13
Index
AIFF 552
Aktor 185
aktueller Parameter 158
Al-Chwârismî, Ibn Mûsâ 637
AlgorithmParameterSpec,
Schnittstelle 1419
Algorithmus 637
Alias 195
-alias, keytool 1413
allgemeines Semaphor 616
allowSystemProperty 1409
AllPermission 1410
AlphaComposite, Klasse 1111
AlreadyBoundException 1218
AM_PM, Calendar 731
Amigos 185
Android 1283
Anführungszeichen 111
angehäufte if-Anweisung 137
angepasster Exponent 300
Anmelde-/Versendesystem 1229
AnnotatedElement, Schnittstelle
1360, 1380
Annotation 554
Annotation, Schnittstelle 1381
Annotiert 1339
anonyme innere Klasse 496
Anpassung 445
Ant 1446
Antialiasing 1081, 1138
Anweisung 95
Anweisungssequenz 102
Anwendungsfall 185
Anwendungsfalldiagramm 185
ANY 860
Anzahl Einträge 1337
Apache Axis 1226
Apache Commons CLI 236
Apache Commons Codec 290
Apache Commons Collections
697
Apache Commons Compress 817
Apache Commons DBCP 1311
Apache Commons IO 755, 772
Apache Commons Logging 1385
Apache Commons Net 1180
Apache Harmony 67
Apache Jakarta HttpClient 1180
append(), StringBuffer/StringBuilder 261
1456
Appendable, Schnittstelle 261,
782
Apple, Look-and-Feel 1055
Applet 56, 66, 1268
AppletContext 552, 1272, 1274
appletviewer 1435
Applikations-Klassenlader 530
APRIL, Calendar 726
Ära 739
Arc2D, Klasse 1095–1096
Arcus-Funktionen 308
Area, Klasse 1097
AreaAveragingScaleFilter 1129
Argument der Funktion 158
ArithmeticException 117, 317,
469
arithmetische Typen 103
arithmetischer Operator 116
Array 215
Array, Klasse 1350
arraycopy(), System 228
Array-Grenze 61
ArrayIndexOutOfBoundsException 469
ArrayList, Klasse 375, 638,
643–644, 651, 659
ArrayStoreException 398, 664
Array-Typen 189
Artefakte 1131
Aschermittwoch 728
ASCII-Zeichen 88
asin(), Math 308
asList(), Arrays 233, 662, 672
ASN.1 1413
assert, Schlüsselwort 479
Assertion 479
AssertionError 479
Assignment 106
assistive technology 1069
Assoziation 373
assoziativer Speicher 644
Astronomie 713
Atlantic City 64
atomar 587
atomare Komponente 924
Atomuhr 714
Attribut 183, 856
Attributinhalte 894
AU 552
AudioClip, Klasse 552
aufgeschobene Initialisierung
165
Aufrunden 309
AUGUST, Calendar 726
Ausdruck 115
Ausdrucksanweisung 100
Ausführungsstrang 557
Ausgabeformatierung 714
Ausnahmenbehandlung 60
Ausprägung 183
Ausprägungsspezifikation 185
Ausprägungsvariable 189
ausschließendes Oder 123
äußere Schleife 145
Auswahlmenü 1007
Auszeichnungssprache 855
authentication required 1153
Authenticator, Klasse 1159
Authentifizierung 1412
Autoboxing 208
Auto-Commit 1328
automatische Typanpassung 127,
385
Autorisierung 1412
await(), Condition 606
AWT 913
AWTEvent, Klasse 930
AWTEventListener, Schnittstelle
1069
AWT-Event-Thread 937, 1063
AWT-Input 579
AWT-Motif 579
B
barrier 576
Base64, Encoding 290, 1197
baseline 1085
Basic Multilingual Plane 88
BasicStroke, Klasse 1112
BatchUpdateException 1321
Beautifier 1451
bedingte Compilierung 61
Bedingungsoperator 125, 176
Behinderung, Accessibility 915
Beispielprogramme der Insel 49
benutzerdefinierter Klassenlader
531
Beobachter-Pattern 436
Berkeley-Socket-Interface 1168
Berners-Lee, Tim 1181
1371.book Seite 1457 Mittwoch, 17. Dezember 2008 1:39 13
Index
Betrag 307
BevelBorder, Klasse 950
Bezeichner 90
Bézier-Kurve 1097
Bias 300
biased exponent 300
bidirektionale Beziehung 373
BigDecimal 316
BigDecimal, Klasse 322
Big-Endian 318
BigInteger, Klasse 316
Bilder skalieren 1127
Bildlaufleiste 978
binäre Suche (binary search) 704
binärer Operator 115
binäres Semaphor 616
Binary Floating-Point Arithmetic
300
binarySearch(), Arrays 233, 669
bind(), Registry 1218
Binnenmajuskel 91
bin-Pfad 73
biometrisches System 1412
Birrel 1207
Bitmenge 709
BitSet, Klasse 709
Bitttage 728
Bitweise Manipulation 709
bitweises Exklusives Oder 170
bitweises Komplement 125
bitweises Oder 125, 170
bitweises Und 125, 170
bitweises Xor 125
Block 113
BlockingQueue, Schnittstelle 683
Block-Tag 424
boolean, Datentyp 103
Boolean, Klasse 207
Bootstrap-Klassen 529
Bootstrap-Klassenlader 530
Border, Schnittstelle 949
BorderFactory, Klasse 951
BorderLayout, Klasse 965, 968
Bound Properties 446
bound properties 447
BoundedRangeModel,
Schnittstelle 980
Boxing 208
BoxLayout 977
BoxLayout, Klasse 964, 977
break 148–149
BreakIterator, Klasse 285
brighter(), Color 1106
Brightness 1107
Bruch 325
Bruchzahl 300
Bucket, Hash-Tabelle 695
BufferedImage, Klasse 1124
BufferedInputStream, Klasse 774,
800
BufferedOutputStream 798
BufferedReader 774
BufferedReader, Klasse 800
BufferedWriter 798
build.xml 1447
ButtonGroup, Klasse 988
Byte 169
byte 299
byte, Datentyp 108
Byte, Klasse 207
ByteArrayInputStream, Klasse
797
ByteArrayOutputStream, Klasse
796
Bytecode 57
Bytecode Verifier 1401
BZip2 817
C
C 55
C# 208
C++ 55, 182
Cache, Bilder 1133
Cache-Control 1186
CachedRowSet, Schnittstelle
1322
CachedRowSetImpl, Klasse 1323
CAG (Constructive Area Geometry) 1097
Calendar, Klasse 714, 724
Call by Reference 197
Call by Value 158, 197
Callable, Schnittstelle 583
CallableStatement, Schnittstelle
1311
CANON_EQ, Pattern 272
Canvas 1116
CAP_BUTT, BasicStroke 1112
CAP_ROUND, BasicStroke 1112,
1115
CAP_SQUARE, BasicStroke 1113
CardLayout, Klasse 965
Caret 1020
CASE_INSENSITIVE, Pattern 272
CASE_INSENSITIVE_ORDER,
String 673
Cast, casten 125–126
catch 455
CDATA 860
CDC (Connected Device
Configuration) 1284
ceil(), Math 309
CERN 1181
Certificate Authority, CA 1412
ChangeListener, Schnittstelle 979
char, Datentyp 103, 111
Character, Klasse 237
CharArrayReader, Klasse 795
CharArrayWriter, Klasse 794
CharSequence, Schnittstelle 243,
429
Checkbox, Klasse 985
checked exception 470
checkError() 785
Checksum, Schnittstelle 827
choice box 1007
Christi Himmelfahrt 728
Cipher, Klasse 1420
CipherInputStream, Klasse 1420
CipherOutputStream, Klasse
1420
class literal 508
Class Loader 528
class method 97
Class, Klasse 508, 1340
class, Schlüsselwort 327, 1348
ClassCastException 387, 469
ClassLoader, Klasse 531, 1403
ClassNotFoundException
1341–1342
CLASSPATH 530, 1437, 1443
-classpath 530, 1437
Class-Path-Wildcard 1438
Client 1209
Client-Server-Kommunikation
1173
Clip-Bereich 1076
Clipboard 997, 1056
Clipboard, Klasse 1056
Clipper 1415
clipping 1102
Clipping-Bereich 1135
1457
1371.book Seite 1458 Mittwoch, 17. Dezember 2008 1:39 13
Index
clone() 514
clone(), Arrays 228
CloneNotSupportedException
515, 517
Closeable, Schnittstelle 776
closePath(),Path2D 1100
Cloudscape 1292
Clustering, Hash-Tabelle 695
cmd.exe 542
code point 88
Codebase 1408
CollationKey, Klasse 267
Collator, Klasse 264, 669, 673
Collection, Schnittstelle 639–640
Collection-API 637
Collections, Klasse 638
Color, Klasse 1103
com.sun.image.codec.jpeg, Paket
1117
com.sun.net.httpserver, Paket
1187
com4j 1433
combo box 1007
ComboBoxModel, Schnittstelle
1007
Command Model 933
Command not found 73
command.com 542
Comparable, Schnittstelle 414,
667
Comparator, Schnittstelle 667
compare(), Comparator 668
compareTo(), Comparable 668
compareTo(), String 246
compareToIgnoreCase(), String
246
Compilation Unit 96, 213
Compilationseinheit 96, 213
Compiler 72
Component, Klasse 948
ComponentEvent, Klasse 932
ComponentListener, Schnittstelle 956
ComponentUI, Klasse 1006
Composite Pattern 957
Composite, Schnittstelle 1111
CompoundBorder, Klasse 950
concat(), String 250
CONCUR_UPDATABLE, ResultSet
1318, 1323
ConcurrentHashMap, Klasse 707
1458
ConcurrentLinkedQueue, Klasse
707
ConcurrentMap, Schnittstelle
707
ConcurrentModificationException 651
ConcurrentSkipListMap, Klasse
644
ConcurrentSkipListSet, Klasse
707
Condition, Schnittstelle 606
Connected Limited Device
Configuration (CDC) 1284
Connection 1186
Connection, Schnittstelle 1302
Connector/J 1293
Connector-Level 1389
Console, Klasse 792
const, Schlüsselwort 166
const-korrekt 166
Constraint-Properties 446
Constructor, Klasse 1358
Contact Port 1169
Container 637
contains(), Shapre 1101
contains(), String 243
containsKey(), Map 688
Content-Encoding 1187
contentEquals(), String 263
Content-Handler 1153, 1156
ContentHandler, Schnittstelle
877
Content-Pane 925
continue 148, 150
Controller 1005
Copy-Constructor 514
Copy-Konstruktor 359
copyOf(), Arrays 230
copyOfRange(), Arrays 230
CopyOnWriteArrayList, Klasse
652, 709
CopyOnWriteArraySet, Klasse
709
CORBA 1222
CORBA (Common Object Request
Broker Architecture) 1209
cos(), Math 308
cosh(), Math 308
Cosinus 308
-cp 530, 1437–1438
Cp037 288
Cp850 288
CRC32, Klasse 828
CREATE TABLE 1337
createCompatibleImage(),GraphicsConfiguration 1124
createGraphics(), BufferedImage
1124
createRegistry(), LocateRegistry
1215
createScreenCapture(), Robot
1073
createStatement(), Connection
1311
Crimson 867
Cryptographic Service Providers
1402
CSV (Comma-separated Values)
852
CubicCurve2D, Klasse 1095
currency, Datentyp 111
currentThread(), Thread 566
currentTimeMillis(), System 540
curveTo(), GeneralPath 1098
custom tag library 1247
Customization 445
CVM 1284
cxxwrap 1433
CyberNeko 911
CyclicBarrier, Klasse 576
D
-D 538
Dämon 578
dangling pointer 363
Dangling-Else-Problem 135
darker(), Color 1106
dash attribute 1111
Data Hiding 337
Data Query Language 1335
database management systems
1291
DatabaseMetaData, Schnittstelle
1332
DataFlavor, Klasse 1058
Datagramm 1190
DatagramPacket, Klasse 1191
Datagram-Socket 1189
DatagramSocket, Klasse
1189–1190
DataInput, Schnittstelle 764, 833
1371.book Seite 1459 Mittwoch, 17. Dezember 2008 1:39 13
Index
DataInputStream, Klasse 805
DataOutput, Schnittstelle 764,
833
DataOutputStream, Klasse 805
Datapoint 57
DataSource 1308
DataSource, Schnittstelle 1308
DataTruncation, Klasse 1320
DATE, Calendar 730
Date, General Header Fields 1186
Date, Klasse 714, 722
DateFormat, Klasse 294, 714,
735, 740
Dateiauswahldialog 1051
Dateinamenendungen 247
Dateiverknüpfung 749
Datenbankausprägung 1291
Datenbankschema 1291
Datenbankverbindung 1306
Datenbankverwaltungssystem
1291
Datenbasis 1291
Datenkompression 815
Datenstrukturen 637
Datentyp 102
Datenzeiger 765
Datumswerte 714
DAY_OF_MONTH, Calendar 730
DAY_OF_WEEK, Calendar 731
DAY_OF_WEEK_IN_MONTH,
Calendar 731
DAY_OF_YEAR, Calendar 731
dBase, JDBC 1302
DBMS 1291
-Dcom.sun.management.
jmxremote 1392
Deadlock 558, 603
DECEMBER, Calendar 726
DecimalFormat, Klasse 296
Decrement 125
default 139
default, Schlüsselwort 1377
DefaultHandler, Klasse 877–878
Default-Konstruktor 192, 356
DefaultListCellRenderer, Klasse
1015
DefaultListModel, Klasse 1015
DefaultListModel, Schnittstelle
1012
DefaultMutableTreeNode, Klasse
1041
Default-Paket 212
defaultReadObject(),
ObjectInputStream 840
DefaultTableCellRenderer, Klasse
1034
DefaultTableModel, Klasse 1032
defaultWriteObject(), ObjectOutputStream 840
DEK 315
Dekonstuktor 520
Dekoration 923
delegate 76
Delegation Model 933
delete() 60
delete(), StringBuffer/StringBuilder 262
DELETE, HTTP-Methode 1182
Delimiter 276, 284
Dependency Injection 443
Deployment-Descriptor 1236
deprecated 426, 1436
-deprecation 427
Deque 682
Deque, Schnittstelle 643
Derby 1292
dereferenced-Meldung 1220
Dereferenzierung 177
deriveFont(), Font 1088
DES (Data Encryption Standard)
1418
Design-Pattern 436
Desktop, Klasse 544
Dezimalpunkt 300
DGC 1220
Dialog 1048–1049
Digitale Unterschriften 1414
DirectX 76
Distributed Component Object
Model (DCOM) 1209
distributed GC 1220
Dividend 116
Divider 961
Division 116
Divisionsoperator 116
Divisor 116
-Djava.rmi.dgc.leaseValue 1220
-Djava.rmi.server.codebase 1222
-Djava.security.debug 1406
-Djava.security.manager 1407
-Djava.security.policy 1409
-Djdbc.drivers 1303
dll-Dateien 1427
DnD, Drag & Drop 1060
DNS 1145, 1278
Doc Comment 421
Doclet 425, 1340
DOCTYPE 861
Document Object Model 866
Document Type Definition 859
Document, Klasse 883
DocumentBuilderFactory 868
Dokumentationskommentar 421
DOM 866
DOM Level 3 XPath 897
Domain Name Service 1145
Domain Name System 1190
Domain-Name-Server 1278
DOMBuilder, Klasse 884
Doppel-Pufferung, Swing 961
DOS-Programme 542
DOTALL, Pattern 272
double 300
double, Datentyp 103
Double, Klasse 207
Double-Buffering, Swing 961
doubleToLongBits(), Double 520
do-while-Schleife 142
DQL 1335
Drag & Drop 915, 1060
draw(Shape), Graphics2D 1094
draw3DRect(), Graphics 1106
drawImage(), Graphics 1119
drawLine(), Graphics 1081
drawString(), Graphics 1085
Drehfeld 1016
DriverManager, Klasse 1303,
1305
Drucken 1140
DSAPrivateKeySpec, Klasse 1420
DSN 1190
DST_OFFSET, Calendar 731
DTD 859
DTDHandler, Schnittstelle 877
Durchschnittswert 1336
Durchschuss 1092
-Duser.timezone 727
dynamic invocation 1368
dynamic linked libraries 1427
Dynamic MBeans 1389
Dynamische Datenstruktur 637
1459
1371.book Seite 1460 Mittwoch, 17. Dezember 2008 1:39 13
Index
Dynamischer Methodenaufruf
1370
dynamisches Layout 924
E
-ea 480, 1438
EBCDIC-Zeichensatz 288, 809
Echozeichen 1020
Eclipse 75
Eclipse Translation Packs 77
EclipseME 1286
ECML 1243
Editor-Kit 1024
Eigenschaft 445
einfache Eigenschaft 446
einfaches Hochkomma 111
Einfachvererbung 380
eingeschränkte Eigenschaft 446
einstelliger Operator 115
Electronic Commerce Modeling
Language 1243
Element suchen 703, 705
Element, Klasse 886
Element, XML 856
elementare Anweisung 102
Elementklasse 492
ElementType, Aufzählung 1378
Ellipse2D, Klasse 1095
else, Schlüsselwort 135
Elternklasse 378
EmptyBorder, Klasse 950
EmptyStackException 470, 681
enable assertions 480
encoding 288
end caps 1112
Endlosschleife 141
endorsed-Verzeichnis 529, 535
Endpoint, Klasse 1227
endsWith(), String 247
ENGLISH, Locale 716
ensureCapacity(), List 661
Enterprise Edition 68
Entfernte Methoden 1207
Entfernte Methodenaufrufe 1207
Entfernte Objekte 1213
Entität 858
Entity 1186
Entity-Body 1186
Entity-Header 1184, 1186
EntityResolver, Schnittstelle 877
1460
entrySet(), Map 691
Entwurfsmuster 436
Enum, Klasse 522
enum, Schlüsselwort 352, 479
Enumeration, Schnittstelle 647
Enumerator 647
EnumMap, Klasse 435
EOFException 764
equals() 510–511, 1150
equals(), Arrays 229
equals(), Object 198, 510
equals(), Point 199
equals(), String 263
equalsIgnoreCase(), String
245–246
ERA, Calendar 730
Ereignis, GUI 930
Ereignisauslöser 933
Ereignisschlange 1063
Ereignisse 445
Ergebnistyp 153
erreichbar, catch 465
erreichbarer Quellcode 159
Error, Klasse 466, 470
ErrorHandler, Schnittstelle 877
erweiterte for-Schleife 220
Erweiterungs-Klassenlader 530
Escape-Sequenz 111
Escape-Zeichen 243
Escher, Maurits 179
EtchedBorder, Klasse 950
Eulersche Zahl 307
Euro-Zeichen 92
Event Queue 1063
Event-Dispatching-Thread 937
EventFilter, Schnittstelle 873
EventListener, Schnittstelle 441
EventObject, Klasse 440
Eventquelle 933
EventQueue, Klasse 1063, 1066,
1068
Events 445
Event-Source 933
Excelsior JET 1437
Exception 60
Exception, Klasse 466
Exchanger, Klasse 576
exec(), Runtime 541
executeQuery(), Statement 1312
executeUpdate(), Statement 1312
Executor, Schnittstelle 580
ExecutorService, Schnittstelle
581
Exemplar 183
Exemplarinitialisierer 369
Exemplarinitialisierungsblock
499
Exemplarvariable 189, 344
exit(), System 236
EXIT_ON_CLOSE, JFrame 920
Exklusives Oder 123
explizite Typanpassung 127
explizite Typumwandlung 387
explizites Klassenladen 529
Explorer 66
Exponent 300
Exponentialwert 311
exportObject(), UnicastRemoteObject 1218
expression 115
extend, Schlüsselwort 378
extends, Schlüsselwort 417
eXtensible Markup Language 856
Extension-Verzeichnis 529
F
Fabrik 436
Fabrikmethode 365
Facelets 1266
Factory 436
Faden 557
Fakultät 321
Fall-Through 139
false 103
Farbe 1103
Farbmodell 1107
Farbsättigung 1107
FEBRUARY, Calendar 726
Federal Information Processing
Standards Publication 1415
Fee, die gute 167
Fehler 466
Fehlercode 455
Feld 215
Feldtypen 189
fencepost error 144
Fenster 918
Fenstermenü 991
Field, Klasse 1351–1352, 1362
FIFO-Prinzip 643
File, Klasse 744
1371.book Seite 1461 Mittwoch, 17. Dezember 2008 1:39 13
Index
file.encoding 809
File.separatorChar 745
FileChannel, Klasse 759
FileDescriptor, Klasse 772
FileFilter, Klasse 1051
FileFilter, Schnittstelle 753
FileInputStream, Klasse 770
FilenameFilter, Schnittstelle 753
FileNotFoundException 456, 467
FileOutputStream, Klasse 769
FilePermission 1410
FileReader, Klasse 768
FileWriter, Klasse 767
fill(), Arrays 230
fill(), Collections 702
fillInStackTrace(), Throwable 475
FilteredRowSet, Schnittstelle
1323
FilterInputStream, Klasse 805
FilterOutputStream, Klasse 805
FilterReader, Klasse 805
FilterWriter, Klasse 805
final 165
final, Schlüsselwort 345, 349,
395, 1348
finale Klasse 395
finale Methode 395
finale Werte 371
finalize() 520
Finalizer 520
finally, Schlüsselwort 462
findClass(), ClassLoader 531
Fingerabdruck 1414
FIPS 1415
Firewall 1223
First in, First out 643
First Person, Inc. 56
Fitts’s Law 966
Five-Nine System 1411
flache Kopie 694
flache Kopie, clone() 517
flache Objektkopie 517
Flaubert, Gustave 1435
Fließkommazahl 102, 110, 300
Fließpunktzahl 300
float, Datentyp 103, 300
Float, Klasse 207
floatToIntBits(), Float 520
floor(), Math 309
FlowLayout, Klasse 964, 966
Fluchtsymbole 111
Flushable, Schnittstelle 777
FocusEvent, Klasse 932
FocusListener, Schnittstelle 952
Fokus 951
Font, Klasse 926, 1086
FontFormatException 1090
FontMetrics, Klasse 1090
FontRenderContext, Klasse 1092
formaler Parameter 157
formaler Typ-Parameter 483
format() 785
format(), Format 294
format(), String 291
Format, Klasse 294
Formatierungsanweisungen 736
Formatierungsstrings 739–740
Format-Spezifizierer 291
Format-String 291
Formatter, Klasse 292
forName(), Klasse 1340
for-Schleife 143
Fortschaltausdruck 144
Fortschrittsbalken 989
Fragezeichenoperator 115
Frame 918
Frame, Klasse 920
FRANCE, Locale 716
free() 60
FRENCH, Locale 716
Fronleichnam 728
FULL, DateFormat 737
Füllfaktor 695
Füllmuster 1115
Füllung, Paint 1102
Funktion 155
Funktionsaufruf 98
Funktionszeiger 433
G
Ganzzahl 102
ganzzahliger Datentyp 108
Garbage-Collector 60, 188, 192,
355, 362
Gauß-Normalverteilung 316
GC 60, 355
GC, Garbage-Collector 362
GCC 1427
gcj 1436
gebundene Eigenschaft 446–447
gebundene Property 960
Geburtsdatum 733
Geburtstagsparadoxon 1415
gegenseitiger Ausschluss 587,
591
Geltungsbereich 114
General Header 1184
GeneralPath, Klasse 1097
Generic Connection Framework
1284
Generics 482
generischer Typ 482
-genkey 1413
geordnete Liste 643
geprüfte Ausnahme 470
GERMAN, Locale 716
GERMANY, Locale 716
geschachtelte Alternativen 137
geschachtelte Ausnahme 475
geschachtelte Top-Level-Klasse
491
get(), List 652
get(), Map 687
GET, HTTP-Methode 1182
getBytes(), ResultSet 1317
getBytes(), String 288
getChars(), String 249
getColumnClass(), TableModel
1029
getColumnCount(), TableModel
1029
getColumnName(), TableModel
1029
getConnection(), DriverManager
1303
getContentPane(), JFrame 926
getDefaultToolkit(), Toolkit 918
getenv(), System 540
getInstance(), Calendar 726
GET-Methode 1161, 1181
getPriority(), Thread 577
getProperties(), System 536
getProperty(), Properties 697
getResource() 778
getResourceAsStream() 778
getRowCount(), TableModel
1029
getStackTrace(), Thread 477
GetStringUTFChars 1429
getTableCellEditorComponent(),
TableCellEditor 1036
Getter 339
1461
1371.book Seite 1462 Mittwoch, 17. Dezember 2008 1:39 13
Index
getText(), JLabel 926
getText(), JTextComponent 1019
getTimeInMillis(), Calendar 729
getValueAt(), TableModel 1029
ggT 317
GIF 1116
GlassFish 68
Glass-Pane 1046
Gleichheit 199
Gleitkommazahl 300
globale Variable 114
Glyphe 1085
GMST 713
GNU Classpath 67
Gosling, James 55
goto, Schlüsselwort 151
GradientPaint 1102
Grammatik 87
grant-Anweisung 1408
Granularität, Threads 578
Graphics Interchange Format
1116
Graphics, Klasse 1076
Graphics2D, Klasse 1076
GraphicsEnvironment, Klasse
1089
greedy operator, regulärer Ausdruck 274
Green-OS 56
Green-Projekt 55
Green-Team 56
Greenwich Mean Sidereal Time
713
GregorianCalendar, Klasse 724,
726
Gregorianischer Kalender 724
GridBagConstraints, Klasse 972
GridBagLayout, Klasse 965, 972
GridLayout, Klasse 965, 970
Groovy 546
Groß-/Kleinschreibung 91, 247,
250
Größter gemeinsamer Teiler 317
GroupLayout, Klasse 965
Grundlinie 1085
Grundton 1107
Gruppenfunktion 1336
guard 611
guarded action 611
guarded wait 611
GUI-Builder 1339
1462
gültig, XML 859
Gültigkeitsbereich 114
gzip 1187
GZIPInputStream, Klasse 817
GZIPOutputStream, Klasse 817
H
Halbierungssuche 704
Hashcode 517, 694
hashCode(), Object 517
Hash-Funktion 517, 694
HashMap, Klasse 644, 684
HashSet, Klasse 643, 676
Hash-Tabelle 684
Hashtable, Klasse 684
Hash-Verfahren 1414
Hash-Wert 517
Hauptklasse 96
HEAD, HTTP-Methode 1182
Header-Datei 61, 1426
HEAD-Methode 1182
Heap 188
heavyweight component 914
Helligkeit 1107
hexadezimale Zahl 108
Hexadezimalform 108
Hibernate 1337
HierarchyEvent, Klasse 932
high-level event 932
Hilfsklasse 364
Hoare, C. A. R. 590
Horcher 933
Host 1145
Host-Adresse 1163
Hostname 1145
HotJava 56
HOUR, Calendar 731
HOUR_OF_DAY, Calendar 731
HP 58
HSB 1107
HSQLDB 1292
HTML 855, 1181
HTML Converter 1270
HTML-Formular 1243
HTTP 1146, 1181
HTTP 0.9 1184
HTTP 1.0 1181
http.proxyHost 1152
http.proxyPort 1152
HttpClient 1180
HttpHandler, Schnittstelle 1188
HTTP-Header 1155
https.ProxyHost 1153
https.ProxyPort 1153
HttpServer, Klasse 1187
Hue 1107
Hyperbolicus-Funktionen 308
Hypertext Transfer Protocol
1146, 1181
I
i18n.jar 529
IBM 1207, 1339
ICCCM 1057
IcedTea 65
Ich-Ansatz 183
ICMP 1204
ICO 1117
Icon, Schnittstelle 928
Identifizierer 90
Identität 199, 510
identityHashCode(), System 519
IdentityHashMap, Klasse 691
IEEE 754 118, 300
IEEE-754 110
IEEEremainder(), Math 312
IETF 1145–1146
if, Schlüsselwort 133
IFC 915
if-Kaskade 137
ignorierter Statusrückgabewert
457
IIOP 1223
IllegalArgumentException
470–471, 473
IllegalMonitorStateException
470, 609, 615
IllegalThreadStateException 562
Image, Klasse 1116
ImageIcon, Klasse 928
ImageIO 1117
ImageIO, Klasse 1117
ImageObserver, Schnittstelle
1120
Imagination 55
immutable 240
imperative Programmiersprache
95
implizites Klassenladen 529
import, Schlüsselwort 193, 212
1371.book Seite 1463 Mittwoch, 17. Dezember 2008 1:39 13
Index
Increment 125
Index 215, 217
Indexed Properties 446
indexierte Variablen 217
indexOf(), String 243
IndexOutOfBoundException 219
indizierte Eigenschaft 446
InetAddress 1164
InetAddress, Klasse 1164
InetSocketAddress, Klasse 1172
infinity 301
InheritableThreadLocal, Klasse
624
Inline-Tag 424
innere Klasse 490
innere Schleife 145
InputMethodEvent, Klasse 932
InputMismatchException 283
InputStream, Klasse 777
InputStreamReader, Klasse 289,
810
InstallShields 1280
instance method 97
instanceof, Schlüsselwort 408,
1346
InstantiationException 384, 1362
Instanz 183
Instanzinitialisierer 369
Instanzvariable 189
instrumentalisierte Objekte 1389
int 299
int, Datentyp 103, 108
Integer, Klasse 207
integraler Typ 103
Integritätsprüfung von Nachrichten 1415
Interaktionsdiagramm 186
Inter-Client Communication Convention Manual 1057
Interface 64, 404, 409
interface, Schlüsselwort 409
Interface/Implementation-Pair
1029
Interface-Typen 189
intermediate container 961
internal frame 1046
Internationalisierung 718
internes Fenster 1046
Internet Control Message Protocol
1204
Internet Engineering Task Force
1145–1146
Internet Explorer 66
Internet Foundation Classes 915
Internet Protocol 1146
Internet-Media-Types 1186
Inter-ORB Protocol 1223
Interrupt 571
interrupt(), Thread 571, 614
interrupted(), Thread 572
InterruptedException 544, 568,
572, 607, 614
InterruptedIOException 1175
Intersolv 1298
Intervall 148
Introspection 445, 1339
invalidate(), Component 959
InvalidClassException 832, 843
Invarianz 488
Inversion of Control 443
Invocation-API 1423
InvocationEvent, Klasse 1066
InvocationTargetException 1362
invoke(), Method 1368
invokeAndWait(), SwingUtilities
1065
invokeLater(), SwingUtilities 991,
1065
Invoker-Servlet 1262
IoC-Container 443
IOException 456, 467
IP 1146
IP-Adressen 1163
ipconfig 1204
iPhone 58, 1283
IP-Nummer 1145
isCellEditable(), TableModel
1029, 1031
isInterrupted(), Thread 571
is-Methode 339
isNaN(), Double/Float 302
ISO 8859-1 88
ISO Country Code 715
ISO Language Code 715
ISO-639-Code 715
ISO-Abkürzung 717
Ist-eine-Art-von-Beziehung 405
ITALIAN, Locale 716
ItemEvent, Klasse 985
ItemListener, Schnittstelle
985–986, 989, 1010
ItemSelectable, Schnittstelle 986
itemStateChanged(), ItemListener
986
Iterable, Schnittstelle 431, 646
Iterator 647
Iterator, Schnittstelle 431, 647
J
J/Direct 76
J2EE 68
J2ME 68
JAAS 1402, 1411
Jacobson, Ivar 185
Jahr 730, 739
JAI 1117
Jakarta Commons Math 325
JANUARY, Calendar 726
JAPAN, Locale 716
JAPANESE, Locale 716
Jar 1439
jar, Dienstprogramm 1435, 1440
-jar, java 1443
Jar-Datei 1157
JarFile, Klasse 827, 1158
jarsigner 1435
jarsigner, Dienstprogramm 1414
JarURLConnection, Klasse 1158
Java 56, 1435
Java 2D API 915
Java 2D-API 1080
Java 6 Update 10 68
Java Accessibility 1070
Java API for XML Parsing 867
Java Authentication and Authorization Service 1411
Java Authentication and Authorization Service (JAAS) 1402
Java Cryptography Architecture
1401
Java Cryptography Extension
(JCE) 1401
Java Database Connectivity 1297
Java DB 1292
Java Document Object Model
866
Java Foundation Classes 915
Java Foundation Classes (JFC)
1080
Java Image Management Interface
1117
1463
1371.book Seite 1464 Mittwoch, 17. Dezember 2008 1:39 13
Index
Java Management Beans 1390
Java Management Extensions
1389
Java Message Service 1229
Java Native Interface 1423
Java Network Launcher Protocol
1281
Java Object Serialization 831
Java Persistence API (JPA) 1337
Java Runtime Environment 1442
Java Secure Socket Extension
1153, 1205
Java Service Wrapper 1452
Java Virtual Machine 57
Java Virtual Machine Process
Status Tool 1444
Java Virtual Machine Statistics
Monitoring Tool 1444
java, Dienstprogramm 1437
java, Paket 193
java.awt.event, Paket 930
java.awt.geom, Paket 1081
java.beans, Paket 847
java.endorsed.dirs 535
java.ext.dirs 530
java.lang.ref, Paket 1289
java.naming.factory.initial 1310
java.net, Paket 1145
java.nio.charset, Paket 289
java.prof 1438
java.rmi.server.codebase 1222
java.rmi.useCodebaseOnly 1222
java.security 1409
java.text, Paket 285
java.util.concurrent, Paket 708
java.util.concurrent.atomic, Paket
596, 621
java.util.concurrent.lock, Paket
591
java.util.jar, Paket 816, 1440
java.util.regex, Paket 269
java.util.zip, Paket 816–817
JavaBean 445
Java-Beans 1339
JavaBeans Activation Framework
1198
JavaBeans Persistence 831
javac, Dienstprogramm 1435
JavaCompiler 1436
Java-Cryptography-API 1401
JavaDoc 421
1464
javadoc 1435
javadoc, Dienstprogramm 423
JavaDoc-Tag 1339
javah, Dienstprogramm 1425
javah-Task, Ant 1425
Java–Look-and-Feel 1054
JavaMail API 1197
JavaScript 64, 1279
Java-Security-Model 59
JavaServer Faces 1266
JavaServer Page 1232
JavaSoft 56
javaw, Dienstprogramm 1439
javax, Paket 193, 507
javax.crypto, Paket 1402
javax.jws, Paket 556, 1226
javax.microedition.midlet, Paket
1289
javax.net, Paket 1205
javax.script, Paket 545
javax.sound 553
javax.sound, Paket 552
javax.sound.midi, Paket 553
javax.swing, Paket 919
javax.swing.text, Paket 1018
javax.swing.undo, Paket 1061
javax.xml.bind.annotation, Paket
903
javax.xml.ws, Paket 556
Jawin 1433
JAXB 902
JAXBContext, Klasse 904
Jaxen 883, 897
JAXP 867
JAX-WS 1226
JBP, JavaBeans Persistence 831
JButton, Klasse 941, 944
JCA 1401
JCheckBox, Klasse 944
JCheckBoxMenuItem, Klasse 993
jCIFS 760
JColorChooser, Klasse 1073
JComboBox, Klasse 1007
jconsole, Dienstprogramm 1392
jdb 1435
JDBC 1297
JDBC 1.0 1299
JDBC 2.0 API 1299
JDBC 2.0 Optional Package API
1299
JDBC 2.1 core API 1299
jdbc.drivers 1303
JDBC-ODBC-Bridge-Treiber 1298
JDBCRowSet, Schnittstelle 1322
JDesktopPane, Klasse 1046
JDialog, Klasse 1049
JDOM 866
JDOMResult, Klasse 901
JDOMSource, Klasse 901
JEditorPane, Klasse 1017, 1024
Jetty 1234
JFC 915
JFileChooser, Klasse 1051
JFormattedTextField, Klasse
1017, 1021
JFrame, Klasse 919, 1077
JGoodies Looks 1056
Jimi 1117
Jindent 1452
JIT 58
JLabel, Klasse 924
jlGui 553
JList, Klasse 1011
jmap, Dienstprogramm 1445
JMenu, Klasse 992–993
JMenuBar, Klasse 992
JMenuItem, Klasse 944, 993
JMS 1229
JMX 1389
JMXConnector, Schnittstelle
1399
JMXConnectorServer, Klasse
1398
JNDI 1308
jndi.properties 1309
JNI 1423
Joda Time 742
Joe Palrang 55
join(), Thread 574
JOIN_BEVEL, BasicStroke 1113
JOIN_MITER, BasicStroke 1113
JOIN_ROUND, BasicStroke 1113
JoinRowSet, Schnittstelle 1323
JOptionPane, Klasse 458, 1049
JOS, Java Object Serialization
831
JPA, Java Persistence API 1337
JPanel, Klasse 961
JPasswordField, Klasse 1017,
1020
JPEG 1116
JPopupMenu, Klasse 1001
1371.book Seite 1465 Mittwoch, 17. Dezember 2008 1:39 13
Index
JProgressBar, Klasse 989, 1065
jps, Dienstprogramm 1392, 1444
JRadioButton, Klasse 944, 988
JRadioButtonMenuItem, Klasse
993
JRE 1442
JRMP (Java Remote Method
Protocol) 1223
JRootPane, Klasse 1046
jrunscript, Dienstprogramm 545
JScrollBar, Klasse 961, 980
JScrollPane 962
JScrollPane, Klasse 961, 1013,
1024, 1028
JSlider, Klasse 978
JSmooth 1437
JSP 1232
JSpinner, Klasse 1016
JSplitPane, Klasse 961, 964
JSR 223 545
JSSE 1153
jstack, Dienstprogramm 1445
jstat, Dienstprogramm 1444
JSTL 1247
JTabbedPane, Klasse 961–962
JTable, Klasse 1027
JTableHeader, Klasse 1039
JTextArea, Klasse 1017
JTextComponent, Klasse 1019
JTextField, Klasse 1017–1018
JTextPane, Klasse 1017
JTidy 910
JToggleButton, Klasse 944, 946
JToolBar, Klasse 961, 998
JTree, Klasse 1041
JULY, Calendar 726
JUNE, Calendar 726
Just-in-Time Compiler 58
JViewport, Klasse 962
JWindow, Klasse 1048
JXPath 912
K
Kanonischer Pfad 746
kanonischer Pfad 746
Kardinalität 373
Kaufmännische Rundung 309
kaufmännische Rundung 309
Keller 680
Kerberos 1412
Key 644
Key, Schnittstelle 1418
KeyEvent, Klasse 932, 953
KeyGenerator, Klasse 1419
KeyListener, Schnittstelle 953
KeyPairGenerator, Klasse 1419
KeySelectionManager, Schnittstelle 1010
keySet(), Map 691
Keystore 1414
keytool, Dienstprogramm 1413,
1435
Kindklasse 378
Klammerpaar 155
Klasse 183, 1129
Klassendiagramm 185
Klasseneigenschaft 344
Klassenhierarchie 378
Klasseninitialisierer 368
Klassenkonzept 64
Klassenlader 59, 528, 1403
Klassen-Literal 508
Klassenmethode 97, 156
Klassenobjekte 508
Klassentypen 189
Klassenvariable, Initialisierung
368
Klonen 514
Knuth, Donald E. 315
Kodierung, Zeichen 288
Kollision, Signatur 1415
Kollisionsangriff 1415
Kommandozeilenparameter 235
Kommaoperator 146
Kommentar 96
Komplement 170
komplexe Zahl 325
Kompressionsfunktion 1415
Kompressionsstufe 1131
Komprimierungsfaktor 1116
Konkatenation 240
konkrete Klasse 405
konstante Zeichenkette 242
Konstantenpool 255
Konstruktive Flächengeometrie
1097
Konstruktor 192, 355
Konstruktoraufruf 187
Konstruktoren in Vererbung 381
Konstruktorweiterleitung 381
Kontextmenü 1000
Kontraktionsfunktion 1415
Kontrollfeldgruppe 988
Kontrollstrukturen 133
koordinierte Weltzeit 714
Kopf 153
Kopfdefinition 858
KOREA, Locale 716
KOREAN, Locale 716
kovarianter Rückgabetyp 396
Kovarianz bei Arrays 397
Kreiszahl, Pi 307
kritischer Abschnitt 587
kryptografische Prüfsumme 1415
ktoolbar, Dienstprogramm 1285
Kubische Kurvensegmente 1097
Kurve 1097
Kurzschlussoperator 124
L
lastIndexOf(), String 244
Last-in-First-out 680
Latin-1 809
Laufwerksname 750
Laufzeitumgebung 57
launch4j 1437
LayoutManager, Schnittstelle 966
lazy activation 1224
LCDUI 1289
LD_LIBRARY_PATH 1429
leading 1092
Lease 1220
Lebensdauer 114
leere Anweisung 102
leerer Block 113
leerer String 253
Leer-String 255
Leerzeichen 284
entfernen 251
Lempel-Ziv-Kodierung 1187
length(), String 242
Lexikalik 87
lib/security 1409
LIFO 680
lightweight component 917
line joins 1111, 1113
line.separator 538, 1406
Line2D, Klasse 1094–1095
lineare Algebra 325
lineare Kongruenzen 315
LinearGradientPaint 1102
1465
1371.book Seite 1466 Mittwoch, 17. Dezember 2008 1:39 13
Index
LineBorder, Klasse 950
LineMetrics, Klasse 1092
LineNumberReader, Klasse 802
lineTo(), GeneralPath 1098
Linie 1081
Linienende 1112
Linien-Pattern 1111
Linienverbindung 1113
LinkedHashSet, Klasse 680
LinkedList, Klasse 643–644, 652,
661
Linking 528
linksassoziativ 126
Liskov, Barbara 388
Liskov’sches Substitutionsprinzip 388
List, Schnittstelle 643, 651
ListCellRenderer, Schnittstelle
1015
Liste 651
Liste füllen 702
Listener 439, 933
ListIterator, Schnittstelle 656
ListSelectionEvent, Klase 1013
ListSelectionEvent, Klasse 1014
ListSelectionListener, Schnittstelle 1013–1014
ListSelectionModel, Schnittstelle
1039
Load Factor 695
load(), System 1429
loadClass(), ClassLoader 531
loadLibrary(), System 1424
Locale 716
Locale, Klasse 715
LocateRegistry, Klasse 1216
Location, Response-Header 1186
Lock 590, 597
lock(), Lock 591
Locking 759
log(), Math 311
log4j 1385–1386
logClass 1219
Logging, RMI 1219
Login-Modul 1412
logisch atomar 608
logischer Operator 123
logisches Komplement 125
logisches Oder 125
logisches Und 125
logisches Xor 125
1466
lokale Klasse 496
lokale Objekte 1213
Lokaler Host 1166
lokalisierte Zahl, Scanner 283
Lokalisierung 718
LONG, DateFormat 737
long, Datentyp 103, 108
Long, Klasse 207
lower-bound wildcard 489
low-level event 931
Luxor 1072
LU-Zerlegung 325
LZ77 1187
M
MAC 1415
MAC-Adresse 1204
magic number 350
magische Zahl 350
Magische Zahlenwerte 1349
Mail User Agent 1196
main() 97
main()-Funktion 74
Main-Class 1442
Makro 61
MalformedURLException 1148
Management Interface 1390
ManagementFactory, Klasse 1393
MANIFEST.MF 1442
Manipulation Detection Code
1415
Mantelklasse 201
Mantisse 300
Map, Schnittstelle 639, 644, 684
Map.Entry, Klasse 692
MARCH, Calendar 726
marker interface 411
Markierungsschnittstelle 411,
835
Marshaller, Schnittstelle 904
marshalling 1210
Matcher, Klasse 269
matches(), Pattern 269
matches(), String 269
MatchResult, Schnittstelle 275
Math, Klasse 305
MathContext, Klasse 324
Matisse 965
MatteBorder, Klasse 950
Mausrad 955
maven 1446
max(), Collections 669
max(), Math 307
MAX_PRIORITY, Thread 577
MAX_RADIX 238
Maximalwert 1337
Maximum 176, 307
MAY, Calendar 726
MBean 1389
MBean-Server 1389
McNealy, Scott 56
MD 1414
MD2 1415
MD4 1415
MD5 1415
MDC 1415
MediaTracker, Klasse 1133
MEDIUM, DateFormat 737
Megginson, David 866
mehrdimensionales Array 222
Mehrfachvererbung 413
Mehrfachverzweigung 137
member class 492
memory leak 363
Memory Map 1445
Menü 991
Menübalken 991
Menüeintrag 991
Menütrennlinie 994
Merant 1298
Merge-Sort 672
Meridian 713
MESA 55
Message Authentication Code
1415
Message Integrity Check 1415
Message Queues 1229
Message Store 1196
Message Transfer Agent 1196
Message Transfer System 1196
Message-Digest 1414
MessageDigest, Klasse 1416
MessageFormat, Klasse 294
Metadaten 1184, 1329
META-INF/MANIFEST.MF 1442
Meta-Information 1186
Metal, Look-and-Feel 1054
Meta-Objekte 1340
Meta-Programming 1339
Method, Klasse 1354
Methode des Aufrufes 1182
1371.book Seite 1467 Mittwoch, 17. Dezember 2008 1:39 13
Index
Methoden 152
Methoden überladen 163
Methodenaufruf 155, 330
Methodenkopf 153
Methodenrumpf 153
MIC 1415
Microsoft 66
Microsoft Access 1294
Microsoft Development Kit 76
Microsoft SQL Server 1294
Middleware 1211
MIDI 553
MidiSystem, Klasse 553
Midlet 1289
MIDP (Mobile Information Device
Profile) 1285
MILLISECOND, Calendar 731
Millisekunde 731
MIME 1197
MimeMultipart, javax.mail 1202
MIME-Nachrichten 1184
MIME-Typ 1156
min(), Collections 669
min(), Math 307
MIN_PRIORITY, Thread 577
MIN_RADIX 238
MIN_VALUE 303
Minimum 176
Minute 731
MINUTE, Calendar 731
Mitgliedsklasse 492
Mnemonic 995
Mobile Information Device Profile
(MIDP) 1285
modal 1049
Model 1005
Model MBeans 1389
Model-View-Controller 436,
1005
Modifizierer 101, 1348
modifiziertes UTF-8 764
Modulo 118
Monat 730
Monitor 590
monitorenter 591
monitorexit 591
Monitoring 1388
MONTH, Calendar 730
mouse wheel 955
MouseEvent, Klasse 932
MouseListener, Schnittstelle 933
MouseMotionListener,
Schnittstelle 933
MouseWheelEvent, Klasse 955
MS 1196
MTA 1196
MTS 1196
MUA 1196
multicast 76
Multicast-Kommunikation 1205
Multilevel continue 151
MULTILINE, Pattern 272
Multi-Map 697
MULTIPLE_INTERVAL_SELECTIO
N, ListSelectionModel 1013
Multiplikation 116
Multiplizität 373
Multipurpose Internet Mail
Extensions 1197
multitaskingfähig 557
multithreaded 558
Muster, regulärer Ausdruck 269
MutableTreeNode, Schnittstelle
1041
Mutex 591
MVC 1005
MXBeans 1390
MySQL 1293
N
Namensdienst 1209, 1215
Namensraum 863
NaN 117, 301, 304
nanoTime(), System 540
narrowing conversion 128
native Methode 1423
Native Protocol All-Java Driver
1299
native, Schlüsselwort 1424
native2ascii, Dienstprogramm
289
Native-API Java Driver 1298
NativeCall 1433
nativer Compiler 1436
nativer Thread 558
natural ordering 667
Natürliche Ordnung 667
Naughton, Patrick 55
NavigableMap, Schnittstelle 644,
686
NavigableSet, Schnittstelle 678
Navigation 951
nearest neighbor algorithm 1129
Nebeneffekt 330
negative Zeichenklassen 271
NEGATIVE_INFINITY 304
negatives Vorzeichen 115
Nelson 1207
nested exception 475
nested top-level class 491
NetBeans 76
NetPermission 1410
Netscape 64, 915
netstat 1174
Network Filesystem 1190
Network Information Services
1145
NetworkInterface, Klasse 1167
Netz-Protokoll All-Java Driver
1299
new line 537
new, Schlüsselwort 187, 355,
1361
newInstance() 384
newInstance(), Array 1350
newInstance(), Constructor 1361
newLine(), BufferedWriter 800
NFS 1190
nicht ausführend 607
nicht geprüfte Ausnahme 470
nicht-primitives Feld 221
nicht-rechteckiges Feld 222
Nimbus, Look-and-Feel 1054
NIS 1145
NO_SUCH_PAGE, Printable 1142
No-Arg-Konstruktor 192
NoClassDefFoundError 1342
non-greedy operator, regulärer
Ausdruck 274
non-static-method-Fehlermeldung 157
Normalizer, Klasse 269
Normalverteilung 316
NoSuchAlgorithmException
1417
NoSuchElementException 648,
683
NoSuchProviderException 1417
Not a Number 301, 304
Notation 184
notify(), Object 606, 613
notifyAll(), Object 608
1467
1371.book Seite 1468 Mittwoch, 17. Dezember 2008 1:39 13
Index
NotSerializableException 832,
835, 837
NOVEMBER, Calendar 726
nowarn 1436
NULL 455
null, Schlüsselwort 200
NULL, SQL 1318
NullPointerException 200, 219,
470
Null-Referenz 200
Null-String 255
Number, Klasse 207
NumberFormat, Klasse 205,
294–295
NumberFormatException 258,
458
numeric promotion 116
numerische Umwandlung 116
numerischer Typ 116
O
Oak 55
Oberklasse 378
Oberklasse finden 1347
Oberlänge 1092
Obfuscator 1342, 1450
Object Management Group 185,
1209, 1222
Object Serialization Stream
Protocol 838
Object, Klasse 380, 508
ObjectInputStream, Klasse 832
Objective-C 64
ObjectName, Klasse 1396
ObjectOutputStream, Klasse 831
ObjectStreamField, Klasse 837
Objektansatz 183
Objektdiagramm 185
Objektgleichheit 510
Objektidentifikation 509
Objektmethode 97
Objektorientierung 58, 64, 100
Objektvariable 189
Objektvariable, Initialisierung
366
Observable, Klasse 436
Observer, Schnittstelle 436
Observer/Observable 436
Observer-Pattern 1005
Ocean, Look-and-Feel 1054
1468
OCTOBER, Calendar 726
ODBC 1294, 1297–1298
ODBC-DatenquellenAdministrator 1294
Oder 123
off-by-one error 144
Oktalform 108
Olson, Ken 1283
OMG 185, 1209
OMG (Object Management
Group) 1209
OO-Methode 184
opak 960
Open Database Connectivity
Standard 1298
Open MBeans 1390
OpenJDK 65
openStream(), URL 1151
Operator 116
Rang eines 125
operator precedence 124
Optionsfeld 988
Oracle 1293
OracleDriver 1304
Ordinalzahl, Aufzählung 524
Ordinalzahl, Enum 524
org.jdom, Paket 882
org.omg, Paket 507
Ostersonntag 728
OutOfMemoryError 188, 515
OutputStream, Klasse 775
OutputStreamWriter, Klasse 289,
809
OverlayLayout, Klasse 978
P
P2P 1230
Pack200 816
package, Schlüsselwort 211
PAGE_EXISTS, Printable 1142
paint(), Frame 1075
Paint, Schnittstelle 1102
paintComponent() 1077
Paket 193, 1145
Paketsichtbarkeit 341
PalmOS 1283
Palmsonntag 728
Parameter 157
Parameterliste 153, 155
Parameterübergabemechanismus 158
parametrisierte Funktion 157
parametrisierter Typ 483
parseBoolean(), Boolean 258
Parsed Character Data 860
parseDouble(), Double 258
ParseException 295, 741
parseInt(), Integer 205, 257, 458
parseObject(), Format 294
partiell abstrakte Klasse 406
Passionssonntag 728
PATH 73
Pattern, Klasse 269
pattern, regulärer Ausdruck 269
Pattern-Matcher 269
Payne, Jonathan 56
PCDATA 860
p-code 57
PDA 68
PDAP 1285
Peer-Elemente 1064
Peer-Klassen 914
Permissions 1410
PersistenceDelegate, Klasse 848
Persistenz 446, 830
Personal Digital Assistant Profile
1285
Pfad 1097
Pfingstsonntag 728
phoneMe 68
PicoJava 58
Picture Element 1079
PipedInputStream, Klasse 812
PipedOutputStream, Klasse 812
PipedReader, Klasse 812
PipedWriter, Klasse 812
pissing on at every opportunity
76
Pixel 1079
Plattenspeicher 751
Pluggable Authentication Module
(PAM) 1412
Pluggable Look & Feel 915
Plugins, Eclipse 84
PocketPC 1284
Point, Klasse 183, 187
Pointer 59
PointerInfo, Klasse 1073
Point-to-Point 1230
Polar-Methode 316
1371.book Seite 1469 Mittwoch, 17. Dezember 2008 1:39 13
Index
Policy-Datei 1408
policytool 1435
policytool, Dienstprogramm
1410
Polygon 1084
Polygon, Klasse 1084, 1095
Polyline 1084
Polymorphie 400
POP before send 1202
POP3 1197
Popup-Menü 1000
Port 1234 1173
Port, RMI-Namensdienst 1216
Port-Adresse 1169
Position des Fensters 922
POSITIVE_INFINITY 304
POST, HTTP-Methode 1182
Post-Dekrement 121
Post-Inkrement 121
POST-Methode 1161, 1181
Potenz 311
Prä-Dekrement 121
Präfix 246
Pragma 1186
Prä-Inkrement 121
Preferences, Klasse 547
Preimage-Angriffe 1415
PreparedStatement, Schnittstelle
1311, 1326
primitiver Typ 103
Primzahlen 712
Principal 1408, 1412
print() 164, 785
Printable, Schnittstelle 1140
PrinterJob, Klasse 1140
printf() 99, 785
printf(), PrintWriter/PrintStream
292
PrintJob, Klasse 1140
println() 785
println(), print() 98
PrintService, Schnittstelle 1143
printStackTrace() 457
PrintStream 785
PrintWriter 785
Priorität, Thread 577
Prioritätswarteschlange 577
PriorityQueue, Klasse 643
private, Schlüsselwort 336, 1348
PrivateKey, Schnittstelle 1418
Privatsphäre 335
Process, Klasse 543
ProcessBuilder, Klasse 541
Profil, Java ME 1284
Profiler 540
Profiling 540
Profiling-Informationen 1438
Programm 96
Programm-Icon 1122
Programmieren gegen
Schnittstellen 413
ProGuard 1450
Properties 445
Properties, Bean 446
Properties, Klasse 536, 697
Property 339
PropertyChangeEvent 453
PropertyChangeEvent, Klasse
447, 960
PropertyChangeListener, Schnittstelle 447
PropertyDescriptor, Klasse 1358
Property-Design-Pattern 445
PropertyPermission 1410
Property-Sheet 445
PropertyVetoException 450
Proposed Standard 1146
protected, Schlüsselwort 381,
1348
Protocol Handler 1156
Protocols 64
Protokoll 1146
Protokoll-Handler 1156
Proxy 1207
Proxy-Authenticate, ResponseHeader 1186
Proxy-Authorization 1160
Proxy-Server 1152
Prozess 557
Pseudo-Primzahltest 317
Public, Response-Header 1186
public, Schlüsselwort 335, 1348
PublicKey, Schnittstelle 1418
Publish-Subscribe 1230
Pulldown-Menü 991
Punktoperator 190
pure abstrakte Klasse 406
PushbackInputStream, Klasse 803
PushbackReader, Klasse 803
put(), Map 686
PUT, HTTP-Methode 1182
Q
qNaNs 303
QuadCurve2D, Klasse 1095
Quadratische Kurvensegmente
1097
Quadratwurzel 311
quadTo(), GeneralPath 1098
Quantifizierer 270
QuantumDB 1295
Quartz 634
Quasiparallelität 557
Quellcodeverschönerer 1451
Query-String 1161
Queue, Schnittstelle 643, 682
Quicksort 672
Quiet NaN 303
Quoted Printing Encoding 1197
R
race condition 589
race hazard 589
RadialGradientPaint 1102
Rahmen 949
Random 314
random(), Math 221, 313
Random, Klasse 314
RandomAccess, Schnittstelle 659
RandomAccessFile, Klasse 456,
762
Range-Checking 61
Rangordnung 124
Raw-Type 485
Reader, Klasse 783
readLine(), BufferedReader 802
readLine(), RandomAccessFile
456
readObject(), ObjectInputStream
833
readPassword(), Console 792
readResolve() 841
readUTF(), RandomAccessFile
764
ReadWriteLock, Schnittstelle 595
rebind(), Registry 1218
Rechenungenauigkeit 147
rechtsassoziativ 126
Record Management System
1290
Rectangle2D, Klasse 1095
1469
1371.book Seite 1470 Mittwoch, 17. Dezember 2008 1:39 13
Index
RectangularShape, Klasse 1095
reentrant 601
ReentrantLock, Klasse 592
ReentrantLock, Schnittstelle 606
ReentrantReadWriteLock, Klasse
595
Reference Concrete Syntax 857
referenced-Meldung 1220
Referenz 59
Referenzierung 177
Referenztyp 103, 116
Referenztyp, Vergleich mit ==
197
Referenzvariable 189
Reflection 1339
ReflectPermission 1410
reflexive Assoziation 374
reg 551
regionMatches(), String 247
Registry 547, 1209, 1215
REGISTRY_PORT, Registry 1216
regulärer Ausdruck 269
Reihung 215
reine abstrakte Klasse 406
Rekursionsform 168
rekursive Assoziation 374
Rekursive Methode 167
relational Operator 122
relationales Datenbanksystem
1297
Remainder Operator 117
Remote Manager 1389
Remote Object Activation 1224
Remote Procedure Call 1209
Remote, Schnittstelle 1213
RenderedImage, Schnittstelle
1129
Rendering-Algorithmus 1139
Renderpack Render Pipelines
1041
Rendezvous 574, 576
repaint() 1078
replace(), String 252
replaceAll(), Collections 702
replaceAll(), String 252
replaceFirst(), String 252
ReplicateScaleFilter, Klasse 1129
Request 1182
Request For Comment 1145
requestFocusInWindow(),
JComponent 952
1470
Request-Header 1184
reservierte Schlüsselwörter 92
ResourceBundle, Klasse 719
Response-Header 1184, 1186
Rest der Division 312
Restwert-Operator 116–117
Restwertoperator 312
Result, Schnittstelle 901
Resultat 115
ResultSet, Schnittstelle 1313
ResultSetMetaData, Schnittstelle
1329
resume(), Thread 577
RetentionPolicy, Aufzählung
1379
Re-Throwing 474
Retry-After, Response-Header
1186
return, Schlüsselwort 159, 226
revalidate(), JComponent 959
Reverse-Engineering-Tool 186
RFC 1145
RFC 1521 290
RFC 1952 1187
RFC 2616 1181
RGB 1107
Rhino 545
Rich Text Format 1024
rint(), Math 310
RMI 1209
RMI Wire Protocol 1210
rmi:// 1218
rmic, Dienstprogramm 1215
RMIClassLoader, Klasse 1222
rmid, Dienstprogramm 1224
RMI-Klassenlader 1222
RMI-Logging 1220
rmiregistry, Dienstprogramm
1216, 1310
RMI-Transportschicht 1210
Robot, Klasse 1073
Rollbalken 978
Rollenbasierte Rechtevergabe
1411
Rollrad 955
Ron Rivest 1415
Rotation 1139
round(), Math 309
RoundingMode, Aufzählung 324
RoundRectangle2D, Klasse 1095
Roundtrip-Engineering 186
Router 1145
RowFilter, Klasse 1041
RowSet, Schnittstelle 1322
RPC 1209
rt.jar 529
RTF 1024
Rückgabetyp 153
Rückgabewert 155
Rumpf 153
run(), Runnable 561
Runden 309
Rundungsfehler 118
Rundungsmodi, BigDecimal 323
runFinalizersOnExit(), System
522
Runnable, Schnittstelle 498, 561
Runtime 541
Runtime Packages 1401
RuntimeException 469
Runtime-Interpreter 57
RuntimePermission 1410
S
Sandbox 1403
Saturation 1107
SAX 866
SAXBuilder 884
SAXBuilder, Klasse 884
SAXParser, Klasse 878
SCALE_AREA_AVERAGING,
Image 1128
SCALE_DEFAULT, Image 1127
SCALE_FAST, Image 1128
SCALE_REPLICATE, Image 1128
SCALE_SMOOTH, Image 1128
Scanner, Klasse 278
Schablonen-Muster 776
Schaltjahr 714
ScheduledThreadPoolExecutor,
Klasse 580, 586
Scheduler 557, 587
Schema 861
Scherung 1139
Schieberegler 978
Schlange 643
Schleifen 140
Schleifenbedingung 142, 146
Schleifen-Inkrement 144
Schleifentest 144
Schleifenzähler 144
1371.book Seite 1471 Mittwoch, 17. Dezember 2008 1:39 13
Index
Schlüssel 644
Schlüsselpaare 1413
Schlüsselspeicher 1414
Schlüsselwörter 92
Schnittstelle 64, 409
Schnittstellentypen 189
Schriftlinie 1085
Schurken 713
schwergewichtige Komponente
914
Schwyzerdütsch 721
Scope 114
Screen_Updater 579
ScriptEngine, Schnittstelle 546
ScriptEngineManager, Klasse 545
Scriptlet 1253
Scrollable, Schnittstelle 962
Scrollbar 978
ScrollPaneLayout, Klasse 978
sealing, Jar 495
SECOND, Calendar 731
SecretKey, Schnittstelle 1418
SecretKeySpec, Klasse 1419
Secure Hash Algorithm 1415
Secure Hash Standard 1415
Secure Sockets Layer 1205
SecureRandom, Klasse 315
SecurityException 1408
Security-Manager 59, 1404
SecurityManager, Klasse 1268,
1403–1404
SecurityPermission 1410
Seed 315
Seiteneffekt 331
Sekunde 731
Selbstbeobachtung 445
Semantik 87
semantisches Ereignis 932
Semaphore, Klasse 616
Separator 88
SEPTEMBER, Calendar 726
SEQUEL 1333
Sequence, Klasse 553
SequenceInputStream, Klasse 779
Sequencer 553
Sequencer, Schnittstelle 553
Sequenz 638, 643
Sequenzdiagramm 186
Serializable, Schnittstelle 835
SerializablePermission 1410
serialPersistentFields 837
serialver, Kommandozeilenprogramm 844
serialVersionUID 844
Server 1209
Server, Response-Header 1186
ServerSocket, Klasse 1173
Service 443
Service Provider Implementation
507
ServiceLoader, Klasse 1303
Service-Provider 443
Session, Klasse 1198, 1201
Set, Schnittstelle 643, 674
setBorder(), JComponent 949
setContentType(), JEditorPane
1024
setDefaultCloseOperation(),
JFrame 920, 939
setDefaultRenderer(), JTable
1035
setDoInput(), URLConnection
1155
setDoOutput(), URLConnection
1155
setFont(), Graphics 1086
setLayout(), Container 965
setLookAndFeel(), UIManager
1055
setModel(), JSpinner 1016
setModel(), JTable 1030
setPaint(), Graphics2D 1102
setPriority(), Thread 577
setProperty(), Properties 697
setRenderingHint(), Graphics2D
1094
setSize(), Window 921
Setter 339
setText(), JButton 942
setText(), JLabel 926
setText(), JTextComponent 1019
Set-Top-Boxen 56
setVisible(), Window 921
SGML 856
SHA 1415
Shallow Copy 694
Shamir, Adi 1415
Shape, Schnittstelle 1094–1095
shared objects 1427
ShellFolder, Klasse 749
Sheridan, Mike 55
Shift 125
Shift-Operator 172
SHORT, DateFormat 737
short, Datentyp 103, 108, 299
Short, Klasse 207
Short-Circuit-Operator 124
showConfirmDialog(), JOptionPane 1050
showMessageDialog(), JOptionPane 1050
showOptionDialog(), JOptionPane
1050
SHS 1415
Shutdown-Hook 635
Sicherheitsmanager 1403–1404,
1407
Sichtbarkeit 114, 335, 381
Sichtbarkeitsmodifizierer 335
signal(), Condition 606
signaling NaN 303
Signatur 153
Signierung 1408, 1412
Simple API for XML Parsing 866
Simple Mail Transfer Protocol
1196
SimpleDateFormat, Klasse 736
SIMPLIFIED_CHINESE, Locale
716
SIMULA 64
Simula-67 181
sin(), Math 308
Single Inheritance 380
SINGLE_INTERVAL_SELECTION,
ListSelectionModel 1013
SINGLE_SELECTION, ListSelectionModel 1013
Singleton 364, 706
sinh(), Math 308
Sinus 308
sizeof 177
Skalierung 1139
Skipjack 1415
Skript-Engine 545
Slash 744
sleep(), Thread 567
slider, Schieberegler 978
Slivka, Ben 76
Smalltalk 58, 181
Smart-Card 1412
Smiley 92
SMTP 1196
SMTP-Server 1197
1471
1371.book Seite 1472 Mittwoch, 17. Dezember 2008 1:39 13
Index
sNaN 303
SOAP 1224
SOCK_DGRAM 1204
SOCK_STREAM 1204
Socket, Klasse 1169
SocketPermission 1410
Sockets 1168
SOCKS 1153
SoftBevelBorder, Klasse 950
Sommerzeitabweichung 731
sort(), Arrays 231, 669
sort(), Collections 671
SortedMap, Schnittstelle 686
SortedSet, Schnittstelle 678
Sortieren 671
Soundbank 553
Source, Schnittstelle 901
Source-Code Beautifier 1451
späte dynamische Bindung 400
SpinnerDateModel, Klasse 1016
SpinnerListModel, Klasse 1016
SpinnerModel, Schnittstelle 1016
SPI-Pakete 507
Splash-Screen 1123
split(), Pattern 277
split(), String 277
Spring-Framework 443
SpringLayout, Klasse 965
Sprungmarken 151
SQL 1333
SQL 2 1333
SQLException 1319
SQLWarning, Klasse 1319
SQuirreL 1295
SSL 1205
SSLSocket, Klasse 1205
SSLSocketFactory, Klasse 1205
stabil sortieren 671
stabiler Sortieralgorithmus 673
Stack 680
Stack, Klasse 680
Stack-Inhalt 478
Stack-Speicher 188
Stack-Trace 476
StackTraceElement, Klasse 477
Standard Extension API 507
Standard Generalized Markup
Language 856
Standard MBeans 1389
Standard Tag Library 1247
Standard Widget Toolkit 1072
1472
Standardberechtigungen 1409
Standard-Konstruktor 192, 356
Standardserialisierung 831
Stapelspeicher 680
Star Seven 56
stark typisiert 102
start(), Thread 562
startsWith(), String 246
statement 95
Statement, Schnittstelle 1311
static final 410
static, Schlüsselwort 101, 345
statisch typisiert 102
statische Eigenschaft 344
statische innere Klasse 491
statische Methode 97, 156
statischer Block 368
statischer Import 213
Statusanzeige 989
Statuscode 1184
Statuszeile 1184
StAX 868
Stellvertreterobjekt 1207, 1215
Sternzeit 713
Steuerelement, Grafisches 913
stilles NaN 303
STL-Bibliothek 672
stop(), Thread 571
Store-and-Forward 1196
StreamEncoder 809
StreamFilter, Schnittstelle 873
StreamTokenizer, Klasse 849
streng typisiert 102
strictfp, Schlüsselwort 314
StrictMath, Klasse 314
String 99, 238
StringBuffer, Klasse 259
StringBuilder, Klasse 259
StringIndexOutOfBoundsException 247–248
Stringkonkatenation 125
Stringlänge 242
String-Literale 240
StringReader, Klasse 774, 795
Strings, Anhängen an 249
Stringteil vergleichen 247
Stringteile extrahieren 247
StringTokenizer, Klasse 283
StringWriter, Klasse 793
Stroke, Schnittstelle 1111–1112
Stroustrup, Bjarne 182
Structured English Query
Language 1333
Subinterface 417
Subject 1412
Subklasse 378
Subprotokoll 1305
Substitutionsprinzip 388
substring(), String 248
Subtraktion 116
Suffix 247
SUID 844
Summe aller Einträge 1337
sun, Paket 193
sun.boot.class.path 530
sun.jdbc.odbc.JdbcOdbcDriver
1304
sun.nio.cs 809
SunWorld 56
super() 383, 385
super, Generics 488
super, Schlüsselwort 385, 393
Superklasse 378
Surrogate-Paar 88
suspend(), Thread 577
SWIG 1433
swing.properties 1054
SwingUtilities, Klasse 1066
SwingWorker, Klasse 1066
SwingWT 1073
switch-Anweisung 137
Swixml 1071
SWT 1072
symbolische Konstante 349
Symbolleiste 998
sync() 773
Synchronisation 522, 586
synchronized, Schlüsselwort 591,
596
SynerJ 76
Syntax 87
synthetische Methode 492
System.err 101, 790
System.in 541, 777, 790
System.out 101, 790
SystemColor, Klasse 1102, 1107
Systemeigenschaften 73, 536
Systemfarben 1107
System-Klassenlader 530
SystemTray, Klasse 1004
1371.book Seite 1473 Mittwoch, 17. Dezember 2008 1:39 13
Index
T
TableCellEditor, Schnittstelle
1036
TableCellRenderer, Schnittstelle
1033
TableColumn, Klasse 1038
TableLayout, Klasse 978
TableModel, Schnittstelle 1028,
1038
TableModelEvent, Klasse 1032
TableModelListener, Schnittstelle 1028
TableRowSorter, Klasse 1040
Tabulator 284
Tag 730, 855
Tag des Jahres 731
Tage im Monat 734
Tagesdatum 733
TagLib 1247
TagLib-Deskriptoren 1247
TAI 714
TAIWAN 716
Taj Mahal 64
tan(), Math 308
Tangens 308
tangle 421
Tango Desktop Projekt 930
tanh(), Math 308
Tar-Archiv 817
Tastatur-Shortcut 995
Tastenkürzel 995
TCP 1190
TCP/IP 1168
Tear-off-Menü 992
Teletubbies 1162
template pattern 776
Template-Code 1238
Terminiert 578
TextArea, Klasse 1022
TextLayout, Klasse 1092
TexturePaint 1102
this und Vererbung 499
this$0, innere Klasse 495
this() 385
this(), Beschränkungen 361
this(), Konstruktoraufruf 360
this-Referenz 332, 385
this-Referenz, innere Klasse 493
Thread 557
Thread, Klasse 498, 562
ThreadDeath, Klasse 573
ThreadGroup, Klasse 625
Thread-Gruppe 629
thread-local storage (TLS) 622
ThreadLocal, Klasse 622
thread-lokale Variablen 622
Thread-Pool 580
ThreadPoolExecutor, Klasse 580
Throwable, Klasse 466
throws, Schlüsselwort 459
tick marks 978
tiefe Kopie, clone() 517
tiefe Objektkopie 517, 841
timeout 1210
Timer, Klasse 633
Timer, Swing-Klasse 1070
TimerTask, Klasse 633
Timestamp, Klasse 1316
Titelleiste 920
TitledBorder, Klasse 950
TLS 1205
toArray(), Collection 663
Tödliche Umarmung 603
Token 87, 284
toLowerCase(), Character 238
toLowerCase(), String 250
Tomcat 1234
Toolkit, Klasse 918
Topic, JMS 1230
Top-Level-Container 918
Top-Level-Klassen 491
toString(), Arrays 232
toString(), Integer 256
toString(), Object 391, 509
toString(), Point 191
toUpperCase(), Character 238
toUpperCase(), String 250
Transferable, Schnittstelle 1057
Transfer-Encoding 1186
TransferHandler, Klasse 1061
Transformation 1102
transient, Schlüsselwort 837
translate(), Graphics 1135
Transparency, Schnittstelle 1102
TransparentLayout 977
Transport Layer Security 1205
Transportschicht 1210
TrayIcon, Klasse 1004
TreeMap, Klasse 638, 644, 684
TreeModel, Schnittstelle 1041,
1043
TreeNode, Schnittstelle 1043
TreeSelectionListener,
Schnittstelle 1043
TreeSet, Klasse 677
Trennzeichen 88, 276
trim(), String 251
true, Schlüsselwort 103
TrueType-Zeichensatz 1090
TrueZIP 817
try, Schlüsselwort 455
Tupel 1291
Typanpassung 126
type erasure 484
TYPE_INT_RGB, BufferedImage
1125
TYPE_SCROLL_INSENSITIVE,
ResultSet 1318
Typecast 127
Types, Klasse 1314
Typ-Variable 482
Typvergleich 125
U
Überblendung, Grafik 1111
überdecken, Methoden 402
überladene Methode 99, 163
überladener Operator 62
überladenes Plus 132
überlagert, Methode 391
Überlauf 304
überschreiben, Methoden 390
Übersetzer 72
Überwachtes Warten 611
UCSD-Pascal 57
UDP-Protokoll 1189–1190
UIDefaults, Klasse 926
UI-Delegate 957
UIManager, Klasse 1055
UK, Locale 716
Umgebungsvariablen, Betriebssystem 539
Umkehrfunktionen 308
UML 184
Umlaut 91
Umrisslinie 1111
Umrisslinie, Stroke 1102
unärer Operator 115
unäres Minus 119
Unäres Plus/Minus 125
unbenanntes Paket 212
1473
1371.book Seite 1474 Mittwoch, 17. Dezember 2008 1:39 13
Index
Unboxing 208
UncaughtExceptionHandler,
Schnittstelle 570
unchecked 555
unchecked exception 470
Und 123
UNDECIMBER, Calendar 726
Undo/Redo 1061
UndoableEditEvent, Klasse 1063
UndoManager, Klasse 1061
Unendlich 301
UnicastRemoteObject, Klasse
1218
Unicast-Verbindung 1205
UNICODE_CASE, Pattern 272
Unicode-Escape 91
Unicode-Zeichen 88
unidirektionale Beziehung 373
Unified Method 184
Uniform Resource Locator 1146
Universal Time 713
UnknownHostException 1169
unlock(), Lock 591
Unmarshaller, Schnittstelle 904
unnamed package 212
UnsatisfiedLinkError 1424
UnsupportedOperationException 470, 476, 642, 649,
663, 705
Unterklasse 378
Unterlänge 1092
Untermenü 991
Unzahl 117
Upgrade 1186
upper-bound wildcard 489
URL 1146
URL, Klasse 1146
URLClassLoader, Klasse 531
URLConnection, Klasse 1153
URLDecoder, Klasse 1162
URLEncoder, Klasse 1161
US, Locale 716
Use-Cases-Diagramm 185
user.timezone 727
UTC 714
UTF-16-Kodierung 88, 858
UTF-8-Kodierung 764, 858
Utility-Klasse 364
UUencode 1197
1474
V
valid, XML 859
valueOf() 202
valueOf(), String 256
values(), Map 691
Varargs 226
variable Argumentanzahl 226
Variablendeklaration 105
Variableninitialisierung 403
Vary, Response-Header 1186
Vector, Klasse 651
veränderbare Zeichenketten 259
Verbindungsloses Protokoll 1190
Verbindungsorientiert 1190
-verbose 1438
verbose 1436
Verbundoperator 120
Verdecken von Variablen 332
vererbte Konstante 418
Vererbung 377
Vergleichsoperator 122
Vergleichsstring 247
verkettete Liste 639, 661
Verklemmung 558, 604
Verlaufsbalken 989
Verschiebeoperator 172
Verschiebung 1139
Verzeichnis anlegen 752
Verzeichnis umbenennen 752
Vetorecht 446
View 1005
ViewPortLayout, Klasse 978
virtuelle Maschine 57
Visual Age for Java 75
Visual Basic 251
void, Schlüsselwort 156
volatile, Schlüsselwort 619
Vorschaubild 1117
Vorzeichenerweiterung 125
Vorzeichenumkehr 119
W
Wahrheitswert 102
wait(), Object 606, 613
War-Archiv 1236
Warning, Response-Header 1186
Warning:Applet Window 1408
Watson, Thomas 1207
WAV 552
weave 421
WEB 421
Web Application Security 1266
Web-Applets 56
Webbrowser 1025
WebRowSet, Schnittstelle 1323–
1324
WebRunner 56
Webstart 1280
Wechselknopf 946
WEEK_OF_MONTH, Calendar
731
WEEK_OF_YEAR, Calendar 730
Weichzeichnen 1081, 1138
Well-known System Ports 1169
Wertebereich 338
Werte-Objekt 203
Wertoperation 115
Wertübergabe 157–158
Wettlaufsituation 589
while-Schleife 141
WHITE, Color 1105
Whitespace 88
widening conversion 127
Widget 913
Wiederholungsfaktor 270
Wiederverwendung per Copy &
Paste 131
Wildcard 489
Win32-API 76
WinCE 1283
WIND_NON_ZERO, GeneralPath 1099
Winding Rule 1099
windowClosed(), WindowListener 939
windowClosing(), WindowListener 939
WindowEvent, Klasse 935
WindowListener, Schnittstelle
933
Windows Icon-Format 1117
Windows-NT Konsole 288
Windows-Registry 551
Windungsregel 1099
Winkelfunktionen 308
WinZip 71
Wireless Toolkit 1285
wissenschaftliche Notation 110
Woche 731
wohlgeformt 857
1371.book Seite 1475 Mittwoch, 17. Dezember 2008 1:39 13
Index
WORA 66
Workbench, Eclipse 80
Worker-Thread 1068
Workspace 78
World Wide Web 56
Wrapper-Klasse 201
write once, run anywhere 66
writeObject(), ObjectOutputStream 832
Writer, Klasse 781
writeReplace() 841
writeUTF(), RandomAccessFile
764
wsimport, Dienstprogramm
1226, 1228
Wurzelelement 887
Wurzelverzeichnis 749
WWW-Authenticate, ResponseHeader 1186
X
X.509 1413
XAML 1071
-Xbootclasspath 530
XDoclet 1383
Xerces 867
XHTML 865
XML 856
XML User Interface Language
1072
XMLDecoder, Klasse 846
XMLEncoder, Klasse 846
XMLEvent, Klasse 869
XMLEventFactory, Klasse 874
XMLEventReader, Klasse 872
XMLEventReader, Schnittstelle
874
XMLEventWriter, Klasse 869
XMLEventWriter, Schnittstelle
875
XMLInputFactory, Klasse 874
XMLOutputFactory, Klasse 874
XMLOutputter, Klasse 885
XMLStreamConstants, Schnittstelle 870
XMLStreamReader, Schnittstelle
869
XMLStreamWriter, Klasse 869
XMLStreamWriter, Schnittstelle
874
-Xms 1438
-Xmx 1438
-Xnoclassgc 1438
XOPEN-SQL-Status 1319
Xor 123, 172, 1076
Xor-Modus, Zeichnen 1111
XPath 896, 899
XPath, Klasse 897
XPath-Wurzel 896
-Xprof 1438
-Xrs 1438
XSLT 899
-Xss 1438
XStream 848
XUL 1072
Y
YEAR, Calendar 730
yield(), Thread 569
Z
Zeichen anhängen 260
Zeichen ersetzen 252
Zeichenbereich 1102
Zeichenkette 99
Zeichenklassen 270
Zeichenkodierung 288
Zeiger 59
Zeilenkommentar 96
Zeilentrenner 284
Zeilenumbruch 537
Zeitablauf 1210
Zeitgenauigkeit 722
Zeitmessung 540
Zeitzone 714, 739
Zeitzonenabweichung 731
Zertifizierungsstelle 1412
ZipEntry, Klasse 821
ZipFile, Klasse 821
zirkuläre Assoziation 374
ZONE_OFFSET, Calendar 731
Zufallszahl 313, 318
Zufallszahlengenerator 315
Zugriffsmethode 339
Zugriffsmodifizierer 1353
zusammengesetzte Bedingung
134
Zustände, Threads 566
Zustandsänderung 453
Zuweisung 108, 125
Zuweisung mit Operation 125
zweidimensionales Feld 222
Zweierkomplement 299
zweistelliger Operator 115
Zwischenablage 1056
zyklische Redundanzprüfung 828
Zahlenwert, Unicode-Zeichen 88
Zeichen 102, 111
1475