;-_=_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 • •