Table Of Content;-_=_Scrolldown to the Underground_=_-;
Java ist auch eine Insel
http://kickme.to/tiger/
Christian Ullenboom
Java ist auch
eine Insel
Ein Kurs in Java und
objektorientierter
Programmierung
Mit Programmen für die
Java 2 Plattform
Vorwort 18
1 Schon wieder eine neue Sprache? 23
1.1 HistorischerH intergrund ......................................................................................... 24
1.2 Eigenschaften von Java ........................................................................................... 25
1.2.1 Die virtuelle Maschine ............................................................................................ 25
1.2.2 Konzepte einer modernen Programmiersprache ..................................................... 26
1.3 Java in Vergleich zu anderen Sprachen ................................................................... 29
1.4 Die Rolle von Java im Web ..................................................................................... 30
1.5 Aufkommen von Stand-Alone-Applikationen ........................................................ 30
1.6 Entwicklungsumgebungen ...................................................................................... 31
1.7 ErstesP rogrammc ompilierenu ndt esten ................................................................ 34
1.7.1 Häufige Compiler- und Interpreterprobleme ........................................................... 36
2 Sprachbeschreibung 38
2.1 Grundlagen der Sprache Java .................................................................................. 38
2.1.1 Textcodierungd urchU nicode-Zeichen ................................................................... 38
2.1.2 Kommentare ............................................................................................................ 39
2.1.3 Bezeichner ............................................................................................................... 40
2.1.4 Reservierte Schlüsselwörter .................................................................................... 40
2.1.5 Token ....................................................................................................................... 41
2.1.6 Semantik .................................................................................................................. 41
2.2 Anweisungenu ndP rogramme ................................................................................ 41
2.2.1 Programme .............................................................................................................. 42
2.2.1 Funktionsaufrufe als Anweisung ............................................................................. 42
2.2.1 Die leere Anweisung ............................................................................................... 43
2.2.2 DerB lock ................................................................................................................. 43
2.3 Datentypen ............................................................................................................... 44
2.3.1 Primitive Datentypen ............................................................................................... 44
2.3.2 Wahrheitswerte ........................................................................................................ 45
2.3.3 Variablendeklarationen ............................................................................................ 45
2.3.1 GanzzahligeD atentypen .......................................................................................... 46
2.3.2 Die Fließkommazahlen ............................................................................................ 46
2.3.3 Zeichen .................................................................................................................... 47
2.3.4 Automatische Anpassung der Größe bei Zuweisungen ........................................... 47
2.4 Ausdrücke ................................................................................................................ 48
2.4.1 Operatoren ............................................................................................................... 48
2.4.2 Divisionu ndM odulo ............................................................................................... 50
2.5 Verzweigungen ........................................................................................................ 52
2.5.1 Die ›if‹ und ›if/else‹ Anweisung .............................................................................. 52
2.5.2 ›switch‹ bietet die Alternative ................................................................................. 55
2.6 Schleifen .................................................................................................................. 58
•
•
•
ii •
•
•
2.6.1 Die ›while‹ Schleife ................................................................................................. 58
2.6.2 Die ›do/while‹ Schleife ............................................................................................ 59
2.6.3 Die ›for‹ Schleife ..................................................................................................... 60
2.6.4 Multilevelb reaku ndc ontinue ................................................................................. 63
2.7 Methodene inerK lasse ............................................................................................ 63
2.7.1 RekursiveF unktionen .............................................................................................. 65
2.8 Noch mehr Operatoren ............................................................................................ 68
2.8.1 Bit-Operationen ....................................................................................................... 68
2.8.2 Die Verschiebe-Operatoren ..................................................................................... 69
2.8.1 Anwendungf ürB itoperatorenu ndS hift ................................................................. 71
2.8.2 Unterklassenp rüfen ................................................................................................. 74
2.8.3 DerB edingungsoperator .......................................................................................... 74
2.8.4 Überladenes Plus für Strings ................................................................................... 76
3 Klassen und Objekte 77
3.1 ObjektorientierteP rogrammierung .......................................................................... 77
3.1.1 Warum überhaupt OOP? ......................................................................................... 77
3.1.2 Modularität und Wiederverwertbarkeit ................................................................... 78
3.2 Klassenb enutzen ..................................................................................................... 78
3.2.1 Anlegen eines Exemplars einer Klasse .................................................................... 79
3.2.2 Zugriff auf Variablen und Funktionen mit dem Punkt ............................................ 80
3.3 Eigene Klassen definieren ....................................................................................... 81
3.3.1 Argumentübergabe .................................................................................................. 82
3.3.2 Lokale Variablen ..................................................................................................... 83
3.3.3 Die this-Referenz ..................................................................................................... 83
3.3.4 Initialisierung von lokalen Variablen ...................................................................... 84
3.3.5 Privatsphäre ............................................................................................................. 84
3.4 Statische Methoden und Variablen .......................................................................... 86
3.4.1 Statische Variablen .................................................................................................. 86
3.4.2 Statische Methoden ................................................................................................. 86
3.4.3 Konstanten mit dem Schlüsselwort final bei Variablen .......................................... 87
3.4.4 Der Einstiegspunkt für das Laufzeitzeitsystem ....................................................... 87
3.4.1 Der Rückgabewert von main() ................................................................................ 89
3.5 Methodenü berladen ................................................................................................ 89
3.6 Objektea nlegenu ndz erstören ................................................................................ 90
3.6.1 Die Erschaffung von Objekten ................................................................................ 90
3.6.2 Zerstörung eines Objekts durch den Müllaufsammler ............................................ 92
3.7 GegenseitigeA bhängigkeitenv onK lassen ............................................................. 93
3.8 Vererbung ................................................................................................................ 94
3.8.1 Methodenü berschreiben ......................................................................................... 96
3.9 Abstrakte Klassen und Interfaces ............................................................................ 96
3.9.1 AbstrakteK lassen .................................................................................................... 96
3.9.2 Schnittestellen( Interfaces) ...................................................................................... 98
3.9.3 Erweitern von Interfaces – Subinterfaces .............................................................. 100
•
•
•
• iii
•
•
3.9.4 Statische Initialisierung einer Schnittstelle ........................................................... 100
3.10 InnereK lassen ....................................................................................................... 102
3.10.1 Implementierung einer verketteten Liste ............................................................... 102
3.10.1 Funktionszeiger ..................................................................................................... 104
3.11 Pakete .................................................................................................................... 105
3.12 Arrays .................................................................................................................... 106
3.12.1 Deklaration und Initialisierung .............................................................................. 107
3.12.2 Zugriff auf die Elemente ....................................................................................... 108
3.12.3 Arraysu ndO bjekte ................................................................................................ 109
3.12.4 Mehrdimensionale Arrays ..................................................................................... 110
3.12.5 AnonymeF elder .................................................................................................... 112
3.12.6 Die Wahrheit über die Array-Initialisierung ......................................................... 113
3.12.7 Arrays kopieren und füllen .................................................................................... 114
4 Exceptions 116
4.1 Problembereiche einzäunen ................................................................................... 116
4.1.1 Exceptions in Java ................................................................................................. 116
4.1.2 Alles geht als Exception durch .............................................................................. 117
4.1.3 Die Throws-Klausel ............................................................................................... 118
4.1.4 Abschließende Arbeiten mit finally ....................................................................... 118
4.2 Exceptions sind nur Objekte .................................................................................. 119
4.2.1 Auswerfenv onE xceptions .................................................................................... 119
4.2.1 NeueE xception-Klassend efinieren ...................................................................... 120
4.3 Die Exception-Objekte in Java .............................................................................. 120
4.4 EinA sserti nJ ava .................................................................................................. 122
4.5 Sicherheitsfragen mit dem SecurityManager klären ............................................. 126
4.5.1 Programm beenden ................................................................................................ 126
5 Die Funktionsbibliothek 127
5.1 Die Java-Klassenphilosophie ................................................................................. 127
5.2 Die unterste Klasse Object .................................................................................... 128
5.2.1 Aufbau der Klasse Object ...................................................................................... 128
5.3 Wrapper-Klassen (auch Ummantelungs-Klassen) ................................................ 132
5.3.1 Die Character Klasse ............................................................................................. 132
5.3.2 Die Boolean Klasse ............................................................................................... 133
5.3.3 Die Number Klasse ................................................................................................ 134
5.3.4 Methodend erW rapper-Klassen ............................................................................ 135
5.3.1 Unterschiedliche Ausgabeformate ......................................................................... 138
5.3.1 Zahlenbereiche kennen .......................................................................................... 139
5.4 Ausführungv onP rogrammeni nd erK lasseR untime ........................................... 140
5.5 Compilierenv onK lassen ...................................................................................... 140
5.5.1 Vorcompilierung durch einen JIT ......................................................................... 140
•
•
•
iv •
•
•
5.5.2 Der Sun Compiler .................................................................................................. 141
6 Der Umgang mit Zeichenketten 143
6.1 Stringsu ndd erenA nwendung .............................................................................. 143
6.1.1 Wie die String-Klasse benutzt wird ....................................................................... 143
6.1.2 String-Objekte verraten viel .................................................................................. 145
6.2 Teile im String ersetzen ......................................................................................... 146
6.3 Zeichenkodierungen umwandeln ........................................................................... 147
6.4 Durchlaufen eines Strings mit der Klasse StringCharacterIterator ....................... 147
6.5 Der Soundex Code ................................................................................................. 152
6.6 Sprachabhängiges Vergleichen mit der Collator-Klasse ....................................... 155
6.7 Die Klasse StringTokenizer ................................................................................... 157
6.7.1 EinW ortzerlegerm itG eschwindigkeitsbetrachtung ............................................. 159
6.7.2 AutomatischerW ortumbruch ................................................................................ 161
6.8 StreamTokenizer .................................................................................................... 162
6.9 Formatieren mit Format Objekten ......................................................................... 165
6.9.1 Ausgaben formatieren ........................................................................................... 166
6.9.2 Dezimalzeichenf ormatieren .................................................................................. 169
6.10 Reguläre Ausdrücke in Java mit gnu.regexp ......................................................... 170
7 Mathematisches 173
7.1 Arithmetiki nJ ava ................................................................................................. 173
7.2 Die Funktionen der Math Bibliothek ..................................................................... 174
7.3 Die Random-Klasse ............................................................................................... 175
7.4 Große Zahlen ......................................................................................................... 176
7.4.1 Die Klasse BigInteger ............................................................................................ 176
7.4.2 Ganz lange Fakultäten ........................................................................................... 178
7.4.1 Konstruktoren und BigInteger Objekte verschieden erzeugen .............................. 178
7.5 Problemem itJ avau ndd erM athematik ................................................................ 180
7.6 Das Java Matrix Paket Jama .................................................................................. 181
8 Raum und Zeit 183
8.1 Wichtige Datums Klassen im Überblick ............................................................... 183
8.2 Die Klasse Date ..................................................................................................... 183
8.2.1 Zeitmessung und Profiling .................................................................................... 186
8.3 Die abstrakte Klasse Calendar ............................................................................... 187
8.4 DerG regorianischeK alender ................................................................................ 188
8.4.1 Zeitzonen durch die Klasse TimeZone repräsentiert ............................................. 192
•
•
•
• v
•
•
8.5 Formatierend erD atumsangaben ........................................................................... 193
8.5.1 Mit DateFormat und SimpleDateFormat formatieren ........................................... 194
8.5.1 Parsen von Texten ................................................................................................. 200
8.5.1 Parsen und Formatieren ab bestimmten Positionen ............................................... 202
9 Threads 203
9.1 Prozesse und Threads ............................................................................................ 203
9.1.1 Wie parallele Programme die Geschwindigkeit heben ......................................... 204
9.2 Die Zustände eines Threads ................................................................................... 205
9.2.1 Erzeugen eines Threads ......................................................................................... 205
9.3 Threads schlafen .................................................................................................... 208
9.3.1 Das Ende eines Threads ......................................................................................... 210
9.3.1 Arbeit niederlegen und wieder aufnehmen ............................................................ 212
9.4 Priorität .................................................................................................................. 212
9.5 Dämonen ................................................................................................................ 214
9.6 Kooperative und Nicht-Kooperative Threads ....................................................... 214
9.7 Synchronisation ..................................................................................................... 215
9.8 Beispiel Producer/Consumer ................................................................................. 216
9.9 Nachrichtenaustausch zwischen zwei Threads ...................................................... 218
9.10 ErzeugteT hreadsz ählen ........................................................................................ 218
9.11 Grenzen von Threads ............................................................................................. 220
9.12 Finde alle Threads, die gerade laufen .................................................................... 220
9.13 Gruppen von Threads in einer ThreadGroup ......................................................... 221
9.13.1 Threads in einer ThreadGroup anlegen ................................................................. 224
9.13.1 Threadu ndT hreadGroupM ethodeni mV ergleich ............................................... 226
9.14 Einen Abbruch der virtuellen Maschine erkennen ................................................ 227
10 Datenstrukturen und Algorithmen 229
10.1 Mit einem Iterator durch die Daten wandern ........................................................ 229
10.1.1 Bauernregelna ufzählen ......................................................................................... 230
10.2 DynamischeD atenstrukturen ................................................................................ 231
10.3 Die Vector Klasse .................................................................................................. 232
10.3.1 Ein Polymorphie-Beispiel zur Klasse Vector ........................................................ 235
10.3.1 Eine Aufzählung und gleichzeitiges Verändern .................................................... 237
10.3.1 Die Funktionalität eines Vectors erweitern ........................................................... 238
10.4 Stack, der Stapel .................................................................................................... 239
10.4.1 Das oberste Stackelement duplizieren ................................................................... 239
10.4.2 Ein Stack ist ein Vector – Aha! ............................................................................. 241
10.5 Die Klasse BitSet für Bitmengen .......................................................................... 241
•
•
•
vi •
•
•
10.6 Die Klasse Hashtable ............................................................................................. 243
10.6.1 Ein Hashtable Objekt erzeugen ............................................................................. 243
10.6.2 Einfügen und Abfragen der Datenstruktur ............................................................ 244
10.6.3 Die Arbeitsweise einer Hashtabelle ....................................................................... 245
10.6.4 Klonen ................................................................................................................... 246
10.6.5 Aufzählend erE lemente ........................................................................................ 247
10.6.6 Ausgabe der Hashtabelle und Gleichheitstest ....................................................... 248
10.7 Die abstrakte Klasse Dictionary ............................................................................ 249
10.8 Die Properties Klasse ............................................................................................ 250
10.9 Queue, die Schlange .............................................................................................. 254
10.10 Die Collection API ................................................................................................ 256
10.10.1 Die Schnittstelle Collection ................................................................................... 256
10.10.2 Schnittstellen, die Collection erweitern ................................................................. 257
10.10.3 Abstrakte Collection Klassen als Basisklassen ..................................................... 258
10.10.4 Konkrete Container-Klassen ................................................................................. 259
10.10.5 Das erste Collection Programm ............................................................................. 259
10.10.1 Iteratoren ................................................................................................................ 260
10.10.2 DerC omperator ..................................................................................................... 261
10.11 Listen ..................................................................................................................... 262
10.11.1 AbstractList ........................................................................................................... 263
10.11.1 ArrayList ................................................................................................................ 266
10.11.1 LinkedList .............................................................................................................. 267
10.12 Algorithmen ........................................................................................................... 267
10.12.1 Datenmanipulation ................................................................................................ 268
10.12.2 Größte und kleinste Werte einer Collection finden ............................................... 270
10.12.3 Sortieren ................................................................................................................ 271
10.12.1 Elemente in der Collection suchen ........................................................................ 273
10.13 Typsichere Datenstrukturen ................................................................................... 273
10.14 EinD esign-Patternd urchB eobachtenv onÄ nderungen ....................................... 275
10.14.1 DesignP attern ....................................................................................................... 275
10.14.2 Das Beobachter-Pattern (Observer/Observable) ................................................... 275
10.14.1 Compiler mit generischen Klassen: Pizza ............................................................. 278
11 Datenströme und Dateien 279
11.1 Übersichtü berw ichtigsteS tream-u ndW riter/Reader-Klassen ........................... 280
11.1.1 Die abstrakten Basisklassen .................................................................................. 281
11.2 Ein- und Ausgabeklassen Input/OutputStream ..................................................... 281
11.2.1 Die Klasse OutputStream ...................................................................................... 282
11.2.2 EinD atenschlucker ................................................................................................ 283
11.2.1 Die Eingabeklasse InputStream ............................................................................. 284
11.2.2 Anwenden der Klasse FileInputStream ................................................................. 284
11.2.1 Anwendung der FileOutputStream Klasse ............................................................ 285
11.2.1 Kopieren von Dateien ............................................................................................ 286
11.2.1 Daten filtern durch FilterInputStream/FilterOutputStream ................................... 287
•
•
•
• vii
•
•
11.2.2 Derb esondererF ilterP rintStream ......................................................................... 289
11.2.3 System Ein- und Ausgabe und Input- PrintStreams .............................................. 290
11.2.1 Bytes in den Strom mit ByteArrayOutputStream .................................................. 294
11.2.2 Die SequenceInputStream Klasse .......................................................................... 295
11.3 Die Writer Klassen ................................................................................................ 297
11.3.1 Die abstrakte Klasse Writer ................................................................................... 298
11.3.2 Datenkonvertierung durch den OutputStreamWriter ............................................ 299
11.3.3 In Dateien schreiben mit der Klasse FileWriter .................................................... 301
11.3.1 StringWriter und CharArrayWriter ....................................................................... 302
11.4 Erweitern der Writer Funktionalität ...................................................................... 304
11.4.1 Gepufferte Ausgabe durch BufferedWriter ........................................................... 304
11.4.1 Ausgabemöglichkeiten durch PrintWriter erweitern ............................................. 306
11.4.2 Daten mit FilterWriter filtern ................................................................................ 308
11.5 Die Reader Klassen ............................................................................................... 313
11.5.1 Die abstrakte Basisklasse Reader .......................................................................... 313
11.5.2 Automatische Konvertierungen mit dem InputStreamReader .............................. 315
11.5.3 Dateien lesen mit der Klasse FileReader ............................................................... 316
11.5.1 StringReaderu ndC harArrayReader ...................................................................... 317
11.5.1 Schachtelnv onE ingabe-Streams .......................................................................... 318
11.5.2 Gepufferte Eingaben mit der Klasse BufferedReader ........................................... 318
11.5.1 LineNumberReader zählt automatisch Zeilen mit ................................................. 320
11.5.1 Eingaben filtern mit der Klasse FilterReader ........................................................ 321
11.5.1 Daten wieder zurück in den Eingabestrom mit PushbackReader .......................... 323
11.6 Dateien ................................................................................................................... 326
11.6.1 Das File Objekt ...................................................................................................... 326
11.6.2 Die Wurzel aller Verzeichnisse ............................................................................. 328
11.6.1 Verzeichnisse listen und Dateien filtern ................................................................ 329
11.6.1 Änderungsdatum einer Datei ................................................................................. 332
11.6.1 Dateien mit wahlfreiem Zugriff (Random-Access-Files) ...................................... 333
11.7 Datenkompression ................................................................................................. 336
11.7.1 Datenströmek omprimieren ................................................................................... 337
11.7.1 ZIPD ateien ............................................................................................................ 340
11.8 Prüfsummen ........................................................................................................... 347
11.8.1 Die Schnittstelle Checksum ................................................................................... 347
11.8.2 Die Klasse CRC32 ................................................................................................. 348
11.8.1 Die Adler-32 Klasse .............................................................................................. 350
11.9 Persistente Objekte und Serialisierung .................................................................. 351
11.9.1 Objektes peichern .................................................................................................. 351
11.9.2 Objektel esen ......................................................................................................... 353
11.9.3 Das Inferface Serializable ...................................................................................... 354
11.9.4 Beispiele aus den Standardklassen ........................................................................ 356
11.9.5 Wie funktioniert Serialisierung? ............................................................................ 361
12 Grafikprogrammierung mit dem AWT 364
12.1 Fenster (Windows) unter grafischen Oberflächen ................................................. 364
•
•
•
viii •
•
•
12.1.1 Fensterö ffnen ........................................................................................................ 364
12.2 Grundlegendes zum Zeichnen ............................................................................... 367
12.2.1 Die paint() Methode .............................................................................................. 367
12.3 Punkte und Linien .................................................................................................. 369
12.4 Rechtecke aller Art ................................................................................................ 370
12.5 Alles was rund ist .................................................................................................. 371
12.6 Linenzüge sind Polygone und Poylines ................................................................. 372
12.6.1 Die Polygon-Klasse ............................................................................................... 373
12.6.2 N-Eckez eichnen .................................................................................................... 374
12.6.1 VollschlankeL inienz eichnen ............................................................................... 376
12.7 Zeichenketten schreiben ........................................................................................ 377
12.7.1 Einenn euenZ eichensatzb estimmen ..................................................................... 377
12.7.2 Zeichensätze des Systems ermitteln ...................................................................... 378
12.7.1 Die Klasse FontMetrics ......................................................................................... 380
12.7.2 Logischeu ndn ativeF ontnameni nf ont.properties ............................................... 381
12.8 Clipping-Operationen ............................................................................................ 384
12.9 Farben .................................................................................................................... 387
12.9.1 Zufällige Farbblöcke zeichnen .............................................................................. 388
12.9.1 Farbbereichez urückgeben ..................................................................................... 389
12.9.2 VordefinierteF arben ............................................................................................. 390
12.9.3 Farben aus Hexadezimalzahlen erzeugen .............................................................. 390
12.9.1 Einen helleren und dunkleren Farbton wählen ...................................................... 392
12.9.2 Farben nach Namen auswählen ............................................................................. 393
12.9.1 Farbmodelle HSB und RGB .................................................................................. 395
12.9.2 Die Farben des Systems ......................................................................................... 395
12.10 Bilder anzeigen und Grafiken verwalten ............................................................... 400
12.10.1 Die Grafik zeichnen ............................................................................................... 402
12.10.1 Grafikenz entrieren ................................................................................................ 404
12.10.2 Laden von Bildern mit dem MediaTracker beobachten ........................................ 404
12.10.3 Kein Flackern durch Double-Buffering ................................................................. 409
12.11 Von Produzenten, Konsumenten und Beobachtern ............................................... 411
12.11.1 Producer und Consumer für Bilder ........................................................................ 411
12.11.2 Beispiel für die Übermittlung von Daten .............................................................. 412
12.11.3 EinP PMG rafikL adera lsI mageConsumer .......................................................... 414
12.11.4 Bilder selbst erstellen ............................................................................................ 415
12.11.1 Die Bildinformationen wieder auslesen ................................................................ 419
12.12 Alles wird bunt mit Farbmodellen ......................................................................... 421
12.12.1 Die abstrakte Klasse ColorModel .......................................................................... 422
12.12.2 Farbwerte im Pixel mit der Klasse DirectColorModel .......................................... 424
12.12.3 Die Klasse IndexColorModel ................................................................................ 425
12.13 Grafikens peichern ................................................................................................. 428
12.13.1 Bilder im GIF-Format speichern ........................................................................... 428
12.13.1 GifS peichernm itd emA CMEP aket .................................................................... 430
12.13.2 JPEG Dateien mit dem Sun Paket schreiben ......................................................... 430
•
•
•
• ix
•
•
