Java Tutorial - Wilkening

Transcription

Objektorientiertes Programmieren in Java - V. 29
Seite 1 / 409
Objektorientiertes Programmieren
in
Java
Detlef Wilkening
www.wilkening-online.de
© 1997-2016
Version 29
Dieses Java Tutorial darf in unveränderter Form für
Unterrichtszwecke weitergegeben und verwendet werden.
Der Autor freut sich aber über Rückmeldungen zum Einsatz des Tutorials.
© Detlef Wilkening 1997-2016
http://www.wilkening-online.de
Seite 2 / 409
Objektorientiertes Programmieren in Java
1 Organisatorisches ......................................................................................................... 13
2 Java ................................................................................................................................ 14
2.1 Einleitung .................................................................................................................... 15
2.2 Java als Plattform........................................................................................................ 15
2.3 Java Versionen ........................................................................................................... 21
2.4 Technologien .............................................................................................................. 27
2.5 Fazit ............................................................................................................................ 30
3 Mini-Einführung ............................................................................................................. 30
3.1 Applikation .................................................................................................................. 31
3.2 Quelltext ...................................................................................................................... 32
3.3 Ausgabe ...................................................................................................................... 35
3.4 Strings ......................................................................................................................... 36
3.5 Arrays und Kommandozeilen-Argumente .................................................................... 36
3.6 Klassen ....................................................................................................................... 37
3.7 Funktionen .................................................................................................................. 37
3.8 Packages .................................................................................................................... 38
3.9 Exceptions .................................................................................................................. 39
3.10 Eingabe .................................................................................................................. 40
3.11 Konvertierungen ..................................................................................................... 43
4 Praktikum ....................................................................................................................... 43
4.1 Tools ........................................................................................................................... 43
4.2 Source Organisation ................................................................................................... 54
4.3 Benutzung der JDK Entwicklungs-Tools...................................................................... 54
4.4 Projekt Tools ............................................................................................................... 67
4.5 Source-Path und Class-Path ....................................................................................... 68
4.6 Eclipse ........................................................................................................................ 70
4.7 Projekte importieren .................................................................................................... 85
4.8 Aufgaben..................................................................................................................... 90
4.9 Lsg. zu Aufgabe „Hallo Welt“ – Kap. 4.8.1 .................................................................. 92
4.10 Lsg. zu Aufgabe „GUI-Fenster“ – Kap. 4.8.2 .......................................................... 93
4.11 Lsg. zu Aufgabe „Package“ – Kap. 4.8.3 ................................................................ 93
4.12 Lsg. zu Aufgabe „Packages“ – Kap. 4.8.4 .............................................................. 93
4.13 Lsg. zu Aufgabe „Summe“ – Kap. 4.8.5 .................................................................. 94
4.14 Lsg. zu Aufgabe „Ausgabe Verzeichnis“ – Kap. 4.8.6 ............................................. 97
5 Elementare Datentypen und Variablen ......................................................................... 98
5.1 Datentypen .................................................................................................................. 98
5.2 Elementare Datentypen............................................................................................... 99
5.3 Variablen ................................................................................................................... 101
Seite 3 / 409
5.4 Wert- und Referenz-Semantik ................................................................................... 102
6 Operatoren ................................................................................................................... 105
6.1 Zuweisungs-Operatoren ............................................................................................ 106
6.2 Gleich- und Ungleich-Operatoren .............................................................................. 106
6.3 Geteilt- und Modulo-Operator .................................................................................... 108
6.4 Bitweises AND, OR, XOR ......................................................................................... 110
6.5 Boolsches bzw. bedingtes AND, OR, XOR ............................................................... 110
6.6 Prä- und Post-Inkrement und -Dekrement Operatoren .............................................. 111
6.7 Schiebe-Operatoren .................................................................................................. 111
6.8 Frage-Zeichen Operator ............................................................................................ 112
6.9 Aufgaben................................................................................................................... 112
6.10 Lsg. zu Aufgabe „Inkrement-Operator“ – Kap. 6.9.1 ............................................. 112
7 Kontroll-Strukturen...................................................................................................... 113
7.1 Bedingter-Kontrollfluss – If ........................................................................................ 113
7.2 Mehrfach-Verzweigung – Switch ............................................................................... 117
7.3 For-Schleife ............................................................................................................... 119
7.4 For-Schleife für Container und Arrays ....................................................................... 120
7.5 While-Schleife ........................................................................................................... 120
7.6 Do-Schleife ............................................................................................................... 121
7.7 Break- und Continue-Anweisung ............................................................................... 121
7.8 Gelabelte Sprung-Anweisungen ................................................................................ 122
7.9 Aufgaben................................................................................................................... 123
7.10 Lsg. zu Aufgabe „Schleifen-Varianten“ – Kap. 7.9.1 ............................................. 125
7.11 Lsg. zu Aufgabe „Teilbar?“ – Kap. 7.9.2 ............................................................... 126
7.12 Lsg. zu Aufgabe „Lesbare Zahlen“ – Kap. 7.9.3 ................................................... 127
7.13 Lsg. zu Aufgabe „Zahlen-Liste“ – Kap. 7.9.4......................................................... 128
7.14 Lsg. zu Aufgabe „Mittelwert und Varianz“ – Kap. 7.9.5 ......................................... 131
7.15 Lsg. zu Aufgabe „Multiplikations-Matrix“ – Kap. 7.9.6 ........................................... 132
8 Funktionen ................................................................................................................... 134
8.1 Funktions-Arten ......................................................................................................... 135
8.2 Syntaktischer Aufbau ................................................................................................ 135
8.3 Variablen in Funktionen............................................................................................. 135
8.4 Funktions-Parameter ................................................................................................. 137
8.5 Funktions-Rückgaben ............................................................................................... 138
8.6 Überladen ................................................................................................................. 139
8.7 Rekursion .................................................................................................................. 140
8.8 Aufgaben................................................................................................................... 141
8.9 Lsg. zu Aufgabe „Fakultäts Funktion“ – Kap. 8.8.1.................................................... 143
8.10 Lsg. zu Aufgabe „Primzahl?“ – Kap. 8.8.2 ............................................................ 145
8.11 Lsg. zu „Aufgabe „Schleife rekursiv“ – Kap. 8.8.3 ................................................. 146
8.12 Lsg. zu Aufgabe „Zahlen-Liste 2“ – Kap. 8.8.4...................................................... 146
8.13 Lsg. zu Aufgabe „Quadratwurzel“ – Kap. 8.8.5 ..................................................... 147
Seite 4 / 409
9 Ausgewählte Bibliotheks-Klassen .............................................................................. 152
9.1 Klasse String ............................................................................................................. 153
9.2 Klassen StringBuilder & StringBuffer ......................................................................... 156
9.3 Container & Iteratoren ............................................................................................... 157
9.4 Wrapper Klassen ...................................................................................................... 176
9.5 Zufalls-Zahlen ........................................................................................................... 178
9.6 Datum und Uhrzeit .................................................................................................... 179
9.7 Datei- und Verzeichnis-Handling ............................................................................... 180
9.8 Aufgaben................................................................................................................... 187
9.9 Lsg. zu Aufgabe „String-Analyse“ – Kap. 9.8.1.......................................................... 192
9.10 Lsg. zu Aufgabe „Hallo <Person>“ – Kap. 9.8.2 .................................................... 196
9.11 Lsg. zu Aufgabe „Hallo <Personen>“ – Kap. 9.8.3 ................................................ 196
9.12 Lsg. zu Aufgabe „Lesbare Zahlen 2“ – Kap. 9.8.4 ................................................ 198
9.13 Lsg. zu Aufgabe „Lottozahlen“ – Kap. 9.8.5 .......................................................... 200
9.14 Lsg. zu Aufgabe „Telefonbuch“ – Kap. 9.8.6 ........................................................ 201
9.15 Lsg. zu Aufgabe „Platten-Platz Verbrauch“ – Kap. 9.8.7 ....................................... 202
9.16 Lsg. zu Aufgabe „Datei-Suche“ – Kap. 9.8.8......................................................... 203
10 Arrays ........................................................................................................................... 204
10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
10.9
Deklaration ........................................................................................................... 204
Arrays haben ein Attribut: length........................................................................... 205
Arrays durchlaufen ............................................................................................... 206
Arrays sind Referenzen ........................................................................................ 206
Arrays können mehrdimensional sein ................................................................... 207
Fehlerhafter Index ................................................................................................ 208
Vergleiche ............................................................................................................ 208
Aufgaben .............................................................................................................. 209
Lsg. zu Aufgabe „Lesbare Zahlen 3“ – Kap. 10.8.1............................................... 209
11 Klassen ......................................................................................................................... 210
11.1
11.2
11.3
11.4
11.5
11.6
11.7
11.8
Motivation ............................................................................................................. 210
Klassen-Entwurf ................................................................................................... 211
Beispiel ................................................................................................................. 212
Klassen-Implementierung ..................................................................................... 215
Aufgaben .............................................................................................................. 220
Lsg. zu Aufgabe „Ringzähler“ – Kap. 11.5.1 ......................................................... 223
Lsg. zu Aufgabe „Kontaktdaten 1“ – Kap. 11.5.2 .................................................. 225
Lsg. zu Aufgabe „Kontaktdaten 2“ – Kap. 11.5.3 .................................................. 228
12 Klassen-Details ............................................................................................................ 229
12.1
12.2
12.3
12.4
12.5
Zugriffsbereiche .................................................................................................... 229
Konstruktoren ....................................................................................................... 230
finalize .................................................................................................................. 231
Funktionen ............................................................................................................ 232
Attribute ................................................................................................................ 235
12.6
12.7
12.8
12.9
12.10
12.11
Seite 5 / 409
Aufzählungen........................................................................................................ 236
Top-Level-Klassen ................................................................................................ 239
Aufgaben .............................................................................................................. 239
Lsg. zu Aufgabe „Türme von Hanoi“ – Kap. 12.8.1 ............................................... 244
Lsg. zu Aufgabe „Gerüchteküche“ – Kap. 12.8.2 .................................................. 246
Lsg. zu Aufgabe „Tic-Tac-Toe 1“ – Kap. 12.8.3 .................................................... 250
13 Packages ...................................................................................................................... 271
13.1
13.2
13.3
13.4
13.5
13.6
Package-Anweisung ............................................................................................. 271
Klassen in Packages ............................................................................................ 272
Language-Package .............................................................................................. 273
Verschachtelung ................................................................................................... 273
Default-Package ................................................................................................... 273
Verzeichnisse ....................................................................................................... 274
14 Vererbung..................................................................................................................... 274
14.1
14.2
14.3
14.4
14.5
14.6
14.7
14.8
14.9
14.10
14.11
14.12
14.13
14.14
14.15
14.16
14.17
14.18
14.19
14.20
14.21
14.22
14.23
14.24
Vererbungs-Hierarchien........................................................................................ 274
Implementation ..................................................................................................... 275
Schlüsselwort super.............................................................................................. 276
Konstruktoren ....................................................................................................... 276
finalize .................................................................................................................. 277
Überschreiben ...................................................................................................... 277
Ist-ein Beziehung .................................................................................................. 279
Polymorphie.......................................................................................................... 279
abstract................................................................................................................. 280
Casts und instanceof ............................................................................................ 281
Klasse „java.lang.Object“ ...................................................................................... 283
Anwendung – Beispiel „Obstkorb“ ........................................................................ 285
Interfaces.............................................................................................................. 293
Modul-Entkopplung ............................................................................................... 294
Fazit...................................................................................................................... 297
Aufgaben .............................................................................................................. 297
Lsg. zu Aufgabe „Obstkorb“ – Kap. 14.16.1 .......................................................... 299
Lsg. zu Aufgabe „ProgressBar“ – Kap. 14.16.2 .................................................... 299
Lsg. zu Aufgabe „Kontaktdaten 3“ – Kap. 14.16.3 ................................................ 300
Lsg. zu Aufgabe „Tic-Tac-Toe 2“ – Kap. 14.16.5 .................................................. 303
15 Innere Klassen ............................................................................................................. 308
15.1
15.2
15.3
Eingebettete static Klassen .................................................................................. 309
Eingebettete nicht static Klassen .......................................................................... 310
Eingebettete Interface’s ........................................................................................ 311
15.4
15.5
15.6
Seite 6 / 409
Lokale Klassen ..................................................................................................... 311
Anonyme Klassen ................................................................................................. 313
Virtuelle Maschine ................................................................................................ 314
16 GUI Programmierung mit Swing................................................................................. 314
16.1
16.2
16.3
16.4
16.5
16.6
16.7
16.8
16.9
Ein einfaches Fenster ........................................................................................... 316
Ein etwas besseres Fenster.................................................................................. 317
Ein grafisches „Hallo Welt“ ................................................................................... 318
Graphics Objekt .................................................................................................... 320
Klasse „Color“ ....................................................................................................... 321
Änderung der Oberfläche in den Windows-Style .................................................. 322
Aufgaben .............................................................................................................. 324
Lsg. zu Aufgabe „Schwebende Kugel“ – Kap. 16.7.1 ............................................ 325
Lsg. zu Aufgabe „Farb-Fenster“ – Kap. 16.7.2...................................................... 325
17 Philosophie der GUI Programmierung ....................................................................... 325
17.1
17.2
Besitzer des Bildschirms ....................................................................................... 325
Kontrollfluß ........................................................................................................... 326
18 Event-Modelle von Swing............................................................................................ 327
18.1
18.2
18.3
18.4
18.5
18.6
Events und Gruppierungen ................................................................................... 327
Internes Event-Modell ........................................................................................... 328
Externes Event-Modell .......................................................................................... 333
Vergleich der Event-Modelle ................................................................................. 345
Scribble 4 mit Daten-Modell .................................................................................. 345
Aufgaben .............................................................................................................. 348
19 Swing Layouts ............................................................................................................. 348
19.1
19.2
19.3
19.4
19.5
19.6
19.7
Swing Klasse „JButton“......................................................................................... 349
Grundlagen ........................................................................................................... 349
Layouts ................................................................................................................. 350
Verschachtelte Layouts ........................................................................................ 353
Aufgaben .............................................................................................................. 354
Lsg. zu Aufgabe „Layouts 1“ – Kap. 19.5.1 ........................................................... 354
Lsg. zu Aufgabe „Layouts 2“ – Kap. 19.5.2 ........................................................... 354
20 Swing GUI-Elemente.................................................................................................... 354
20.1
20.2
20.3
20.4
20.5
20.6
20.7
20.8
20.9
Labels ................................................................................................................... 354
Text-Felder ........................................................................................................... 355
Buttons ................................................................................................................. 357
Radio-Buttons ....................................................................................................... 358
Check-Boxen ........................................................................................................ 359
Scroll-Bars und Scroll-Panes ................................................................................ 361
Tabellen................................................................................................................ 361
Panels .................................................................................................................. 365
Menüs................................................................................................................... 365
20.10
20.11
20.12
20.13
20.14
20.15
Seite 7 / 409
Timer .................................................................................................................... 367
Aufgaben .............................................................................................................. 369
Lsg. zu Aufgabe „Liste“ – Kap. 20.11.1................................................................. 370
Lsg. zu Aufgabe „Scribble 6“ – Kap. 20.11.2 ........................................................ 370
Lsg. zu Aufgabe „TextField“ – Kap. 20.11.3.......................................................... 370
21 Applets ......................................................................................................................... 370
21.1
21.2
21.3
21.4
21.5
21.6
21.7
21.8
Beispiel ................................................................................................................. 370
Applet HTML-Seite ............................................................................................... 371
Grundlagen ........................................................................................................... 373
Applet-Parameter ................................................................................................. 374
Applets & Applikationen ........................................................................................ 375
Aufgaben .............................................................................................................. 376
Lsg. zu Aufgabe „Statuszeilen-Applet“ – Kap. 21.6.1 ............................................ 376
Lsg. zu Aufgabe „Scribble 7“ – Kap. 21.6.2 .......................................................... 376
22 Exceptions ................................................................................................................... 376
22.1
22.2
22.3
22.4
22.5
22.6
22.7
22.8
22.9
22.10
22.11
22.12
Motivation ............................................................................................................. 376
Realisation ............................................................................................................ 377
Fehler über mehrere Funktions-Ebenen ............................................................... 378
Aufräumarbeiten und „finally“ ................................................................................ 379
Exception-Objekte und Exception-Hierarchie........................................................ 381
Fangen von Basis-Exception-Klassen .................................................................. 382
Mehrere catch-Blöcke ........................................................................................... 383
Unbehandelte Exceptions ..................................................................................... 384
Geprüfte und ungeprüfte Exceptions .................................................................... 385
Verschachtelte try-Blöcke ..................................................................................... 387
Exception-Objekte ................................................................................................ 390
Exception-Sicherheit ............................................................................................. 391
23 Streams ........................................................................................................................ 393
23.1
23.2
23.3
23.4
Einführung ............................................................................................................ 393
Java Streams........................................................................................................ 393
Beispiele ............................................................................................................... 397
Stream-Tokenizer ................................................................................................. 399
24 Reflexion ...................................................................................................................... 400
24.1
24.2
24.3
24.4
24.5
Objekt-Erzeugung über den Klassen-Namen ....................................................... 400
Klasse „Class“ ...................................................................................................... 402
Disassemblieren ................................................................................................... 404
Aufgaben .............................................................................................................. 404
Lsg. zu Aufgabe „Klassen-Inspektor“ – Kap. 24.4.1 .............................................. 404
25 Serialisierung ............................................................................................................... 405
25.1
Interface Serializable ............................................................................................ 405
25.2
25.3
25.4
25.5
25.6
25.7
Seite 8 / 409
Rekursion ............................................................................................................. 406
Klassen-Variablen................................................................................................. 408
Modifier „transient“ ................................................................................................ 408
Nicht serialisierbare Basis-Klassen ....................................................................... 409
Aufgaben .............................................................................................................. 409
Lag. zu Aufgabe „Scribble 7“ – Kap. 25.6.1 .......................................................... 409
Abbildungen
Abb. 2-1 : Executable-Abhängigkeit zu einer konkreten Plattform ........................................ 16
Abb. 2-2 : Executables für mehrere Plattformen ................................................................... 16
Abb. 2-3 : Executable für mehrere Plattformen entwickeln ................................................... 17
Abb. 2-4 : Idee einer virtuellen Maschine.............................................................................. 17
Abb. 2-5 : Portabilität mit einer VM und genormtem Byte-Code ........................................... 18
Abb. 3-1 : Oracle Homepage – Einstieg in den Download des JDK...................................... 32
Abb. 4-1 : Oracle Homepage – Einstieg in den Download des JDK...................................... 45
Abb. 4-2 : Oracle Java Download Seite – JDK Auswahl ....................................................... 46
Abb. 4-3 : Oracle JDK Download Seite – Plattform auswählen und downloaden .................. 47
Abb. 4-4 : Oracle Java Download Seite – JDK Dokumentation Auswahl .............................. 48
Abb. 4-5 : Oracle JDK Doku Download Seite – Doku auswählen und downloaden............... 48
Abb. 4-6 : Installiertes JDK – Aufruf der JVM ....................................................................... 49
Abb. 4-7 : Aufruf des Java-Compilers nach gesetzter Path Umgebungs-Variable ................ 49
Abb. 4-8 : Aufruf des Java-Compilers mit vollem Pfad ......................................................... 50
Abb. 4-9 : Entpackte Java Dokumentation ........................................................................... 50
Abb. 4-10 : Java Dokumentations Einstieg „index.html“ ....................................................... 51
Abb. 4-11 : Eclipse Homepage – Wechsel zur Download Seite............................................ 52
Abb. 4-12 : Eclipse Download-Seite – Eclipse IDE for Java Developers ............................... 53
Abb. 4-13 : „Hallo Welt“ Quelltext im Editor (Datei „e:\java\HalloWelt.java“) ......................... 55
Abb. 4-14 : Kommandozeile für das Verzeichnis „e:\java“ .................................................... 56
Abb. 4-15 : Der Java Compiler erzeugt den Byte-Code des „Hallo Welt“ Beispiels .............. 57
Abb. 4-16 : Die virtuelle Java Maschine (JVM) führt das „Hallo Welt“ Beispiel aus ............... 57
Abb. 4-17 : GUI Quelltext im Editor (Datei „e:\java\Gui.java“) ............................................... 58
Abb. 4-18 : Der Java Compiler erzeugt den Byte-Code des GUI Beispiels ........................... 58
Abb. 4-19 : Die virtuelle Java Maschine (JVM) führt das GUI Beispiel aus ........................... 59
Abb. 4-20 : Der Java Compiler erzeugt den Byte-Code aller Klassen im Verzeichnis ........... 59
Abb. 4-21 : Package Quelltext im Editor (Datei „PackageBeispiel.java“) .............................. 60
Abb. 4-22 : Verzeichnis-Struktur für das Package Beispiel................................................... 60
Abb. 4-23 : Der Java Compiler erzeugt den Byte-Code des Package Beispiels ................... 61
Abb. 4-24 : Fehler bei der Ausführung des Package Beispiels ............................................. 61
Abb. 4-25 : Der Java Compiler erzeugt den Byte-Code mit „sourcepath“ Option .................. 62
Abb. 4-26 : Korrekte Ausführung des Package Beispiels ..................................................... 63
Abb. 4-27 : Fehler bei Ausführung außerhalb des Wurzel-Verzeichnisses ........................... 63
Abb. 4-28 : Korrekte Ausführung des Package Beispiels mit Class-Path Option „-cp“.......... 64
Abb. 4-29 : Ausgangs Struktur für Byte-Code eigene Verzeichnisse .................................... 65
Abb. 4-30 : Der Java Compiler erzeugt den Byte-Code mit Trennung des Byte-Codes ........ 65
Abb. 4-31 : Erzeugte Verzeichnis Struktur und Byte-Code ................................................... 66
Seite 9 / 409
Abb. 4-32 : Korrekte Ausführung des Package Beispiels mit Trennung des Byte-Codes ..... 66
Abb. 4-33 : Kommandozeilen Argument Quelltext im Editor (Datei „e:\java\Args.java“) ........ 67
Abb. 4-34 : Compilation und Ausführung des Kommandozeilen Argumente Beispiels ......... 67
Abb. 4-35 : 2 Klassen in zwei parallelen Packages .............................................................. 69
Abb. 4-36 : Klassen, Dateien, Packages, Verzeichnisse und der Source-Path..................... 69
Abb. 4-37 : Eclipse Workspace Launcher ............................................................................ 71
Abb. 4-38 : Eclipse Begrüßungs Bildschirm.......................................................................... 72
Abb. 4-39 : Eclipse Begrüßungs Bildschirm schließen ......................................................... 72
Abb. 4-40 : Leerer Workspace in der Java Perspektive........................................................ 73
Abb. 4-41 : Neues Projekt anlegen....................................................................................... 74
Abb. 4-42 : Projekt-Wizard ................................................................................................... 75
Abb. 4-43 : Workspace mit neuem „Hallo Welt“ Projekt ....................................................... 76
Abb. 4-44 : Neue Klasse anlegen ......................................................................................... 77
Abb. 4-45 : Klassen-Wizard.................................................................................................. 78
Abb. 4-46 : Warnung bei Nutzung des Default-Packages .................................................... 79
Abb. 4-47 : Warnung bei fehlerhaftem Klassen-Namen ....................................................... 79
Abb. 4-48 : Neue Klasse „HalloWeltAppl“ im Workspace ..................................................... 80
Abb. 4-49 : Fertiger Quelltext im Wizard .............................................................................. 81
Abb. 4-50 : Starten des Programms ..................................................................................... 83
Abb. 4-51 : Ausgabe des Programms .................................................................................. 83
Abb. 4-52 : Eclipse Warnungs Preferences für „serialVersionUID“ ....................................... 85
Abb. 4-53 : Eclipse Warnungs Preferences für „typlose Container“ ...................................... 85
Abb. 4-54 : Ausgepackter Tutorial Workspace auf “E:” ........................................................ 86
Abb. 4-55 : Neuer Eclipse Workspace für die Tutorial Beispiele ........................................... 87
Abb. 4-56 : Kontext-Menü mit Import Eintrag ....................................................................... 87
Abb. 4-57 : Import Wizard Seite 1 ........................................................................................ 88
Abb. 4-58 : Import Wizard Seite 2 ........................................................................................ 89
Abb. 4-59 : Der fertig importierte Eclipse Workspace ........................................................... 90
Abb. 5-1 : Wert-Semantik ................................................................................................... 103
Abb. 5-2 : Referenz-Semantik ............................................................................................ 104
Abb. 9-1 : Ein String-Objekt wird nicht verändert ................................................................ 155
Abb. 9-2 : Ein StringBuilder-Objekt wird verändert ............................................................. 157
Abb. 9-3 : Warnungen des Java-Compilers wegen der Nutzung untypisierter Container.... 162
Abb. 9-4 : Warnungen der Eclipse 3.7.2 wegen der Nutzung untypisierter Container ........ 163
Abb. 9-5 : Vererbungs-Hierarchie der Wrapper-Klassen .................................................... 178
Abb. 10-1 : Referenz-Semantik bei Arrays ......................................................................... 207
Abb. 10-2 : Speicher-Layout eines mehrdimensionalen Arrays .......................................... 207
Abb. 10-3 : Speicher-Layout eines nicht-rechteckigen Arrays ............................................ 208
Abb. 11-1 : Das Schlüsselwort heißt „Abstraktion“ ............................................................. 210
Abb. 11-2 : Objekt-Kapselung und Benutzung über die Schnittstelle .................................. 210
Abb. 11-3 : Klassen und Objekte am Beispiel von Autos .................................................... 211
Abb. 11-4 : Funktionen ohne bzw. mit Objekt-Bezug .......................................................... 217
Abb. 12-1 : Türme von Hanoi ............................................................................................. 240
Abb. 14-1 : Vererbungs-Hierarchie ..................................................................................... 274
Abb. 14-2 : Allgemeine Vererbungs-Hierarchie .................................................................. 274
Seite 10 / 409
Abb. 14-3 : Vererbungs-Hierarchie des Beispiels ............................................................... 276
Abb. 14-4 : 2 Schicht-Architektur eines Programms ........................................................... 294
Abb. 14-5 : Abhängigkeit in einer 2 Schicht-Architektur ...................................................... 295
Abb. 14-6 : Design der Modul-Entkopplung ........................................................................ 295
Abb. 16-1 : Ein grafisches „Hallo Welt“ Programm ............................................................. 318
Abb. 16-2 : Ein GUI Programm mit bunter Ausgabe im Fenster ......................................... 321
Abb. 16-3 : GUI-Fenster aus Kapitel 19.4 mit Swing-Style ................................................. 322
Abb. 16-4 : GUI-Fenster aus Kapitel 19.4 mit Windows-Style ............................................ 323
Abb. 16-5 : Fenster mit schwebender Kugel ....................................................................... 324
Abb. 17-1 : Aufbau klassischer Programme ....................................................................... 326
Abb. 17-2 : Aufbau Event-gesteuerter Programme............................................................. 326
Abb. 18-1 : Der Fluß eines Events...................................................................................... 328
Abb. 18-2 : Ein einfaches Scribble Zeichen-Programm ...................................................... 331
Abb. 18-3 : Klassen-Diagramm Observer-Pattern .............................................................. 334
Abb. 18-4 : Interaktion Observer-Pattern ............................................................................ 334
Abb. 18-5 Klassen-Diagramm Observer-Pattern in Java ................................................... 334
Abb. 19-1 : Ein Fenster mit einem Button ........................................................................... 349
Abb. 19-2 : Die Content-Pane enthält nur den letzten Button ............................................. 350
Abb. 19-3 : Fenster mit Border-Layout ............................................................................... 351
Abb. 19-4 : Fenster mit Flow-Layout................................................................................... 351
Abb. 19-5 : Fenster mit Grid-Layout ................................................................................... 352
Abb. 19-6 : Fenster mit verschachtelten Layouts ................................................................ 353
Abb. 20-1 : Fenster mit Label ............................................................................................. 355
Abb. 20-2 : Fenster mit Text-Feld und automatischer Längen-Angabe .............................. 356
Abb. 20-3 : Fenster mit Button im initialen Zustand und nach dreimaliger Betätigung ........ 357
Abb. 20-4 : Fenster mit einer Gruppe von Radio-Buttons ................................................... 359
Abb. 20-5 : Fenster mit drei Check-Boxen .......................................................................... 360
Abb. 20-6 : Fenster mit einfacher 4x3 Tabelle .................................................................... 362
Abb. 20-7 : Fenster mit 40x30 Tabelle ohne Scrollbar ........................................................ 362
Abb. 20-8 : Fenster mit 40x30 Tabelle mit Scrollbar ........................................................... 363
Abb. 20-9 : Fenster mit Tabelle, dessen Inhalt aus einem Array stammt ............................ 364
Abb. 20-10 : Fenster mit Tabelle mit Tabellen-Modell ........................................................ 365
Abb. 20-11 : Fenster mit Menü ........................................................................................... 367
Abb. 20-12 : Fenster in grün und in rot – gesteuert von einem Timer ................................. 368
Abb. 22-1 : Ein kleiner aber wichtiger Teil der Exception-Hierarchie in Java ...................... 381
Abb. 22-2 : Klassen-Hierarchie für unsere Beispiel File-Exceptions ................................... 382
Abb. 23-1 : Ein nicht näher spezifizierter Datenstrom ......................................................... 393
Abb. 23-2 : Bsp für ineinander gekapselte Streams ........................................................... 394
Abb. 23-3 : Arbeitsweise der Stream-Kapselung ................................................................ 394
Versions-Historie
Version
Veränderte Kapitel
Seite 11 / 409
29
April 2016
• In vielen Kapiteln Rechtschreibfehler und kleine Ausdrucksfehler beseitigt.
• Text in hoffentlich allen Kapiteln an die neuen Versionen von Java (JDK 1.8.0_u77)
und Eclipse 4.5.2 (Mars) angepaßt – Screenshots sind noch auf dem alten Stand.
• Viele Kapitel in Kapitel 6 über Operatoren überarbeitet – aber noch nicht fertig.
• Einführendes Kapitel 3.9 über „Exceptions“ überarbeitet und leicht erweitert.
• Einführendes Kapitel 3.10 über „Einlesen von der Kommandozeile“ aktualisiert.
• Alle Quelltexte in den Kapiteln 8-11 mit Syntax-Highlighting versehen.
• Kleine Änderungen in Kapitel 8.
• Mehrere Fehler in den Beispielen von Kapitel 9 beseitigt, außerdem noch mehrfach in
den Beispielen die Typ-Angabe bei Containern vereinfacht.
• In den Musterlösungen zu Kapitel 11 auf typisierte Container umgestellt.
• Kapitel 12.2.1 über Attribut-Initialisierungen erweitert
• Kapitel 12.6 über Enums komplett neu geschrieben
28
April 2015
• Text in hoffentlich allen Kapiteln an die neuen Versionen von Java (JDK 1.8.0_u40),
Eclipse 4.4.2 (Luna) und NetBeans angepaßt.
• Beschränkungen auf alte JDKs entfernt – das Tutorial geht jetzt defaultmäßig immer
von einem JDK 1.8 aus.
• Alle Quelltexte in den Kapiteln 1-7 mit Syntax-Highlighting versehen.
• Viele kleine Erweiterungen, Anpassungen und Vereinfachungen im Kapitel 3.
• Kapitel 4 in vielen Teilen erweitert, so z.B. ein neues Kapitel für den Import von
Projekten in einen Eclipse-Workspace. Außerdem alle Abbildungen erneuert und an
Java 8 und Eclipse 4.4 angepaßt.
• Viele kleine Erweiterungen, Anpassungen und Vereinfachungen im Kapitel 5.
27
Mai 2012
• Text in hoffentlich allen Kapiteln an die neuen Versionen von Java (JDK 1.7.0_u04),
Eclipse 3.7.2 und NetBeans (7.1.2) angepaßt.
• Kapitel 2.3.8 über JDK 1.7 vervollständigt.
• Kleine Änderungen in den Schleifen-Kapiteln 7.3, 7.4 und 7.7.2.
• Kleinere Ergänzungen in Kapitel 8.7 (Rekursion).
• Kapitel 9 (Java-Bibliothek) in allen Kapiteln erweitert und überarbeitet – vor allem
Kapitel 9.1 (Strings), den Anfang von Kapitel 9.3 (Container), Kapitel 9.5
(Zufallszahlen) und Kapitel 9.7 (Datei-System). Außerdem zwei neue Aufgaben 9.8.7
und 9.8.8 hinzugefügt – inkl. den Muster-Lösungen 9.15 und 9.16 (aber leider nur der
reine Quelltext, noch ohne weitere Erklärungen).
• Einige kleinere Änderungen in Kapitel 10 (u.a. neuer For-Schleifen-Typ), aber auch
ein komplett neues Unter-Kapitel 10.3.
Seite 12 / 409
26
Okt. 2011
• Text in vielen Kapiteln (aber noch nicht allen) an die neuen Versionen JDK 1.7.0_00
und Eclipse 3.7.1 angepaßt.
• Ein Unterkapitel 2.3.8 über JDK 1.7 in das Kapitel 2.3 aufgenommen, aber bisher nur
angefangen – noch viel offen.
• Kapitel 7.2 komplett neu geschrieben mit mehr Beispielen und auch JDK 1.7
Erweiterungen.
• Kapitel 8 hat viele kleine Änderungen und Erweiterungen bekommen.
• Kapitel 8 hat zwei neue Aufgaben (Kapitel 8.8.3 und Kapitel 8.8.4) mit Musterlösungen
ohne Erklärungen (Kapitel 8.11 und Kapitel 8.12) bekommen.
• Kapitel 9.3 vollkommen neu geschrieben mit vielen JDK 1.5 und JDK 1.7 Neuheiten
und viel mehr Informationen über die Container-Klassen. Das Kapitel ist aber noch
nicht fertig und enthält noch einige offene Punkte.
• Kapitel 9.7 leider immer noch nicht neu geschrieben, aber immerhin schon Verweise
auf einige „java.nio.file“ Neuigkeiten aus dem JDK 1.7 eingearbeitet.
25
Apr 2011
• Text in vielen Kapiteln an die neuen Versionen JDK 1.6.0_24 und Eclipse 3.6.2
angepaßt.
• Titelblatt eingeführt – mit Copyright und Hinweis auf die freie Verfügbarkeit des
unveränderten Tutorials für Unterrichtszwecke.
• Fußzeile um Link auf meine Homepage erweitert
• Kapitel 1 um Copyright und Hinweis auf die freie Verfügbarkeit des unveränderten
Tutorials für Unterrichtszwecke erweitert.
• Kapitel 2.3.8 ist neu
• Kapitel 16.6 über die Änderung des Swing GUI-Skins zu z.B. einem Windows-Style
wurde neu aufgenommen.
24
• Kapitel 6.3 über die Geteilt- und Modulo-Operatoren ergänzt.
• Fehler im ersten Beispiel in Kapitel 8.6 entfernt.
• Fehler im Durchlauf-Zähler in der Lösung zur rekursiven Quadratwurzel-Näherung in
Kapitel 8.13.2 entfernt.
• Kapitel 9.1.2 über String-Verkettung erweitert.
• Kapitel 9.2 um die Klasse „StringBuilder“ erweitert.
• Sämtliche Lösungen des Kapitels 9 auf StringBuilder, typisierte Container und den
neuen For-Schleifen-Typ umgestellt (Kapitel 9.10, 9.11, 9.12, 9.13 und 9.14).
Außerdem Lösung für das Lottozahlen-Programm (Kapitel 9.13) optimiert.
• Kleine Fehler in den Beispielen in Kapitel 11.4.2 beseitigt.
23
• Text in vielen Kapiteln an die neuen Versionen JDK 1.6.0_22 und Eclipse 3.6.1
angepaßt.
• Kleine Fehler in vielen Kapiteln entfernt.
• Break und Continue Anweisungen mit detailierten Beispielen hinterlegt – Kapitel 7.7.
• Kapitel über echte Enums ergänzt – Kapitel 12.6.
Offene
Punkte
•
•
•
•
•
•
Seite 13 / 409
Thread.sleep aus Kapitel 11.3.1 in Kapitel 9 aufnehmen.
Kapitel 7 ist in manchen Unterkapiteln noch ein bisschen knapp.
Kapitel 18 hat noch einige offene Stellen.
In Kapitel 23 fehlen noch einige Erklärungen.
In Kapitel 25 fehlt der Hinweis auf das „serialVersionUID“ Attribut.
Kapitel 10 über Arrays vor Kapitel 9 ziehen, da im File-System Kapitel ein Array von
Strings vorkommt.
1 Organisatorisches
Thema
• Objektorientiertes Programmieren in Java
• Achtung – die Sprache ist so umfangreich, dass die Vorlesung aus Zeitmangel bei weitem
nicht alle Sprachelemente abdecken kann, und bei den abgedeckten auch viele Details
ausläßt.
• Achtung – die Bibliotheken von Java sind extrem umfangreich – auch hier wird die Vorlesung
nur einzelne kleine Teile vorstellen können.
Voraussetzungen
• Kenntnisse einer beliebigen Programmiersprache.
• Die Vorlesung setzt voraus, dass Sie die Grundlagen der Programmierung kennen. Sie
sollten z.B. wissen was eine Variable, ein Typ oder eine Funktion ist, und warum und wofür
man sie benutzt. Sie sollten die Begriffe Scope (Block), Lebensdauer, Speicher, Stack und
Heap zumindest ungefähr zuordnen können. Über den Vorteil einer konsistenten und
durchgängigen vorstellen Formatierung und Benamung sollte ich kein Wort mehr verlieren
müssen. Ihnen sollte klar sein, warum die Auftrennung in möglichst unabhängige Module
sehr sinnvoll ist. Und zu guter Letzt sollten Sie zumindest in Ansätzen in der Lage sein, ein
Problem in Teil-Probleme zu zerlegen, es zu strukturieren, und einfache Algorithmische
Lösungen zu verstehen und erarbeiten zu können.
Tutorial
• Das Tutorial wurde mal wieder überarbeitet und erweitert. Und trotzdem ist es leider noch
nicht fertig – es enthält also noch immer einige Lücken und wahrscheinlich auch noch
Fehler. Lesen Sie es also mit einer gesunden Skepsis – wie aber eigentlich alles, nicht
wahr?
• Das Tutorial bezieht sich prinzipiell auf die aktuelle Java 8 Plattform mit dem JDK 1.8. Aus
Zeitmangel werden aber viele der „neueren“ Features von Java nicht besprochen. Von daher
laufen viele Beispiele auch mit alten Java-Versionen wie dem JDK 1.5. Trotzdem setze ich
bei allen Beispielen ein JDK 1.8 voraus – da ich zum Teil auch neue Sprach-Features
vorstelle und nutzen werde.
• Die Abbildungen und Beispiele der Kommandozeilen und der IDE in Kapitel 4 beziehen sich
noch auf ältere Versionen von Java – konkret auf das JDK 1.5.0_06. Bzgl. der im Kapitel
vorgestellten Themen gibt es aber keine Unterschiede zu den neusten Versionen, von daher
Seite 14 / 409
stimmen diese Beschreibungen und Abbildungen auch weiterhin problemlos
• Die Abbildungen der GUI Programme wurden unter Windows XP als auch Windows 7 mit
klassischem GUI Stil sowohl mit dem JDK 1.4.2, JDK 1.5, JDK 1.6, JDK 1.7 als auch dem
JDK 1.8 erstellt. Je nach von Ihnen verwendetem Betriebssystem und/oder JDK kann der
GUI Stil natürlich abweichen – verhalten sollten sich alle Beispiele aber identisch.
• Sollten Sie Fehler finden oder Anregungen haben, so schicken Sie mir bitte eine Mail Adresse: ‘[email protected]’. Bitte haben Sie Verständnis dafür, dass ich nicht jede
Mail beantworten kann.
Praktikum
• Kleine und große Aufgaben in Java lösen
• Näheres siehe in Kapitel 4.
Tools
• Die für die Entwicklung notwendigen Tools werden in Kapitel 4.1 vorgestellt.
• Ihre Benutzung wird in den Kapiteln 4.3 und 4.6 kurz erläutert.
Warum sollte ich Java lernen?
• Im Augenblick die wohl wichtigste und verbreiteste Programmiersprache.
• Relativ einfach zu lernen.
• Im großen Maße plattform-unabhängig und weit verbreitet – siehe Kapitel 2.2.
• Für viele Anwendungsfälle fertige Bibliotheken enthalten.
• Gute Unterstützung an Tools – siehe auch Kapitel 4.1.1 und 4.1.3.
• Gute Unterstützung an Bibliotheken, Literatur, usw.
Literatur und WWW
Es gibt hunderte von Büchern zu Java, Zeitschriften, und zig-Millionen Artikel im Web. Die erste
Anlaufstelle sollte die offizielle Doku von Oracle sein:
• http://www.oracle.com/us/technologies/java/index.html
Ansonsten kann Sie z.B. Onkel „Google“ mit vielen weiteren Links und z.B. Tante „Amazon“ mit
massenhaft Buch-Vorschlägen versorgen – auch wenn Sie natürlich andere Onkels und Tanten
präferieren dürfen.
2 Java
Dieses Kapitel führt in die Philosophie und Historie von Java ein, und stellt wichtige
Schlagwörter und (Marketing-) Begriffe der Java Welt vor. Betrachtet werden z.B. die
Implikationen und Vor- und Nachteile einer virtuellen Maschine, wie Java sie einsetzt oder die
Historie der JDKs. Aber es wird eben auch erklärt, was eine virtuelle Maschine ist, was JDKs
sind, oder was Applets oder Midlets sind.
Alle, die dieses Hintergrund-Wissen nicht interessiert und die heiß auf die Sprache Java an sich
und praktisches Programmieren sind, können direkt zum Kapitel 3 springen.
Seite 15 / 409
2.1 Einleitung
Java wurde von James Gosling bei Sun entwickelt. Die erste offizielle Vorstellung von Java war
im März 1995. Java entwickelte sich in den kommenden Jahren – aus verschiedenen Gründen
– zu einer der wichtigsten Programmier-Sprachen auf dem Markt, und ist seit einigen Jahren
die wohl am häufigsten eingesetzteste Programmier-Sprache1 der Welt. Mittlerweile hat Oracle
Sun übernommen – und damit liegt die Weiterentwicklung von Java primär in den Händen von
Oracle.
Bevor wir aber ab Kapitel 3 tiefer in die Sprache Java einsteigen, wollen wir einige andere
Dinge klären, die Java von vielen anderen Sprachen unterscheidet, und zum Teil auch für den
Erfolg von Java verantwortlich sind.
So ist Java mehr als nur die objektorientierte Programmier-Sprache, als die Sie den Namen
Java möglicherweise kennengelernt haben. Mit dem Begriff Java verbindet man auch häufig die
sogenannte virtuelle Maschine „JVM“. Und manchmal wird Java sogar als Plattform – quasi als
eine Art Betriebssystem – bezeichnet. Alle drei Sichtweisen haben ihre Berechtigung – und wir
werden auch gleich sehen, warum.
2.2 Java als Plattform
Um die Aussage „Java als Plattform“ zu verstehen, wollen wir uns etwas detailierter anschauen,
wie „normale“ Compiler-Sprachen arbeiten (Kapitel 2.2.1), und dies dann mit Java vergleichen
(Kapitel 2.2.2).
2.2.1 Compiler-Sprachen
2.2.1.1 Executable
Bei einer Compiler-Sprache wie z.B. C oder C++ schreibt der Programmierer sein Programm in
der entsprechenden Programmiersprache (eben z.B. C oder C++), und ein anderes Programm
(der Compiler) übersetzt dies in direkt ausführbaren Maschinen-Code.
Damit ist klar, dass das eigentlich Executable (d.h. die ausführbare Datei auf Ihrer Festplatte)
Achtung – misstrauen Sie solchen Aussagen wie die häufigste, verbreiteste oder sonstwas
Programmier-Sprache. Erstmal ist die Frage, wie definiert man sowas überhaupt (Anzahl an
Code-Zeilen, Anzahl Programmierer, Anzahl Bibliotheken, ...)? Und letztlich kann keiner
feststellen, wie viele Zeilen Code wirklich weltweit in irgendeiner Sprache geschrieben wurden,
oder wieviele Programmierer oder Firmen eine Sprache einsetzen, oder sonstwas. Es gibt aber
schon einige ganz interessante und halbwegs akzeptabler Statistiken über die Verbreitung und
Relevanz von Programmier-Sprachen. Und hier liegt Java immer in der Spitzengruppe, häufig
an erster Stelle.
1
Seite 16 / 409
fest an einen Prozessor (bzw. kompatible Prozessoren) gebunden ist, denn nur diese
Prozessoren verstehen diesen Maschinen-Code. Z.B. ein Executable, compiliert für einen
Sparc-Prozessor, läuft nicht auf einem Power-PC Prozessor – auch wenn das gleiche
Betriebssystem vorhanden ist.
Weiterhin hat jedes Betriebssystem ein spezielles Format, in dem ausführbare Datei aufgebaut
sein müssen. Der Compiler muß beim Executable erzeugen natürlich dieses Format
berücksichtigen. Damit ist ein Executable auch ein konkretes Betriebssystem (oder ein
kompatibles) gebunden. Ein Executable, z.B. compiliert für Windows, läuft nicht unter Linux –
auch wenn der gleiche Prozessor vorhanden ist.
Unser Executable ist also an eine Plattform bestehend aus Prozessor und Betriebssystem
gebunden.
Abb. 2-1 : Executable-Abhängigkeit zu einer konkreten Plattform
Natürlich kann man sein Programm auch für eine andere Plattform übersetzen, wenn man denn
einen Compiler für diese Plattform hat, und das Programm plattform-unabhängig geschrieben
ist (siehe Kapitel 2.2.1.2). Aber für jede gewünschte Ziel-Plattform (d.h. jede gewünschte
Kombination aus Prozessor und Betriebssystem) muß ein eigenes Executable erstellt werden.
Abb. 2-2 : Executables für mehrere Plattformen
2.2.1.2 Programmierung
Aber nicht nur der Compiler bestimmt die Ziel-Plattform unserer Programm-Entwicklung. Auch
die Programmierung selber kann hier bestimmte Randbedingungen festlegen. Ein Programm
existiert ja nicht im luftleeren Raum, sondern soll später mit dem Computer und dem Benutzer
interagieren. Dazu greift es z.B. auf das Datei-System zu, und macht Ein- und Ausgaben.
Hier hat der Programmierer drei Möglichkeiten:
1. Er beschränkt sich auf die Sprach- und Bibliotheks-Elemente, die im Umfang seiner
Programmier-Sprache enthalten sind. Unter C und C++ ist dies nur ein extrem kleiner
Bereich, der von den ISO Standards abgedeckt ist – z.B. gehören grafische Oberflächen
oder Netzwerk-Bereiche nicht dazu.
- Der Programmierer ist sehr eingeschränkt in seinen Möglichkeiten.
- Dafür hat er ein Programm geschrieben, das prinzipiell für viele Plattformen compiliert
werden kann.
2. Der Programmierer greift direkt auf das Betriebssystem zu2. Dann hat er alle Möglichkeiten
des Betriebssystems zur Verfügung – er kann also z.B. grafische Oberflächen
implementieren, oder Netzwerk-Funktionalitäten nutzen.
2
Auf das sogenannte Betriebssystem API (Application Programming Interface).
Seite 17 / 409
- Der Programmier hat alle Möglichkeiten des Betriebssystems.
- Das Programm ist an dieses eine Betriebssystem gebunden, also nicht portabel.
3. Letzlich kann der Programmierer auch fremde (3-party) Bibliotheken nutzen (kommerzielle
oder freie), die betriebssystem-abhängige Funktionalität kapselt, und diese unter mehreren
Betriebssystemen zur Verfügung stellt.
- Der Programmierer muß entsprechende Bibliotheken für seinen Compiler finden, und er
muß sie einsetzen können und dürfen3.
- Das Programm funktioniert dann für alle Plattformen, für die die Bibliothek vorhanden ist.
Abb. 2-3 : Executable für mehrere Plattformen entwickeln
2.2.1.3 Portabiliät
Portabilität ist bei Compiler-Sprachen also ein komplexes Thema, da dort die Hardware, der
Prozessor, das Betriebssystem und alle genutzten 3-party Bibliotheken eine Rolle spielen.
2.2.2 Java Virtual Machine – JVM
Während Compiler-Sprachen also ein Executable erzeugen, dass an eine ganz konkrete
Plattform (Hardware, Prozessor, Betriebssystem) gebunden ist, geht Java einen anderen Weg.
Java compiliert die Programme für eine sogenannte virtuelle Maschine – die „Java Virtual
Machine“ (JVM), d.h. eine Plattform, die es in Silizium gegossen gar nicht gibt4. Statt dessen
wird die virtuelle Maschine in Software geschrieben, und simuliert die Java Plattform auf einer
beliebigen anderen Plattform, z.B. Windows, Linux oder Mac OS-X.
Abb. 2-4 : Idee einer virtuellen Maschine
Damit macht sich Java in einem hohen Maße von den Portabilitäts-Problemen von CompilerSprachen unabhängig. Es gibt nur noch eine Plattform – die Java Virtual Machine – egal auf
welcher echten Plattform das Programm hinterher laufen soll. Solange auf der echten Plattform
eine JVM existiert, können Java Programme dort ablaufen.
Die Bedingungen klingen vielleicht harmlos, sind es aber in der Praxis oft nicht. So haben z.B.
Compiler zum Teil unterschiedliche Bibliotheks-Formate, die sich manchmal sogar zwischen
Compiler-Versionen geändert haben. Oder eine Bibliothek ist zwar für den gesuchten Compiler
vorhanden, aber mit anderen nicht-kompatiblen Optionen gebaut. Sind Sie jetzt von zwei
Bibliotheken, die mit inkompatiblen Optionen erstellt wurden, abhängig, so haben Sie verloren –
selber schon mal erlebt. Oder die Lizenz-Bedingung paßt nicht, oder die Bibliothek kostet
zuviel, oder ist in der Firma nicht validiert, oder oder oder.
4 Okay, es könnte so eine Plattform in Silizium geben. Aber obwohl es schon Versuche in
dieser Richtung gab, gibt es die JVM bis heute nur in Software.
3
Seite 18 / 409
Daher erzeugt ein Java Compiler auch keinen Maschinen-Code und kein Executable, sondern
sogenannten Byte-Code. Und die Datei bzw. die Dateien, die dabei erzeugt werden, sind
natürlich auch keine Executables, sondern Dateien, die eine JVM zur Ausführung benötigten.
Dieser Ansatz einer virtuellen Maschine hat natürlich einige Konsequenzen – im positiven wie
im negativen Sinne, die wir im folgenden diskutieren wollen.
2.2.2.1 Portabilität
Fangen wir mit einem klaren Plus an – die Portablität. Java Byte-Code ist natürlich extrem
portabel. Er enthält keinerlei Abhängigkeiten zu irgendeiner Hardware, zu irgendeinem
Prozessor oder irgendeinem Betriebssystem. Auch 3-party Bibliotheken machen hier keine
Probleme, da sie selber auch wieder als Java Byte-Code vorliegen. Solange auf der
eigentlichen Plattform eine JVM existiert, kann der Java Byte-Code dort ausgeführt werden.
Und dazu muß der Byte-Code auch nicht neu compiliert werden, denn es gibt keine bzgl. der
Byte-Code Definition keinerlei Unterschiede zwischen den JVMs verschiedener echter
Plattformen5.
Das Ganze geht sogar soweit, dass man Byte-Code von verschiedenen Quellen problemlos
mischen kann, und problemlos woanders laufen lassen kann. Z.B. könnte ein Java Projekt zum
Teil unter Windows mit Eclipse entwickelt werden, ein anderer Teil unter Solaris mit dem JavaCompiler von Sun, und ein dritter Teil unter Linux mit einem beliebigen anderen Compiler. Der
Byte-Code aller drei Teil-Projekte kann einfach zusammengebracht werden, und läuft dann z.B.
auch auf Mac OS-X ohne jede Änderung. Denn der Byte-Code und die Schnittstelle der JVM
sind genau normiert.
Abb. 2-5 : Portabilität mit einer VM und genormtem Byte-Code
Das ist Portablität in einer ganz anderen Dimension im Vergleich zu den herkömmlichen
Compiler-Sprachen.
2.2.2.2 Sandbox
Zusätzlich zu der Portablität ermöglicht der Ansatz einer VM auch noch andere Optionen. Da
der Byte-Code nicht direkt auf der Hardware und dem Prozessor läuft, und er auch nicht direkt
auf das Betriebssystem zugreifen kann, läßt sich ein Java Programm prinzipiell vollständig
kontrollieren. Alle Aktionen des Programms müssen letztlich durch die VM ausgeführt werden.
Wenn die VM aber sicherheits-kritische Aktionen wie z.B. den Zugriff auf das Dateisystem nicht
zuläßt, kann ein Java-Programm hier nichts kaputt machen.
Eine virtuelle Maschine kann also für ein Java-Programm wie ein Sandkasten („Sandbox“) sein,
5
Von den immer vorhandenen Bugs wollen wir mal absehen.
Seite 19 / 409
in dem es sich austoben, aber auch keinen Blödsinn anrichten kann. Genau dies beherrscht die
JVM auch. Im Kontext eines Browsers als Applet ausgeführte Java Programme (siehe Kapitel
2.2.2.3 und Kapitel 21) haben eingeschränkte Rechte. Nur über Zertifikate und explizite NutzerBestätigungen können Sie an mehr Rechte kommen – ansonsten müssen sie in ihrem
Sandkasten bleiben.
Hinweis – die Idee des Sandbox funktioniert natürlich nur, wenn die JVM Implementierung
keine Fehler aufweist, durch die die Programme den Sandkasten verlassen können.
2.2.2.3 Browser-Anwendungen
Ideal ist diese Portabilität und das Sandbox-Prinzip natürlich z.B. für Programme aus dem
Internet, die in jedem Browser laufen können sollen. Denken Sie sich eine Aufgabe, für die
einfache Text-Darstellung im Browser nicht reicht – hier wäre es schön, im Browser des
Nutzers ein kleines Programm ablaufen lassen zu können. Dies ist mit Java möglich, da es für
alle halbwegs wichtigen Browser Java-Plugins gibt, d.h. JVMs für den Browser.
Ein Server kann also ein Java-Programm als Byte-Code an einen Browser ausliefern, ohne sich
Gedanken um die Ziel-Plattform machen zu müssen (Portabilität), und Sie als Nutzer können
so ein Programm bedenkenlos in Ihrem Browser ausführen, da es sich nur im Sandkasten der
JVM mit eingeschränkten Rechten bewegen darf6.
So ein Java-Programm, das im Browser läuft, ist übrigens kein ganz normales Java-Programm,
sondern ein sogenanntes Applet, das sich minimal von normalen Java Desktop Programmen
unterscheidet. Im Tutorial lernen wir Applets und ihre Programmierung in Kapitel 21 kennen.
Hinweis – während in den Anfangszeiten von Java gerade die Applets als das Besondere von
Java herausgestellt wurden und ein Grund für den Erfolg von Java waren – sind Applets heute
nur noch sehr selten anzutreffen. Zum einen gibt es mittlerweile viele andere Technologien, die
Java im Browser überflüssig machen, zum anderen hat sich die JVM im Browser als ein echtes
Sicherheitsproblem herauskristallisiert – da die Sandbox nie wirklich sicher war. Die JVM hatte
und hat immer mit schweren Lücken im Sandbox-Prinzip zu kämpfen, wodurch Applets den
Sandkasten verlassen und dann mit den Rechten des Browsers auf dem System agieren
konnten.
2.2.2.4 Portable Umgebungen
Nicht nur Desktops bieten eine große Auswahl an Plattformen, auch portable Geräte wie z.B.
PDAs oder Handies sind eine interessante Umgebung für portable Programme. Sie bieten
vielfältige Hardware und unterschiedliche Betriebssystem – es wäre aber interessant
Programme für alle diese Plattformen schreiben zu können.
Dafür wurde in der Java Familie „JME“ („Java Mobile Edition“) entwickelt. Dies ist eine
6
Wir wollen wieder mal von Bugs in der JVM absehen.
Seite 20 / 409
eingeschränkte JVM, die nicht alle Sprach-Features von Java anbietet, und auch bei weitem
nicht alle Bibliotheken von Java unterstützt. Aber JME ist wieder eine genau definierte
Umgebung mit klar abgesteckten Fähigkeiten, die an die Anforderungen von einfachen
portablen Geräten angepaßt sind. Java-Programm für die JME-VM nennen sich Midlets.
Achtung – Java Mobile ist schon einige Jahre alt und adressierte portable Umgebungen, die
nicht besonders leistungsfähig waren – z.B. Handies aus einer Vor-Smartphone-Area. Heutige
portable Geräte wie Smartphones oder Tablets haben die Leistungsfähigkeit von normalen
Desktop Rechnern – hier kann eine fast ganz normale JVM problemlos laufen.
2.2.2.5 Android
Viele heutige portable Geräte laufen unter dem Betriebssystem Android – und die Haus- und
Hofsprache von Android ist Java. Wenn Sie eine App für Android entwickeln wollen, dann
werden Sie dies in den meisten Fällen in Java machen. Natürlich sind auch andere Sprachen
möglich – allen voran C++ – aber die normale Sprache für Android-Apps ist Java.
Das Java von Android ist nicht abgespeckt wie JME, sondern ein ganz normales Java. Nur für
die grafische Oberfläche wird nicht AWT, Swing oder JavaFX (siehe Kapitel 16) eingesetzt,
sondern ein spezielles Android-Spezifisches GUI Framework.
Leider sprengt die Entwicklung von Android Apps unseren Rahmen – obwohl es natürlich „cool“
wäre, ein Programm zu schreiben, das auf vielen Smartphones läuft.
2.2.2.6 Server-Umgebungen
Was für Browser und PDAs recht ist, kann für Server-Infrastrukturen auch passend sein. Auch
dort findet man häufig – historisch bedingt – ein heterogene und gewachsene Infrastruktur von
Plattformen der verschiedensten Art. Früher konnten hierbei Programme nicht einfach von
einem System auf das nächste verschoben werden, um den wechselnden Anforderungen zu
genügen – mit Java ist dies möglich. Solange ein JVM zur Verfügung steht, kann ein Programm
problemlos von einem Rechner auf den anderen verschoben oder kopiert werden.
In Server-Umgebungen ist dies nicht das einzig interessante Kriterium. Wichtig ist z.B. auch die
Unterstützung von Persistenz, Datenbanken, Transaktionen, uvm. Hierfür wurde in die Java
Familie „Java EE“ („Java Enterprise Edition“) aufgenommen. Dies ist eine Erweiterung von Java
um spezielle Bibliotheken und Fähigkeiten (z.B. „Java Enterprise Beans“ als ein KomponentenKonzept für Server-Anwendungen) für eben solche Themen.
Auch andere Server-Themen fanden ihren Niederschlag in der Java Familie. So gibt es in Java
z.B. Servlets – d.h. Java-Programme, die in einem Web-Server ausgeführt werden und
dynamische HTML Seiten bereit stellen können. Oder auch Portlets, die speziell für die
Programmierung von Web-Portalen entwickelt wurden.
Im Tutorial wird gar nicht auf spezielle Server-Elemente von Java eingegangen – dazu fehlt
Seite 21 / 409
wieder mal die Zeit.
2.2.3 Plattform „Java“
Wie man sieht, stellt Java in Form der JVM wirklich eine Plattform dar – denn sie simuliert
einen Java Prozessor mit einem Java Betriebssystem – dem typischen Verständnis einer
Plattform.
Aber auch mit einem breiter gefassten Verständnis von Plattform trifft der Begriff auf Java zu.
Java adressiert neben den normalen Desktop-Programmen auch Applets, die im Browser
laufen. Dann mit JME Midlets für einfache portable Geräte, und mit speziellen GUI Android
Smartphones. Und für Server-Anwendungen gibt es Java EE mit u.a. Servlets und Portlets.
Dies ist ein breites Spektrum an Einsatzgebieten, was in dieser Vielfalt von kaum einer anderen
Programmier-Sprache abgedeckt wird.
2.3 Java Versionen
Als Java im März 1995 der Öffentlichkeit vorgestellt wurde, war Java noch eine ziemlich kleine
Sprache – und kaum jemand (niemand?) dachte an eine solche Verbreitung, wie sie heute
vorhanden ist. Die initiale Entwicklung von Java hatte auch nur wenig mit den heutigen
Einsatzgebieten zu tun, sondern es ging um eine Software-Plattform für Haushaltsgeräte7. Da
Haushaltsgeräte auch eine sehr hetorogene Plattform darstellen, war die Entwicklung einer
virtuellen Maschine natürlich eine gute Idee8.
Wenn Sie Java nur als Ausführungs-Plattform nutzen wollen – und das wird auf die meisten
Menschen zutreffen – dann benötigen Sie nur die JVM in Form des JRE. Wollen Sie auch mit
Java entwickeln – und das betrifft uns – dann benötigen wir das JDK.
JRE steht hierbei für „Java Runtime Environment“ und ist das Stück Software, was der Nutzer
braucht, um ein Java-Programm (d.h. den Java Byte-Code) laufen zu lassen – also im Prinzip
die virtuelle Maschine.
JDK steht für „Java Development Kit“ und enthält neben dem JRE auch die Tools und
Bibliotheken, die man braucht um Java Programme zu entwickeln. Ein JDK ist also das, was
Sie zum Entwickeln brauchen – siehe auch Kapitel 4.1.1. Häufig wird es auch als Java SDK
(„Software Development Kit“) bezeichnet.
Sie kennen doch sicher auch diese Visionen vom Kühlschrank, der merkt, wenn die Milch alle
ist und beim Händler direkt neue bestellt. Hier hat auch der vielzitierte Satz „Java wurde für
Toaster entwickelt“ seinen wahren Ursprung.
8 Aber glauben Sie jetzt nicht, dass die Idee einer VM eine Java Idee ist. Schon Anfang der
70er Jahre gab es erste VMs mit normiertem Byte-Code, z.B. Eumel. Aber damals war die Zeit
noch nicht reif dafür.
7
Seite 22 / 409
2.3.1 JDK 1.0
Aus dem Labor kam Java heraus, als Sun eine Konkurrenz zu Microsofts Vorherrschaft auf
dem Desktop suchte, und das Internet sich zu entwickeln began. Der Desktop sollte unwichtig
werden, und statt dessen sollte der Nutzer einfach alles im Browser und dem Internet machen.
Und hierfür erschien eine VM mit ihren Fähigkeiten bzgl. Portabliltät und Sicherheit natürlich
ideal. Also wurde die Idee von Applets entwickelt – die Möglichkeit das damals recht
beschränkte Web um interaktive Möglichkeiten zu erweitern. So kam Java mit dem JRE 1.0
bzw. dem JDK 1.0 in die Welt.
Applets haben aber nicht wirklich die Welt gerettet – oder wie häufig begegnen Ihnen Applets
im Internet? Heutzutage gibt es andere Technologien um Rich-Internet-Seiten zu
programmieren, die sich mehr verbreitet haben, so z.B. DHTML, JavaScript, Ajax oder Flash.
Applets sind die Ausnahme, die man nutzt, wenn man wirklich die Vorteile einer mächtigen
Programmiersprache und der Sandbox im Browser benötigt.
Die Java Bibliothek des JDK 1.0 bestand aus 212 Klassen in 8 Packages. Selbst wenn Ihnen
die Begriffe Klassen und Packages noch nichts sagen – wir lernen sie in Kapitel 11 bzw. 13
kennen – sind die reinen Mengen-Zahlen im Laufe der JDK-Historie ganz interessant. Im
Augenblick reicht uns hier die einfache Vorstellung, dass Klassen stark vereinfacht (und auch
nicht richtig) eine Bündelung von Funktionen darstellen, und Packages ihrerseits wieder
Klassen in Gruppen strukturieren. Interessant ist also vor allem die Zahl der Klassen, da sie
indirekt ungefähr die Zahl der Bibliotheks-Funktionen widerspiegelt.
2.3.2 JDK 1.1
Die nächste Java Version (JDK 1.1) wurde im Februar 1997 freigegeben. Diese Version war ein
erster wichtiger Schritt zu einer ernsthaften Plattform. Der Sprung von Java aus dem Labor in
die reale Welt war mit dem JDK 1.0 relativ schnell erfolgt, und so krankte Java noch an einigen
Kinderkrankheiten. Das JDK 1.1 brachte hier viele Abhilfen, und so wurde neben der Bibliothek
auch die Sprache erweitert. Mit dem JDK 1.1 gab es nun z.B. innere Klassen, das GUI EventModell wurde quasi auf den Kopf gestellt, es gab Änderungen an der Serialisierung und an
Reflection, Unicode-Dateien wurden nun unterstützt, JDBC hielt Einzug, und die JNI
Schnittstelle wurde standardisiert. Und die Bibliothek erweitert sich um fast 300 Klassen.
JDK Version
1.0
1.1
Datum
Packages
Apr. 1995 8
Feb. 1997 23
Klassen
212
504
Achtung – nehmen Sie die Anzahl der Packages und Klassen nicht zu genau. Die Zählungen
stellen Momentaufnahmen dar. Es ist immer wieder passiert, dass neuere Unterversionen des
JDK (z.B. 1.4.2) neue Klassen und Packages eingeführt haben.
2.3.3 JDK 1.2 – Java 2
Zwischen den JDK Versionen 1.1 und 1.2 gab es viele Zwischen-Versionen, die manche
Seite 23 / 409
Neuerungen inkrementell einführten. Vor allem die GUI Welt von Java war im Umbruch – über
das eher einfache AWT von JDK 1.0 und JDK 1.1 wurde das schönere und mächtigere Swing
gesetzt. Damit wechselte das primäre Ziel von Java von den Applets zu Desktop-Programmen.
AWT („Abstract Window Toolkit“) war der Teil der Bibliothek des JDK 1.0 und 1.1, welches für
die GUI Programmierung zuständig war. AWT ist auch heute noch Teil von Java, wurde aber
durch Swing erweitert, was eine viel leistungsfähigere GUI Bibliothek darstellt. Nähere
Informationen zu AWT und Swing finden Sie in bzw. ab Kapitel 16.
Eine weitere wichtige Änderung war eine starke Erweiterung der Collections – wichtig, da
Collections das tägliche Brot des Programmierers darstellen, siehe auch Kapitel 9.3.
Aber auch viele andere Bibliotheksteile wurden überarbeitet, erweitert oder ergänzt. So drückte
sich das dann in Zahlen aus:
JDK Version
1.0
1.1
1.2 (Java 2)
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Packages
8
23
59
Klassen
212
504
1520
Alles zusammen war Sun Grund genug, von einem ganz neuen besseren Java zu reden, und
gab Java mit dem Namen „Java 2“ die Versions-Nummer 2.
Zusätzlich deutete sich mit dem JDK 1.2 schon ein Wechsel bzgl. der VM Technologie an. Seit
dem JDK 1.3 ist HotSpot die primäre JVM von Sun (siehe Kapitel 2.4.2), im JDK 1.2 war sie
schon enthalten und konnte per Option aktiviert werden.
2.3.4 JDK 1.3
Mit dem JDK 1.3 wurde der Focus von Java auch auf die Server-Infrastrukturen gelenkt, und so
brachte das JDK 1.3 neben HotSpot (siehe Kapitel 2.4.2) viele im Server-Umfeld wichtige neue
und erweiterte Bibliotheksteile mit – z.B. Verteilung via RMI/IIOP und JNDI Namensdienste.
JDK Version
1.0
1.1
1.2 (Java 2)
1.3
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Mai 2000
Packages
8
23
59
76
Klassen
212
504
1520
1842
Seite 24 / 409
2.3.5 JDK 1.4
JDK 1.4 im Februar 2002 war eine für Java wichtige Version. Viele Kritiker sagen, dass dies die
erste professionell und produktiv einsetzbare Version war. Auf jeden Fall zeichnete sich das
JDK 1.4 durch weiter verbesserte Performance, einen besseren Garbage-Collector (siehe
Kapitel 2.4.1) und hohe Stabilität aus. Auch heute wird das JDK 1.4 von Sun noch unterstützt,
und wird auch noch von vielen Firmen aus den verschiedensten Gründen eingesetzt.
Natürlich brachte auch das JDK 1.4 wieder viele Bibliotheks Verbesserungen und
Erweiterungen mit sich – schauen Sie sich mal die Zahlen in der folgenden Tabelle an. Sowohl
Desktop-Programme profitierten von neuen Swing Features, als auch Server-Programme von
vielen anderen Neuerungen.
Und mit JDK 1.4 wurde zum ersten Mal seit dem JDK 1.1 auch wieder die Sprache erweitert –
Java bekam Assertions, die aus Zeitmangel in der Vorlesung leider nicht besprochen werden
können.
JDK Version
1.0
1.1
1.2 (Java 2)
1.3
1.4
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Mai 2000
Feb. 2002
Packages
8
23
59
76
135
Klassen
212
504
1520
1842
2723
2.3.6 JDK 1.5 – Java 5
Mit dem JDK 1.5 wurde Java mal wieder umbenannt: „Java 5“ hieß es nun. Obwohl rund 2 ½
Jahre seit dem JDK 1.4 ins Land gegangen waren, vergrößerte sich die Bibliothek kaum. Es
kamen nur 556 neue Klassen hinzu.
JDK Version
1.0
1.1
1.2 (Java 2)
1.3
1.4
1.5 (Java 5)
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Mai 2000
Feb. 2002
Sep. 2004
Packages
8
23
59
76
135
166
Klassen
212
504
1520
1842
2723
3279
Seite 25 / 409
Die größten Änderungen passierten mit der Sprache selber und unter der Haube. Am
offensichtlichsten waren hiervon natürlich die Sprach-Erweiterungen:
• Neue Schleifen-Konstrukte
• Aufzählungs-Typen
• Generics (typisierte Container)
• Annotations
• statische Imports
• etc.
Unter der Haube beherrscht Java seit dem JDK 1.5 z.B. parallele Garbage-Collection – siehe
Kapitel 2.4.1.
Hinweis – aus Zeitmangel werden viele der mit Java 5 eingeführten Sprach-Konstrukte im
Tutorial nicht oder nur sehr knapp besprochen.
2.3.7 JDK 1.6 – Java 6
Im Dezember 2006 beglückte Sun die Java Community mit Java 6 bzw. dem JDK 1.6 – der zur
Zeit aktuellen Version9. Es gab keine Sprach-Änderungen, aber natürlich wurde die Bibliothek
wieder verbessert und erweitert – so wurde u.a. die Integration von Java Programmen in den
Desktop stark verbessert, z.B. durch eine System-Tray Unterstützung. Aber die vielleicht
interessanteste Neuerungen spielte sich woanders ab.
Seit dem JDK 1.6 hat Java eine Script-API und unterstützt damit direkt mehrere andere
Programmierspachen. So gibt es jetzt z.B. JRuby, eine in Java geschriebene Implementierung
der Programmiersprache Ruby auf der JVM mit der Möglichkeit der einfachen Interaktion
zwischen beiden Welten.
JDK Version
1.0
1.1
1.2 (Java 2)
1.3
1.4
1.5 (Java 5)
1.6 (Java 6)
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Mai 2000
Feb. 2002
Sep. 2004
Dez. 2006
Packages
8
23
59
76
135
166
202
Klassen
212
504
1520
1842
2723
3279
3777
9
Stand 13.04.2008
Seite 26 / 409
2.3.8 JDK 1.7
Mittlerweile hat Oracle Sun übernommen, und Java steht nun unter der Regie von Oracle. Dies
hat dazu geführt, dass wir lange auf die nächste Java Version warten mußten. Aber seit August
2011 ist Java 7 (JDK 1.7) da, und seit Mai 2012 ist sie auch für den Produktiveinsatz
freigegeben. Java 7 brachte sowohl Erweiterungen der Sprache, der Bibliothek als auch der
JVM mit sich.
Die Sprache Java wurde um einige kleine Dinge ergänzt, die das Leben in der Praxis einiges
leichter machen. Zum Beispiel können jetzt Switch-Anweisungen für Strings genutzt werden
(Kapitel 7.2), lesbare Integer- und Binär-Literale wurden eingeführt, Exception-Catch-Blöcke
können nun mehrere Exceptions gleichzeitig fangen, Redundante Typ-Informationen bei
Generics sind nicht mehr notwendig (Kapitel 9.3.1), oder die Handhabung von ClosableRessourcen ist nun viel sicherer.
Auch in der Bibliothek gab es eine Menge neue Dinge – besonders hervorzuheben sind sicher
das neue Fork/Join-Framework im Multithreading-Umfeld, die Erweiterungen im New-IO
Package (Kapitel 9.7.2), Unterstützung von Unicode 6, Veränderungen an den Währung-Codes
und Locales, Überarbeitung des XML-Stacks, und der Ausbau der GUI Bibliothek mit z.B.
neuen Designs (Nimbus-Projekt) und transparenten bzw. halb-transparenten Fenstern.
Unter der Haube, daher in der virtuellen Maschine, wurde das Class-Loading Verhalten
verändert, der neue Garbage Collector G1 aktiviert, und die Anbindung an neue ProgrammierSprachen weiter vereinfacht.
Unterm Strich finden sich vielleicht keine großen Erweiterungen in Java 7 wieder, aber doch
viele kleine Dinge die das Programmierer-Leben einfacher und/oder sicherer machen.
JDK Version
1.0
1.1
1.2 (Java 2)
1.3
1.4
1.5 (Java 5)
1.6 (Java 6)
1.7 (Java 7)
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Mai 2000
Feb. 2002
Sep. 2004
Dez. 2006
Aug. 2011
Packages
8
23
59
76
135
166
202
209
Klassen
212
504
1520
1842
2723
3279
3777
4024
Seite 27 / 409
2.3.9 JDK 1.8 – Java 8
Am 18. März 2014 ist Java 8 erschienen. Java 8 brachte sowohl Erweiterungen der Sprache,
der Bibliothek als auch der JVM mit sich: in die Sprache wurden Lambdas, funktionale
Interfaces, Default-Implementierungen und Streams mit parallelen Algorithmen eingeführt. Die
Bibliothek bekam eine vollkommen neue Date-Time-API, viele Concurrency Erweiterungen, und
Swing als GUI-Anteil wurde durch Java FX abgelöst. Unterm Strich sind die Erweiterungen in
Java 8 so umfangreich, dass sie höchstens mit dem Sprung auf Java 5 vergleichbar sind.
JDK Version
1.0
1.1
1.2 (Java 2)
1.3
1.4
1.5 (Java 5)
1.6 (Java 6)
1.7 (Java 7)
1.8 (Java 8)
Datum
Apr. 1995
Feb. 1997
Nov. 1998
Mai 2000
Feb. 2002
Sep. 2004
Dez. 2006
Aug. 2011
März 2014
Packages
8
23
59
76
135
166
202
209
217
Klassen
212
504
1520
1842
2723
3279
3777
4024
4240
Hinweis – aus Zeitmangel werden viele der mit Java 8 eingeführten Sprach-Konstrukte im
Tutorial nicht oder nur sehr knapp besprochen.
2.4 Technologien
Die JVM enthält einige sehr interessante Technologien, die heutzutage die Leistungsfähigkeit
von Java mitbestimmen und daher zum Erfolg von Java beigetragen haben. Zwei dieser
Technologien möchte ich hier detailierter vorstellen, da sie im bisherigen Kapitel schon
mehrfach erwähnt wurden, und sehr aufschlußreich sind.
• Speicherverwaltung und Garbage-Collector
• Performance und Hotspot
2.4.1 Speicherverwaltung und Garbage-Collector
Die Sprache Jave und die JVM unterstützen eine Technik, die Garbage-Collection genannt
wird. Dies meint einfach nur, dass Sie beliebig Objekte erzeugen können, und sich nicht um die
Freigabe des von den Objekten belegten Speichers kümmern müssen. Dies macht dann der
Garbage-Collector – ein Teil der JVM. Er erkennt nicht mehr benötigte Objekte und gibt deren
Speicher wieder frei. Dies entlastet Sie als Programmierer, da Sie sich um dieses Thema nicht
mehr kümmern müssen – und es verhindert den Quell von Fehlern der mit manueller
Speicherverwaltung verbunden ist. Falls Sie jemals z.B. „C“ programmiert haben, dann wissen
Seite 28 / 409
Sie sicher, dass Zeiger und manuelle Speicherverwaltung eine Büchse der Pandorra sind,
deren Problemen man kaum Herr wird. All das gibt es in Java nicht – das macht die Sprache
einfacher und die Programme fehlerfreier.
Eigentlich könnte man hier aufhören, denn damit ist das Thema „Speicherverwaltung und
Garbage-Collection“ oberflächlich ausreichend beschrieben. Und uns fehlt die Zeit detailiert in
die heutigen Techniken und Algorithmen von Garbage-Collectoren einzusteigen, obwohl es ein
ungeheuer interessantes und faszinierendes Thema ist. Aber ein paar Dinge möchte ich Ihnen
doch noch mit auf den Weg geben – heutige Garbage-Collectoren wie z.B. im JDK 1.8 arbeiten
ungeheuer effizient, d.h. :
• Sie erkennen zuverlässig nicht mehr referenzierte Objekte.
• Sie arbeiten sehr schnell. Programme mit Garbage-Collections können den gleichen
Programmen mit manueller Speicherverwaltung in der Performance überlegen sein.
• Seit dem JDK 1.5 kann ein Großteil der Garbage-Collector Techniken auch parallel zum
normalen Programmfluß stattfinden – daher die JVM nutzt z.B. neuere Multi-Core Maschinen
sehr gut aus.
Einziger Nachteil heutiger Garbage-Collector Techniken ist, dass sie einen gewissen
Speicheroverhead haben, d.h. mehr Speicher verbrauen als im Idealfall notwendig wäre. Bei
reinen Mark&Copy Garbage-Collectoren10 kann dieser Overhead fast die Hälfe des Speichers
ausmachen – aber auch hier sind heutige JVM’s viel effizienter geworden.
2.4.2 Performance und HotSpot
Ein immer wieder heißes Thema in der Diskussion um Java ist die Performance. Es ist ja auch
scheinbar sehr einleuchtend, dass Byte-Code auf einem in Software geschriebenen Prozessor
nicht so schnell ausgeführt werden kann wie Maschinen-Code, der direkt auf einem echten
Prozessor ausgeführt wird. Aber das ist nur der erste Eindruck – mittlerweile gibt es über 40
Jahre Erfahrung und Ideen im Bau von virtuellen Maschinen, und viele dieser Ideen betreffen
der Performance. Die beiden interessantesten Technologien sind hier JIT-Compiling und
HotSpot.
JIT steht für „Just-in-Time“, d.h. ein JIT-Compiler ist ein Just-in-Time Compiler. Damit ist
gemeint, dass die virtuelle Maschine statt einfach den Byte-Code auszuführen diesen bei der
ersten Ausführung in Maschinen-Code übersetzt und dann dieser direkt vom Prozessor
ausgeführt wird. Da dieser Übersetzungs-Vorgang Zeit dauert, wird die Ausführungs-Dauer
beim Übersetzen natürlich stark gebremst – danach steht aber die native ProzessorPerformance zur Verfügung.
Eine Garbage-Collector Technik, die mit zwei Heaps arbeitet, von denen einer immer leer ist
– d.h. sinnlos verbrauchter Speicher darstellt. Dafür ist die Technik sehr schnell, da sie noch
referenzierte Objekte nur markieren („mark“) und dann umkopieren („copy“) muß, und die
Speicherfreigabe der restlichen Objekte in Nullzeit erledigt, da sie sie einfach auf dem alten
Heap vergißt.
10
Seite 29 / 409
Prinzipiell ließe sich natürlich der gesamte Java Byte-Code in Maschinen-Code übersetzen,
aber es gibt Bereiche, wo es sich nicht lohnt, der Aufwand sehr hoch ist, oder aus anderen
Gründen nicht wirklich gut praktikabel ist. Außerdem darf auch compilierter Byte-Code nicht die
Sicherheits-Prinzipien von Java wie z.B. die Sandbox verletzen.
Auf der anderen Seite gibt es aber auch Bereiche wo sich mit Informationen aus dem Kontext
des Byte-Codes sehr radikale Optimierungen machen liessen – z.B. wer ruft eine Funktion auf,
bzw. mit welchen Parametern wird sie immer aufgerufen. Und hier kommt HotSpot zum Tragen.
HotSpot ist der Name der JVM seit dem JDK 1.3. Bestandteil von HotSpot ist u.a. ein JITCompiler. Das Besondere an HotSpot ist aber, dass hier die VM das Programm zur Laufzeit
beobachtet, und in Abhängigkeit von diesen Beobachtungen weitere Optimierungen durchführt.
Ein offensichtlicher Hintergrund dieser Vorgehensweise ist die Erkennung sogenannter HotSpots, daher von Programm-Teilen, die besonders häufig ausgeführt werden und bei denen
sich die Optimierung besonders lohnt. Aber HotSpot kann z.B. auch dynamische
Optimierungen durchführen, die die Semantik des Codes verändern, aber im konkret
vorliegenden Kontext funktionieren11.
Hinter HotSpot steht mittlerweile eine Menge Erfahrung und Know-How, und die Optimierungen
werden mit jedem JDK verbessert. Mit JIT-Compiling und den weiteren HotSpot Optimierungen
spielt Java heute von der Performance her auf dem Niveau von normalen compilierten
Sprachen wie z.B. C++ mit. Es gibt sogar ernst zu nehmende Stimmen, die die Meinung
vertreten, dass virtuelle Maschinen viel besser optimieren können als jeder Compiler, da ihnen
viel mehr Informationen zur Verfügung stehen kann.
2.4.2.1 Bemerkung
Eigentlich ist hiermit alles Wichtige gesagt. Natürlich ließe sich noch manches zu den
Techniken von VMs, JIT-Compilern und vor allem HotSpot schreiben – aber eine solche
Vertiefung würde den Rahmen des Tutorials bei weitem sprengen. Ich möchte aber noch ein
bisschen zum Thema Performance von Java sagen, da es scheinbar ein extrem emotional
besetztes Thema mit vielen Gerüchten und Halb-Wahrheiten ist.
Viele Kritiker von Java haben bis heute nicht erkannt bzw. erkennen wollen, dass sich die
Performance von Java seit dem JDK 1.0 immens verbessert hat, und viele ihrer Kritiken heute
nicht mehr zutreffend sind. Auf der anderen Seite gibt es auch eine Menge Java-Fanatiker, die
unreflektiert Java für die performanteste Sprache der Welt halten. Und wenn diese aufeinander
treffen, dann knallt es – manchmal kann das sehr unterhaltsam sein.
Ich kann Ihnen nur empfehlen, wenn Sie mal Langeweile haben – suchen Sie sich z.B. eine
C++ Newsgroup und posten Sie etwas polemisch hinein, dass Java viel schneller ist als C++.
Oder posten Sie umgekehrt in eine Java Newsgroup dass C++ viel schneller als Java ist. Dann
lehnen Sie sich zurüch und genießen den Sprachen-Krieg, den Sie angezettelt haben. An
11
Man nennt solche Optimierungen „Closed-World Optimierungen“.
Seite 30 / 409
langen verregneten Abenden kann dies viel unterhaltsamer als jeder Film sein.
Und wo liegt die Wahrheit? Nirgendwo oder überall. Ich kann Ihnen problemlos ein Programm
schreiben, wo C++ Java schlägt, und auch umgekehrt. Aber was sagt das schon aus? Nichts!
Es kann schon unglaublich komplex und schwierig sein, „objektiv“ und reproduzierbar die
unterschiedliche Performance zweier unterschiedlicher Implementierungen der gleichen
Sprache in der gleichen Umgebung zu beurteilen. Viel schwieriger ist es schon, verschiedene
Bibliotheken zu vergleichen. Wie schwierig ist es dann wohl, akzeptable Vergleiche zwischen
zwei Sprachen zu bekommen? Und ist das überhaupt sinnvoll? Man entscheidet sich doch nicht
für oder gegen eine Sprache nur aufgrund der Performance, sondern auch aufgrund von
hunderten anderer Kriterien.
Ich kann Ihnen nur empfehlen: solange Sie nicht wirklich richtig Ahnung von der Materie haben
– halten Sie sich aus der Performance Diskussion raus. Java ist heute, gerade auf heutigen
Rechnern, verdammt schnell – aber das gilt auch für viele andere Sprachen. Und wenn Sie
wirklich mal ein Performance-Problem haben, suchen Sie nach besseren Algorithmen oder
anderen Implementierungen bevor Sie die Sprache wechseln. In fast allen Fällen reicht das
aus. Und wenn das nicht reicht, dann haben Sie wahrscheinlich ein Problem, das ein einfacher
Sprachenwechsel auch nicht so einfach beseitigt.
2.5 Fazit
Wie Sie sehen, ist gerade die Plattform Java in Form der JVM ein faszinierender Ansatz, der
viele Probleme z.B. bzgl. Portabilität oder Speicherverwaltung radikal beseitigt. Hinzu kommt
eine relativ einfache Sprache, mit der sich das restliche Tutorial beschäftigt, und eine
wunderbare riesige Bibliothek, die viele Probleme löst. In Kapitel 4.1.3 werden wir dann noch
einige sehr mächtige Tools kennen lernen, die uns beim Programmieren stark unterstützen und
auch noch frei sind. Programmierer-Herz – was willst du mehr?
Ach ja, es sollte Ihnen klar sein, dass dieses Kapitel bei weitem nicht alle Java Wörter
vorgestellt hat. Wundern Sie sich also nicht, wenn Sie mit welchen konfrontiert werden, die hier
fehlen. Das Java Universum ist groß und wächst jeden Tag – es gibt viel zu entdecken...
3 Mini-Einführung
In Java können als ausführbare Einheiten Programme, Applets, Midlets und Servlets erstellt
werden. Wir werden hier hauptsächlich Programme erstellen. Der Unterschied zwischen
Applets und Anwendungen ist nicht sehr groß, so dass dies im Augenblick keine praktische
Bedeutung hat12.
12
Es gibt Unterschiede in der Art des Einsprungs, der Sicherheit, der Bibliotheken und der
Konsole - siehe todo...
Seite 31 / 409
Dieses Kapitel stellt einige Grundlagen vor, mit denen Sie ruck-zuck konfrontiert werden, um
überhaupt kleine sinnvolle Programme schreiben zu können, und um die Praktikums-Aufgaben
lösen zu können. Von daher brauchen wir sie, und darum werden sie hier gleich erklärt. Auf der
anderen Seite sind viele dieser Dinge „fortgeschrittenen Themen“, die erst im Laufe der Zeit
kommen. Nehmen Sie sie darum hier einfach hin, und wenden Sie sie pragmatisch an, ohne
zuviel darüber nachzudenken. Im Laufe der Zeit klärt sich alles auf.
3.1 Applikation
3.1.1 Beispiel 1
In einer Java Applikation muss es mindestens eine public-Klasse geben, die folgende KlassenFunktion main enthält:
public class Kap_03_01_Bsp_01_HalloWelt {
public static void main(String[] args) {
System.out.println("Hallo Welt");
}
}
Jede öffentliche Klassen-Funktion („public static“) mit dem Namen „main“, dem Rückgabetyp
„void“, und der Parameterliste „String[ ]“ stellt einen Einsprungpunkt in ein Java Programm dar.
Beim Aufruf der JVM geben Sie eine Klasse an, in der die JVM nach einer solchen KlassenFunktion sucht – und wenn sie gefunden wird, beginnt dort das Programm.
Typischerweise gibt es in einem Java-Programm eine Klasse, die die Anwendung repräsentiert,
eine solche „main“ Funktion hat, und den zentralen Einsprungpunkt in die Anwendung darstellt.
Achtung – der Quelltext der Klasse MUSS in einer Datei mit dem Namen der Klasse selber
und der Extension „java“ stehen. Dies fordert die Sprache! Das gleiche Verfahren gibt es auch
noch bei der Verwendung von Packages. Das obige Beispiel muss also in der Datei
„Beispiel.java“ stehen. Warum dies so ist, wird in Kapitel 4.5 erklärt.
Hinweis – u.a. dieses Beispiel wird im Kapitel 4.3 zur Erklärung der Java-Tools eingesetzt. In
Kapitel 4.3.1.1 können sie es im Editor, als Byte-Code und im laufenden Zustand sehen.
3.1.2 Beispiel 2
Um zum einen schon einen Eindruck von der Einfachheit und Leistunsgfähigkeit von Java zu
bekommen, und zum anderen zu testen, ob ihre Java Installation problemlos funktioniert hat,
hier noch ein zweites einfaches Programm.
import javax.swing.JFrame;
public class Kap_03_01_Bsp_02_Gui {
JFrame frame = new JFrame("Mein erstes GUI Fenster");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Seite 32 / 409
frame.setLocation(200, 200);
frame.setSize(300, 100);
frame.setVisible(true);
}
}
Im Gegensatz zum ersten arbeitet es nicht nur auf der Kommandozeile, sondern öffnet
zusätzlich ein einfaches leeres GUI-Fenster mit dem Titel „Mein erstes GUI Fenster“ – siehe
folgende Abbildung:
Abb. 3-1 : einfaches Beispiel GUI-Fenster mit Java Swing
Hinweis – u.a. dieses Beispiel wird im Kapitel 4.3 zur Erklärung der Java-Tools eingesetzt. In
Kapitel 4.3.1.2 können Sie es im Editor, als Byte-Code und im laufenden Zustand sehen.
Hinweis – erzeugte Objekte (hier „frame“) müssen nicht gelöscht werden. Dies macht die JVM
automatisch. Der entsprechende Vorgang nennt sich Garbage-Collection, und wird in Kapitel
11.4.3 noch mal kurz angesprochen. Je nachdem, von welcher Programmiersprache Sie
kommen, ist dies normal oder ungewöhnlich für Sie. Sprachen wie z.B. C# oder Ruby, haben
auch einen Garbage-Collector, und verhalten sich hier wie Java. Kommen Sie dagegen von
Sprachen wie z.B. Pascal, C oder C++, so ist dieses Verhalten ungewöhnlich, da in diesen
Sprachen der Programmierer Speicher explizit wieder freigeben muss (selbst wenn dies oft
nicht direkt zu sehen ist). Java hat hier den Ansatz des Garbage-Collectors gewählt, der zu
weniger Fehlern und mehr Komfort für den Programmierer führt. Übrigens: Sie müssen
erzeugte Objekte in Java nicht nur „nicht explizit“ löschen, Sie können es natürlich auch gar
nicht. Java hat kein Sprachmittel zu Speicherfreigabe – wozu auch?
3.2 Quelltext
3.2.1 Aufbau
Java Quelltext ist formlos bzw. Block-, Anweisungs- und Token-orientiert aufgebaut – d.h. nicht
zeilen- oder einrückungs-orientiert. Sie können also beliebig Leerzeilen, Leerzeichen,
Tabulatoren und Zeilenumbrüche in ihren Quelltext einfügen, solange sie keine Token
auseinander reißen. Token sind quasi die kleinste syntaktische Einheit von Java, z.B. Symbole
(Namen, Bezeichner,...), Schlüsselwörter (class, import, public,...), Operatoren (+, -, +=, &&,
<<<) und Sonderzeichen ({, }, (, ), [,...)
Seite 33 / 409
3.2.2 Literale: Zahlen, Zeichen und Texte
Literale sind Zahlen-, Zeichen- und Text-Konstanten im Quelltext.
• Integer Literale sind normale Zahlen.
• Gleitkomma-Literale werden an dem Dezimal-Punkt erkannt.
• Einzelne Zeichen-Konstanten einfache
• Zeichenketten-Konstanten (Texte) werden in doppelte Hochkommata eingeschlossen. Sie
müssen spätestens am Zeilenende beendet werden.
2
3.14
.23
2.
'c'
"Hallo"
""
//
//
//
//
//
//
//
Integer Konstante
Fliesskomma Konstante
Zeichen-Konstante
Zeichenketten-Konstante
Leere Zeichenketten-Konstante (Leer-String)
3.2.3 Kommentare
Java unterstützt drei Arten von Kommentaren:
1. Bereichs-Kommentare, die mit /* beginnen und mit */ enden, und dabei beliebige Bereiche
überdecken dürfen – eine Schachtelung ist nicht erlaubt.
2. Zeilenend-Kommentare, die mit // beginnen und für den Rest der Zeile gelten.
3. Spezielle Java-Doc Kommentare, die mit /** beginnen, mit */ enden und spezielle Tags
enthalten – eine Schachtelung ist auch hier nicht erlaubt. Mit dem Tool Java-Doc können
aus diesen Kommentaren automatisch Referenz-Dokumente erzeugt werden. Daher
werden diese Kommentare häufig auch „Java-Doc Kommentare“ genannt. Java-Doc
Kommentare werden in der Vorlesung aus Zeitmangel nicht besprochen.
/*
Dies ist ein Kommentar
*/
double d /* Kommentar */ = 3.1;
int i = 5;
// Noch ein Kommentar
Hinweis – die Nutzung von Java-Doc Kommentaren ist sehr zu empfehlen, da auch aktuelle
Entwickluns-Umgebungen wie z.B. Eclipse oder NetBeans (siehe Kapitel 4.1.3) diese direkt
während der Entwicklung auswerten und z.B. in Views oder Tooltips anzeigen.
3.2.4 Symbole
Java unterscheidet bei Symbolen für z.B. Variablen, Funktionen oder Klassen zwischen Großund Kleinschreibung. „Fenster“, „fenster“ und „FENSTER“ sind drei unterschiedliche Symbole.
Erlaubte Symbole bestehen u.a. aus den Buchstaben ‚a’ - ‚z’, ‚A’ - ‚Z’, Ziffern und dem
Underscore. Hierbei darf das Symbol nicht mit einer Ziffer beginnen. Außerdem sind viele
weitere Unicode Zeichen erlaubt, die Buchstaben und Ziffern darstellen. Sie sollten sie in der
Praxis (zumindest in unserem Sprachraum) aber nicht benutzen. Aber wenn Sie wollen, können
Seite 34 / 409
Sie in Java also japanische Variablen- und chinesische Funktions-Namen vergeben – ich kann
es aber nicht empfehlen.
3.2.5 Konventionen
In Java existiert die Konvention, dass
• Package-Namen klein beginnen und klein geschrieben werden,
• Klassen- und Interface-Namen groß beginnen und kapitalisiert geschrieben werden,
• Funktions- und Variablen-Namen klein beginnen und kapitalisiert geschrieben werden,
• Klassen-Konstanten GROSS mit Underscores geschrieben werden.
Beispiele:
Package-Namen
Klassen- bzw. InterfaceNamen
Funktions-Namen
Variablen-Namen
(auch lokale Konstanten)
Konstanten-Namen
(nur Klassen-Konstanten)
mypackage
metadataauthoring
MyClass
MetaDataManager
AbstractGuiModel
getBackgroundColor
calculateAverage
pidCount
bitLength
DEFAULT_COLOR
START_WIDTH
Selbst wenn sie jetzt noch keine z.B. Packages oder Interfaces kennen, nehmen sie schon mal
zur Kenntnis, daß es für alle Namen in Java Konventionen bzgl. der Schreibweise gibt, an die
sie sich halten sollten.
Damit können wir nun schlussfolgern, dass in der Zeile:
System.out.println("Java");
System eine Klasse, out ein Attribut von System, und println eine Elementfunktion von out sein
muss.
Achtung – in Java sind diese (und andere) Konventionen wichtig, da viele Mechanismen (z.B.
bei Beans13) und Tools darauf basieren. Sie sollten sich also konsequent daran halten. Dies
betrifft nicht nur die Names-Konventionen, sondern auch andere, die wir noch kennen lernen
werden. Viele moderne Entwicklungs-Umgebungen unterstützen Sie durch Warnungen und
Hinweise bei der Einhaltung dieser Konventionen – siehe z.B. Kapitel 4.6.3.
Java-Beans stellen eine Art wiederverwendbare GUI-Komponenten dar. Aus Zeitmangel
werden wir sie in der Vorlesung nicht besprechen können.
13
Seite 35 / 409
3.3 Ausgabe
In einer Applikation kann man Zeichenketten, Konstanten, Variablen, usw. auf die Konsole
ausgeben. Dafür existiert in der Klasse „System“ der Ausgabestream (PrintStream) „out“, für
den es u.a. die Element-Funktionen „print“ und “println“ gibt.
System.out.print(<ein Argument>);
System.out.println(<ein Argument>);
// Ist ein 'print' inkl. Zeilenumbruch
Beide Elementfunktionen erwarten einen Argument beliebigen Typs und geben diesen auf der
Konsole aus. Die Elementfunktion „println“ erzeugt zusätzlich zur Ausgabe analog zu „print“
noch einen Zeilenumbruch.
int i = 7;
System.out.print("->");
System.out.println(i);
System.out.println("Java");
System.out.println(42);
Ausgabe
->7
Java
42
Den Funktionen können beliebige Argumente übergeben werden. Im folgenden Beispiel sieht
man das z.B. an der Ausgabe von „System.out“ – die Ausgabe ist sicher nur bedingt sinnvoll
und hilfreich und vor allem ist sie nicht immer gleich (die Zahl hinter dem @ kann anders sein)
– aber sie zeigt beispielhaft, dass sich wirklich jedes Argument in einen String wandeln und
dann ausgeben läßt.
System.out.print(7);
System.out.print('c');
System.out.println(78);
System.out.println("Hallo");
System.out.println(System.out);
// <- es laesst sich wirklich alles ausgeben
Mögliche Ausgabe (die genaue Ausgabe von System.out ist nicht definiert)
7c78
Hallo
java.io.PrintStream@1a7bf11
Es können auch mehrere Elemente gleichzeitig ausgegeben werden: wenn ein Element ein
String ist, wird beim Operator + das andere Element immer automatisch in einen String
umgewandelt und danach beide Strings konkateniert (siehe auch Kapitel 9.1.2).
int i = 7;
System.out.println("Java " + 42 + " " + i);
System.out.println(42 + " Java " + i);
// Ausgabe: Java 42 7
// Ausgabe: 42 Java 7
Ausgabe
Java 42 7
42 Java 7
Bemerkung – die Auswertungsreihenfolge des Operators + ist in Java von links nach rechts
definiert. Und auch die Addition zweier Zahlen entspricht der normalen Erwartung.
int i = 4;
System.out.println(i + 42);
System.out.println(4 + 5 + 7);
// Ausgabe: 46
// Ausgabe: 16
Seite 36 / 409
Ausgabe
46
16
Der Aufruf von „System.out.println“ ohne Parameter erzeugt einfach nur einen Zeilenumbruch,
sprich eine Leerzeile.
System.out.println();
// Erzeugt eine Leerzeile
3.4 Strings
Neben vielen anderen Typen kennt Java auch einen Datentyp für Texte (Zeichenketten). Dies
ist der Typ „String“. String ist kein elementarer Datentyp (vergleiche Kapitel 5.2), kann aber
trotzdem einfach benutzt werden.
Strings werden im Detail im Kapitel 9.1 besprochen. Wir führen sie hier ganz kurz und
pragmatisch ein, da sie der Typ der Kommandozeilen-Argumente (siehe Kapitel 3.5) und der
Rückgabe-Typ beim Einlesen einer Zeile von der Kommandozeile (siehe Kapitel 3.10) sind.
Strings können mit Literalen initialisiert werden, und können einander zugewiesen werden. Ihre
Länge bestimmt man mit der Element-Funktion „length“.
String s = "Java";
System.out.println("Laenge von \"" + s + "\" ist " + s.length());
Ausgabe
Laenge von "Java" ist 4
3.5 Arrays und Kommandozeilen-Argumente
In den Übungs-Aufgaben werden häufiger Kommandozeilen-Argumente benutzt. Sie werden
der main-Funktion in einem String-Array übergeben. Um das Array auswerten zu können,
benötigen Sie folgende Informationen:
• Die Größe des Arrays kann über das Attribut length abgefragt werden – Zugriff über den
Punkt-Operator ‚.‘.
• Der Zugriff auf die Elemente des Arrays geschieht über den Index-Operator [] (die eckigen
Klammern) mit Index in den Klammern.
• Arrays sind in Java null-basiert, d.h. z.B. das erste Element hat den Index ‚0‘
Jedes Element des String-Arrays für die Kommandozeilen-Argumente ist ein String (vergleiche
Kapitel 3.4), und kann als solcher direkt genutzt werden, oder auch einer String Variablen
zugewiesen werden.
public class Example {
if (args.length==0) {
System.out.println("Kein Argument");
return;
}
System.out.println(args.length + " Argument(e)");
System.out.println("- 1. Arg: \"" + args[0] + "\"");
Seite 37 / 409
if (args.length>1) {
String arg2 = args[1];
System.out.println("- 2. Arg: \"" + arg2 + "\"");
}
}
}
Detaillierter werden Arrays in Kapitel 10 und Strings in Kapitel 9.1 besprochen.
Hinweis – der Zugriff auf ein nicht-existentes Array-Element (d.h. Index kleiner Null oder Index
zu groß) führt zu einer Exception – siehe Kapitel 3.9 und Kapitel 10.6.
Hinweis – u.a. ein Beispiel, das diesem sehr ähnlich ist, wird im Kapitel 4.3 zur Erklärung der
Java-Tools eingesetzt. In Kapitel 4.3.4 können Sie es im Editor, als Byte-Code und im
laufenden Zustand “sehen“.
3.6 Klassen
Klassen sind das elementare Strukturierungsmittel von Java.
Pro Datei muss genau eine öffentliche Klasse vorhanden sein, die der Datei ihren Namen gibt.
Eine Klasse wird folgendermaßen definiert:
[Modifizierer] class <klassen-name> {
[Elementfunktionen, Attribute,...]
}
Eine Klasse wird öffentlich, indem sie den Modifizierer „public“ bekommt. Eine minimale
öffentliche Klasse sieht also so aus:
public class Klasse {
}
Die Datei, in der die Klasse definiert ist, muss genauso heißen wie die Klasse - abgesehen von
der Dateiextension ‘.java’. Die öffentliche Klasse „Klasse“ muss also in einer Datei
„Klasse.java“ stehen. Warum dies so ist, wird in Kapitel 4.5 erklärt.
Hinweis – liegt eine Klasse in einem oder mehreren Packages, so muss die Datei in einer
Verzeichnisstruktur liegen, die der Package Struktur der Klasse entsprecht.
Hinweis – detaillierte Informationen zu Klassen finden sich in den Kapiteln 11 und 12.
3.7 Funktionen
Jeder ausführbare Code steht immer in einer Funktion14.
Na gut, genau genommen kann Code auch noch in Block-Initialisierern stehen, aber über
solch speziellen Sprachmittel wollen wir hier noch nicht reden.
14
Seite 38 / 409
Funktionen sind immer Bestandteil einer Klasse.
Syntax:
Modifizierer <Rückgabetyp> <Fkt-Name> ( <Parameterliste> ) {
<Implementierung>
}
Modifizierer – z.B.: public, private, static, final, ...
Eine Parameterliste ist eine durch Komma getrennte Auflistung von Parametern (sie kann auch
leer sein. Ein Parameter besteht aus Typ und Name – Bsp.:
public static void f() { ... }
protected final int doit(StringBuffer sb) { ... }
private static String calcName(String s, int i) { ... }
Aufruf:
<Fkt-Name>( <Argumentliste> );
Bsp:
f();
calcName("", 1);
Rückgaben können beim Funktions-Aufruf ignoriert werden – siehe im Beispiel der Aufruf der
Funktion „calcName“, die einen String zurückgibt – der beim Aufruf aber ignoriert wird.
Achtung
• Die meisten Funktionen in Java sind sogenannte Elementfunktionen. Sie können nur mit
Objektbezug aufgerufen werden.
• Nur Funktionen mit dem Modifier „static“ (sogenannte Klassenfunktionen) können direkt
benutzt werden.
• Solange wir noch nicht tiefer in Klassen eingestiegen sind, werden alle unsere
selbstgeschriebenen Funktionen Klassen-Funktionen sein – daher den Modifier „static“
enthalten. Bitte denken Sie daran – vergessen Sie das „static“ wird ihr Programm in den
meisten Fällen nicht compilieren.
Hinweis – detaillierte Informationen zu Funktionen finden sich in den Kapiteln 8 und 12.4.
3.8 Packages
Es ist sinnvoll, ihre Programme in Module zu ordnen. Das Sprachmittel hierfür sind Packages.
Um eine Klasse in ein Package zu legen, muss die Datei in einem entsprechenden Verzeichnis
(mit Namen des Package) liegen, und die Datei muß als erste Anweisung (d.h. nicht
Kommentar oder Leerzeilen) eine package-Anweisung enthalten. Ein package-Anweisung
beginnt mit dem Schlüsselwort „package“, dann folgt der Package-Name, und das ganze muß
mit einem Semikolon abgeschlossen sein.
Seite 39 / 409
package mypackage;
Bei verschachtelten Packages müssen auch die Verzeichnisse entsprechend verschachtelt
sein. In der Package-Anweisung werden die Package-Namen dann durch Punkte getrennt.
package mypackage.nocheins.innerespackage;
Analog zu Klassen, deren Namen zu Datei-Namen korrespondieren müssen, müssen also
auch die Package-Namen zu Verzeichnissen korrespondieren. Dies verlangt die Sprache, und
sie müssen sich daran halten. Warum dies so ist, wird in Kapitel 4.5 erklärt.
Hier das „Hallo-Welt“ Beispiel aus Kapitel 3.1.1 in leicht modifizierten Versionen:
• Einmal in einem einfachen Package „pack“.
• Und dann in einem verschachtelten Package „aussen“ in „mitte“ in „innen“.
Beispiel 1 – Achtung, die Datei „Beispiel.java“ muss in einem Verzeichnis „pack“ liegen.
package pack;
public class Beispiel {
}
}
Beispiel 2 – Achtung, die Datei „Beispiel.java“ muss in einem Verzeichnis „innen“ liegen, das in
einem Verzeichnis „mitte“ liegen muss, und das wiederum in einem Verzeichnis „aussen“ liegen
muss.
package aussen.mitte.innen;
}
}
Hinweis – detaillierter werden Packages in Kapitel 13 besprochen.
3.9 Exceptions
Es gibt immer Dinge, die können schief gehen – z.B. eine Eingabe oder ein Array-Zugriff.
Solche Probleme werden in Java immer durch Exceptions gemeldet. Da Sie am Anfang sicher
viele Fehler machen werden (jeder Fehler ist gut, denn er zeigt, dass Sie Java angewendet
haben), werden Sie in Java von Anfang an häufig mit Exceptions konfronitert werden. Im
Augenblick reicht uns – neben dem Thema „Checked-Exceptions“ – siehe gleich – hier das
Wissen, dass mit Exceptions Fehler in unserem Programm angezeigt werden. Irgendetwas
haben Sie falsch gemacht, oder ist einfach schief gelaufen. Am Anfang gehen wir erstmal
davon aus, dass alles gut geht – außer wir wollen den Fehlerfall explizit nutzen, wie z.B. in
Seite 40 / 409
Kapitel 3.11. Daher könnten wir Exceptions eigentlich erstmal ignorieren, aber...
Aber ein Teil der Exceptions können in Java nicht ignoriert werden, nämlich alle CheckedExceptions. Daher: immer wenn eine Funktion ein „Problem“ mit einer solchen CheckedException melden könnte, dann müssen sie sich darum kümmern. Ein Beispiel dafür ist die
Funktion „read“ in der Anweisung „System.in.read()“ im nächsten Kapitel.
Schreiben Sie im Augenblick die problematische(n) Anweisung(en) einfach in einen try-Block
und fügen noch einen leeren catch-Block an. Außerdem merken sie sich, dass der
Programmfluss im Fehlerfall in den catch-Block verzweigt. Beispiele hierfür finden wir gleich in
den Kapiteln 3.10 und 3.11.
System.out.println("vor try");
try {
System.out.println("vor read");
// "read()" kann schief gehen – d.h. koennte eine Exception werfen
System.in.read();
System.out.println("nach read");
} catch (Exception x) {
// Hierhin verzweigt der Programmfluss im Fehlerfall
System.out.println("Fehlerbehandlung");
}
System.out.println("nach try/catch");
Ein zweiter Fall, in dem wir uns auch im Augenblick schon um Exceptions kümmern müssen, ist
wenn Fehler möglich sind, und diese durch Exceptions gemeldet werden. Dies findet sich z.B.
bei Konvertierungen (siehe Kapitel 3.11) oder bei fehlerhaften Array-Zugriffen (siehe Kapitel 3.5
und Kapitel 4.13).
Hinweis – detaillierter werden Exceptions in Kapitel 22 besprochen.
3.10 Eingabe
Die Eingabe von der Kommandozeile war unter Java lange Zeit recht kompliziert, da mehrere
Streams und Reader miteinander verbunden werden mußten, und Checked-Exceptions beteiligt
waren. Prinzipiell ist der Mechanismus mit den Streams und Readern sehr leistungsfähig – nur
für einen Anfänger und eine so alltägliche Aufgabe nicht angemessen – wir werden Streams
und Reader in Kapitel 23 kennen lernen. Mit dem JDK 1.5 konnte das Einlesen mit Hilfe der
Klasse „Scanner“ und der Element-Funktion „nextLine()“ leicht vereinfacht werden. Seit dem
JDK 1.6 kann direkt auf die Kommandozeile zugegriffen und eine Zeile als String eingelesen
werden.
Das folgende Beispiel (für das JDK 1.6) zeigt, wie man eine Zeile als String von der
Kommandozeile einliest und auswertet. Ignorieren Sie erstmal die Dinge, die wir noch nicht
eingeführt haben wie z.B. die Kontrollstrukturen „while“, „if“ und „break“. Der grundsätzliche
Ablauf des Programms sollte auch so klar sein. Es ist ein Echo-Programm, das alle Eingaben
des Nutzers direkt wieder in doppelten Anführungs-Zeichen auf der Kommandozeile ausgibt –
mit der Information wieviele Zeichen eingelesen wurden.
public class Chapter0310Ex01 {
Seite 41 / 409
System.out.println("Echo-Programm - JDK 1.6");
while (true) {
System.out.print("> ");
String in = System.console().readLine();
if (in.length() == 0) {
break;
}
System.out.println(" \"" + in + "\" - " + in.length() + " Zeichen");
}
System.out.println("Programm-Ende");
}
}
mögliche Ausgabe
Echo-Programm - JDK 1.6
> Hallo
"Hallo" - 5 Zeichen
> Ich lerne jetzt Java
"Ich lerne jetzt Java" - 20 Zeichen
>
Programm-Ende
Nehmen Sie das Beispiel erstmal so hin, falls nicht alles klar ist – im Laufe der Vorlesung
werden sich die einzelnen Fragen dazu aufklären. Und wenn sie Eingabe machen müssen,
benutzen sie das Beispiel ganz pragmatisch als Vorlage und passen es im Rahmen ihrer
Kenntnisse und Bedürfnisse an. Die jeweils eingelesene Zeile findet sich innerhalb der WhileSchleife im String „in“, und kann dann von ihnen genutzt werden.
Achtung – das obige Beispiel funktioniert problemlos auf der Konsole, aber nicht in der
Eclipse. Die Eclipse startet ihr Java-Programm im Hintergrund mit einer Umgebung ohne echter
Konsole. Der Aufruf von „console()“ liefert dort „null“ (siehe Kapitel todo) zurück und erzeugt
dann eine Null-Pointer-Exception. Dies ist ein bekannter Bug in der Eclipse, der auch in Version
4.5.2 (Mars Update 2) noch existiert.
• https://bugs.eclipse.org/bugs/show_bug.cgi?id=122429
• http://stackoverflow.com/questions/104254/java-io-console-support-in-eclipse-ide
Darum sind alle Beispiele in diesem Tutorial noch mit dem folgenden JDK 1.1 Mechanismus
umgesetzt.
Aus historischen Gründen – und da Ihnen dieser Code in der Praxis noch häufig begegnen
könnte (z.B. hier im Tutorial, da ich die Eclipse benutze) – hier auch die Beispiele aus ganz
alten Zeiten (ab JDK 1.1) und für das JDK 1.5. Die Programme machen genau das Gleiche wie
das erste Beispiel – sind nur viel mehr Code und schwerer zu verstehen.
Das Beispiel für das JDK 1.1 zeichnet sich dadurch aus, dass
• es Streams & Reader benutzt (siehe Kapitel 23), und
• eine Checked-Exception abfangen muss, die von „reader.readLine()” geworfen werden
könnte.
import java.io.InputStreamReader;
import java.io.BufferedReader;
Seite 42 / 409
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(isr);
while (true) {
String in = reader.readLine();
if (in.length()==0) {
break;
}
}
System.out.println("Unerwarteter Fehler");
}
}
}
Hinweis – da Einlesen schief gehen kann sind hier Exceptions möglich, und hier sind diese
Checked-Exceptions und müssen daher abgefangen werden – vergleiche Kapitel 3.9. Sie
können ja mal den try-catch-Block weg lassen – dann wird der Compiler einen Compiler-Fehler
melden.
Die dritte Implementierung unseres Echo-Programms basiert auf dem JDK 1.5 und nutzt einen
„Scanner“. Da Scanner geschlossen werden müssen und unser Beispiel 100% korrekt sein soll,
müssen wir auch die Fälle berücksichtigen, wo in unserem Programm etwas schief geht und
dieses Problem durch eine Exception gemeldet wird (vergleiche Kapitel 3.9). Dadurch gewinnen
wir wieder etwas Exception-Handling, diesmal in Form eines Try/Finally-Blocks:
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
try {
while (true) {
String in = sc.nextLine();
break;
}
}
} finally {
sc.close();
}
}
}
Sie sehen, nutzen Sie moderne JDKs und bleiben beim Code des ersten Beispiels für das
Einlesen von der Kommandozeile.
Seite 43 / 409
3.11 Konvertierungen
In den Übungs-Aufgaben werden ab und zu Konvertierungen von Strings zu Ganz- oder
Gleitkomma-Zahlen benötigt. Diese Konvertierungen können über Klassen-Funktionen der
Klassen „Integer“ und „Double“ vorgenommen werden. Achtung – die Konvertierungen können
natürlich schief gehen – in diesem Fall wirft die Parse-Funktion eine „NumberFormatException“
Exception. Auch dies ist also ein Beispiel dafür, dass Sie sich in Java immer wieder um
Exceptions kümmern müssen – auch wenn wir sie noch gar nicht richtig kennen.
public class Example {
System.out.println("Kein Argument");
return;
}
System.out.println("Arg: " + args[0]);
try {
int i = Integer.parseInt(args[0]);
System.out.println("i: " + i);
} catch (NumberFormatException x) {
System.out.println(args[0] + " laesst sich nicht in int wandeln");
}
try {
double d = Double.parseDouble(args[0]);
System.out.println("d: " + d);
System.out.println(args[0] + " laesst sich nicht in double wandeln");
}
}
}
Hinweis – die Klassen „Integer“ und „Double“ sind quasi die Objekt-Analogien zu den
elementaren Typen „int“ und „double“. Sie werden z.B. als Wrapper-Klassen für Container
benutzt, und sie bieten allgemeine Hilfs-Funktionen wie z.B. „parseInt“ für den jeweiligen Typ
an. Näheres zu diesen Wrapper-Klassen finden Sie in Kapitel 9.4.
4 Praktikum
4.1 Tools
Für die Entwicklung von Java-Applikationen bzw. Applets werden zwingend ein Editor, ein Java
Compiler und eine virtuelle Java-Maschine (JVM – Java Virtual Machine) benötigt. Es gibt viele
weitere Tools, die das Entwickler-Leben erleichtern können, die aber nicht zwingend notwendig
sind – z.B. Debugger, Test-Werkzeuge, Versions-Verwaltungen, Differ, und und und.
Heutzutage wird ein Java Programm aber typischerweise in einer IDE (Integrierte Entwicklungs
Umgebung) wie Eclipse, NetBeans oder IntelliJ entwickelt. Auch wir werden im Praktikum mit
einer IDE (konkret „Eclipse“) arbeiten – siehe Kapitel 4.1.3 und 4.6. Trotzdem sind auch die
Kommandozeilen-Tools in der Praxis sehr wichtig, und sie fördern ein Verständnis für die
Mechanismen, die in einer IDE unter der Haube ablaufen. Daher wollen wir uns vor den IDEs
Seite 44 / 409
kurz die JDK Entwicklungs-Tools anschauen – siehe Kapitel 4.1.1 und 4.3.
4.1.1 Das JDK und die Tools „java“ und „javac“
Das JDK (siehe auch Kapitel 2.3) von Oracle enthält neben der eigentlichen Java VM auch
viele Tools zur Programmierung mit Java. Da viele diese Tools reine KommandozeilenWerkzeuge sind, ist ihre Benutzung – gerade für den Anfänger – nicht besonders einfach und
komfortabel. Dafür sind sie kostenlos u.a. im Internet erhältlich, und können sowohl privat als
auch komerziell genutzt werden.
Die einfachste Lösung zur Entwicklung von Java-Programmen wäre also ein beliebiger Editor
mit den Kommandozeilen-Werkzeugen „javac“ und „java“ von Oracle.
• Der Java-Compiler „javac“.
Mit diesem Programm wird aus dem oder den Java-Quelltexten der Java Byte-Code erzeugt.
Java Byte-Code hat immer die Extension „.class“.
• Die Java virtuelle Maschine („JVM“) „java“.
Mit diesem Programm wird der Java Byte-Code ausgeführt.
Sie benötigen z.B. das aktuelle Java SDK: J8SE SDK (Java 8 Standard Edition – Software
Development Kit) – die aktuelle Version ist 1.8.0_u77, d.h. JDK 1.8 Update 77 (Stand Anfang
April 2016). Es empfiehlt sich auf jeden Fall auch die „J2SE 8.0 Documentation“ mit
herunterzuladen. Achtung – die Screenshots beziehen sich noch auf Version 1.8.0_u40.
Homepage bzw. Download-Adresse
• http://www.oracle.com/de/index.html
• http://www.oracle.com/de/technologies/java/index.html
• http://www.oracle.com/technetwork/java/javase/downloads/index.html
Seite 45 / 409
Abb. 4-1 : Oracle Homepage – Einstieg in den Download des JDK
Seite 46 / 409
Abb. 4-2 : Oracle Java Download Seite – JDK Auswahl
Seite 47 / 409
Abb. 4-3 : Oracle JDK Download Seite – Plattform auswählen und downloaden
Zusätzlich zum aktuellen JDK sollten Sie immer auch die aktuelle Java-Dokumentation auf der
Oracle Java Download Seite (weiter unten) herunterladen. Und wenn Sie mit JavaFX arbeiten –
siehe Kapitel 16 – dann auch die JavaFX Dokumentation.
Seite 48 / 409
Abb. 4-4 : Oracle Java Download Seite – JDK Dokumentation Auswahl
Abb. 4-5 : Oracle JDK Doku Download Seite – Doku auswählen und downloaden
Hinweis – auf der Oracle Download Seite können Sie übrigens auch in einem immer die jeweils
aktuelle NetBeans IDE mit herunterladen – siehe auch Kapitel 4.1.3.2.
Nach der Installation des JDK steht Ihnen die JVM direkt z.B. auf der Kommandozeile zur
Verfügung und kann mit „java“ aufgerufen werden. Mit der Option „-version“ z.B. gibt die JVM
Seite 49 / 409
nur ihre Version aus und beendet sich dann direkt. Die Ausführung von echten Java
Programmen auf der Kommandozeile lernen wir in Kapitel 4.3.
Abb. 4-6 : Installiertes JDK – Aufruf der JVM
Wollen Sie auch den Java-Compiler „javac“ und die anderen JDK-Tools direkt nutzen können,
so müssen Sie z.B. unter Windows in der System-Steuerung den Pfad zu dem Bin-Verzeichnis
Ihrer JDK-Installation der Umgebungs-Variablen „path“ hinzufügen. Bei einer „normalen“
Installation ist dies unter einer 64 Bit Windows Version: „C:\Program
Files\Java\jdk1.8.0_77\bin“. Wenn Sie dies gemacht haben, dann können Sie auch den JavaCompiler „javac“ direkt auf der Kommandozeile aufrufen – z.B. auch mit der Option „-version“.
Abb. 4-7 : Aufruf des Java-Compilers nach gesetzter Path Umgebungs-Variable
Haben Sie das JDK Bin-Verzeichnis nicht in den Pfad aufgenommen, dann müssen Sie beim
Aufruf den kompletten Pfad-Namen inkl. Extension mitangeben:
Seite 50 / 409
Abb. 4-8 : Aufruf des Java-Compilers mit vollem Pfad
Werden Sie hauptsächlich oder vielleicht ausschließlich mit einer IDE arbeiten, so lohnt sich
das Setzen der Umgebungs-Variablen nicht. Arbeiten Sie häufig auf der Kommando-Zeile, so
rentiert sich das Setzen sehr schnell.
Hinweis – die Nutzung der JDK Tools ist in Kapitel 4.3 beschrieben.
Die hoffentlich mit heruntergeladene Java-Dokumentation müssen Sie nur entpacken. Darin
finden Sie mit „index.html“ den Einstiegs-Punkt in die sehr umfangreiche Dokumentation:
• Die Java Dokumentation „jdk-8u77-docs-all.zip“ entpackt sich nach „docs“
• Die JavaFX Dokumentation „javafx-8u77-apidocs.zip entpackt sich nach „api“
Abb. 4-9 : Entpackte Java Dokumentation
Seite 51 / 409
Abb. 4-10 : Java Dokumentations Einstieg „index.html“
4.1.2 Editor ConTEXT oder Notepad
Für das Arbeiten ohne IDE – was in der Praxis immer wieder sinnvoll ist – empfiehlt sich ein
guter Editor. Während die typische Linux Distribution meist einige sehr mächtige Editoren
enthält, bringt Windows von sich aus nur den Editor „Notepad“ mit, der leider nicht
empfehlenswert ist. Zum Glück gibt es für Windows viele freie Editoren – ganz gut leben kann
man z.B. mit:
• ConTEXT
http://www.contexteditor.org/index.php
• Notepad++
http://notepad-plus-plus.org/
• jedit
http://www.jedit.org/
Aber zweifelsfrei gibt es viele weitere empfehlenswerte Editoren unter Windows.
4.1.3 IDEs
Natürlich gibt es für die Java Entwicklung auch integrierte grafische Entwicklungs-Umgebungen
(IDEs15), die alle notwendigen Werkzeuge (Editor, Compiler, JVM) und viele weitere Tools und
Hilfen unter einem Dach zusammenfassen. Die Benutzung dieser Umgebungen ermöglicht ein
weitaus schnelleres und komfortableres Arbeiten, da viele Arbeiten automatisiert sind bzw. in
einer grafischen Umgebung erfolgen können. Ein Teil dieser IDEs sind als „Personal Version“
für den privaten Gebrauch kostenlos erhältlich. Andere sind komplett frei, d.h. auch für den
komerziellen Gebrauch – darunter fallen z.B. die IDEs Eclipse von IBM oder Net-Beans von
Oracle, die beide sehr empfehlenswert sind.
15
Integrated Development Environment
Seite 52 / 409
4.1.3.1 Eclipse
Eclipse etabliert sich im Augenblick immer mehr als die zentrale Open-Source Umgebung für
die Java Entwicklung. Dies liegt u.a. daran, dass allein IBM über 160 Entwickler16 für die
(Weiter-) Entwicklung von Eclipse einsetzt, und sie trotzdem kostenlos zur Verfügung stellt.
Außerdem gibt es eine große Eclipse Community17, die viele Erweiterungen (Plugins) und Hilfen
bereit stellt. Unterm Strich ist Eclipse mittlerweile ein kleines Monster, eine IDE mit einer
unglaublichen Vielzahl an Möglichkeiten und Features.
Wir werden Eclipse im Praktikum benutzen – die aktuelle Version ist 4.5.2 Mars (Stand Anfang
April 2016). Achtung – die Screenshots beziehen sich noch auf die ältere Eclipse Version 4.4.2
Luna.
Homepage bzw. Download-Adresse
• http://www.eclipse.org
• http://www.eclipse.org/downloads/
Achtung – die Eclipse IDE gibt es in mehreren Varianten. Für den Anwendungsfall der
Vorlesung, d.h. für die Entwicklung von Java Applets und Java Applikationen für den Desktop
ist die „Eclipse IDE for Java Developers“ die richtige Wahl.
Abb. 4-11 : Eclipse Homepage – Wechsel zur Download Seite
Darunter so berühmte Leute wie Erich Gamma, den Autor des Buchs „Entwurfsmuster“ –
siehe Kapitel todo.
17 Dies äußert sich in Deutschland z.B. dadurch, dass es eine eigene Eclipse Zeitschrift gibt,
oder auch Konferenzen zum Thema Eclipse.
16
Seite 53 / 409
Abb. 4-12 : Eclipse Download-Seite – Eclipse IDE for Java Developers
Nach der Installation von Eclipse müssen Sie die heruntergeladene Zip-Datei nur auspacken. In
dem Ziel-Verzeichnis finden Sie dann die Datei „eclipse.exe“, mit der Sie die Eclipse starten
können. Die Nutzung der Eclipse ist in Kapitel 4.6 beschrieben.
Hinweis – Eclipse selber ist in Java geschrieben. Sie benötigen also ein installiertes JRE auf
Ihrem Rechner. Da Sie ja mit Java entwickeln wollen, sollten Sie also das aktuelle JDK
installiert haben – und das enthält auch das jeweilige JRE.
4.1.3.2 NetBeans
Natürlich hat auch Eclipse seine Schwächen, und andere IDEs und Tools ihre Stärken. Die
Vorlesung möchte keine Werbung für Eclipse sein. Schauen Sie sich ruhig die Alternativen gut
an, und entscheiden Sie nach Ihren eigenen Vorstellungen und Wünschen. Eine vergleichbare
Alternative mit manchen Vor- aber auch Nachteilen ist sicher NetBeans von Oracle – URL
siehe Kapitel 4.1.1.
Seite 54 / 409
Hinweis – NetBeans selber ist in Java geschrieben. Sie benötigen also ein installiertes JRE auf
Ihrem Rechner. Da Sie ja mit Java entwickeln wollen, sollten Sie also das aktuelle JDK
installiert haben – und das enthält auch das jeweilige JRE.
4.2 Source Organisation
Bevor wir unsere ersten Programme übersetzen und laufen lassen, noch einmal die folgenden
sehr wichtigen Hinweise:
• Die gesamte programmierte Logik in einem Java Programm spielt sich in Klassen ab.
• Jeder Java Quelltext muss genau eine public Klasse (oder Interface) enthalten.
• Der Name der Klasse muss dem Namen der Quelldatei entsprechen (inkl. Groß- und
Kleinschreibung). Die Datei muss zusätzlich die Extension „.java“ haben.
- Beispiel: Die public Klasse „Pop3Protocol“ muss zwingend in einer Datei
„Pop3Protocol.java“ stehen.
• Liegt die Klasse in einem Package, so muss die Datei in einem Verzeichnis mit dem
entsprechenden Package Namen liegen (auch hier gilt natürlich wieder Gross- und
Kleinschreibung).
- Beispiel: Liegt die public Klasse „TestCase“ in einem Package „applicationlogic“, so muss
die Datei „TestCase.java“ zwingend in einem Verzeichnis „applicationlogic“ liegen.
- Beispiel: Liegt die public Klasse „SeqNode“ in den Packages „db“ und „implementation“
(d.h. das Package „db“ enthält das Package „implementation“), so muss die Datei
„SeqNode.java“ in einem Verzeichnis „implementation“ liegen, und dieses wiederum in
einem Verzeichnis „db“.
• Der Grund für die Korrelation von Klassen- und Datei-Namen, bzw. von Package- und
Verzeichnis-Namen wird in Kapitel 4.5 erklärt.
Die Korrelation von Klassen- zu Datei-Namen, und Package- zu Verzeichnis-Namen wurde
zwar schon in den Kapiteln 3.1 und 3.8 erwähnt, aber die Erfahrung zeigt, dass dies ein ganz
typischer Anfänger-Fehler ist. Darum sollte es hier noch mal erwähnt sein. Passen Sie also
darauf auf. In den letzten Jahren waren sicher die Hälfte der Probleme in den ersten
Praktikumswochen auf diesen Fehler zurückzuführen.
4.3 Benutzung der JDK Entwicklungs-Tools
Für die Beispiele hier wird davon ausgegangen, dass unter Windows gearbeitet wird, das
aktuelle JDK 1.8 installiert ist, und für z.B. den Java-Compiler das JDK Bin-Verzeichnis in die
Path Umgebungs-Variable eingetragen wurde – siehe Kapitel 4.1.1.
4.3.1 Java mit Klassen ohne Packages
Liegen die Java Klassen in keinem Package, so ist die Benutzung der Kommandozeilen-Tools
sehr einfach. Schauen wir uns die die Schritte zur Verarbeitung und Ausführung des „Hallo-
Seite 55 / 409
Welt“ Beispiels aus Kapitel 3.1.1 an.
Achtung – Klassen, die in keinem Package liegen, sollten die absolute Ausnahme sein. Sie
sind eine schnelle Lösung für kleine Test- oder Beispiel-Programme – von daher werden Sie
solche viel in diesem Tutorial finden. Für mehr sollte man sie aber nicht nutzen. Später – wenn
Sie reale Programme schreiben – sollten Sie für alle ihre Programme eine sinnvolle DateiOrganisation anlegen, die sich dann in den Packages und Verzeichnissen widerspiegelt.
4.3.1.1 „Hallo Welt“ Beispiel
Erstellen Sie mit einem Editor den Quelltext des „Hallo-Welt“ Java Programms aus Kapitel 3.1.1
– diesmal aber mit dem Klassen-Namen „HalloWelt“, und speichern Sie ihn unter dem Namen
„HalloWelt.java“ ab. Bei mir liegt die Datei z.B. direkt unter „E:\java“.
Abb. 4-13 : „Hallo Welt“ Quelltext im Editor (Datei „e:\java\HalloWelt.java“)
Achtung – passen Sie auf, dass die Klasse genauso wie die Datei heißt (bis auf die zusätzliche
Extension „.java“) – die Sprache Java fordert dies, siehe Kapitel 3.6.
Öffnen Sie jetzt eine Kommandozeile für dieses Verzeichnis.
Seite 56 / 409
Abb. 4-14 : Kommandozeile für das Verzeichnis „e:\java“
Rufen Sie den Java Compiler „javac“ mit Angabe der zu übersetzenden Datei auf. In
Abhängigkeit von ihrer Konfiguration müssen Sie entweder den Pfad zum Compiler mit
angeben, oder können ihn weglassen – siehe Kapitel 4.1.1. Bei mir ist der Pfad zu den JDK
Entwicklungs-Tools in der Pfad-Umgebungsvariable enthalten – ich brauche den Pfad also
nicht anzugeben:
> javac HalloWelt.java
Der Java Compiler compiliert die angegebene Datei und erzeugt den entsprechenden ByteCode (Datei „HalloWelt.class“) im aktuellen Verzeichnis.
Seite 57 / 409
Abb. 4-15 : Der Java Compiler erzeugt den Byte-Code des „Hallo Welt“ Beispiels
Diesen müssen wir jetzt in der virtuellen Java Maschine (JVM) ausführen. Dazu rufen wir die
virtuelle Maschine „java“ auf, und übergeben den vollständigen Namen der Klasse18.
> java HalloWelt
Abb. 4-16 : Die virtuelle Java Maschine (JVM) führt das „Hallo Welt“ Beispiel aus
Nicht den Namen der Class-Datei oder den Namen der Quelltext-Datei, sondern wirklich den
vollständigen Namen der Klasse. Dies impliziert, dass bei Klassen die in Packages liegen
(siehe Kapitel 4.3.2.2) natürlich auch alle Packages mit angegeben werden müssen.
18
Seite 58 / 409
4.3.1.2 GUI Beispiel
Vergleichbar zum „Hallo-Welt“ Beispiel läuft Handling des GUI Beispiels aus Kapitel 3.1.2 ab.
Abb. 4-17 : GUI Quelltext im Editor (Datei „e:\java\Gui.java“)
Abb. 4-18 : Der Java Compiler erzeugt den Byte-Code des GUI Beispiels
Seite 59 / 409
Abb. 4-19 : Die virtuelle Java Maschine (JVM) führt das GUI Beispiel aus
4.3.1.3 Mehrere Klassen gleichzeitig compilieren
Wollen Sie mehrere Dateien auf einmal übersetzen, so können Sie den Wildcard „*“ im DateiNamen benutzen. Löschen Sie z.B. die beiden gerade erzeugten Class-Dateien, und
compilieren Sie unsere beiden Beispiel-Quelltexte „HalloWelt.java“ und „Gui.java“ in einem
Rutsch neu:
> javac *.java
Abb. 4-20 : Der Java Compiler erzeugt den Byte-Code aller Klassen im Verzeichnis
Seite 60 / 409
4.3.2 Java mit Klassen in Packages
Liegen die Klassen in Packages, so wird das ganze etwas aufwändiger, aber nicht wirklich
kompliziert. Um das zu lernen, schreiben wir ein Beispiel ähnlich dem „Hallo-Welt“ von eben,
nur dass die Klasse jetzt in den Packages „aussen.mitte.innen“ liegt. Natürlich legen wir die
Datei korrekt in die Verzeichnis-Struktur „aussen\mitte\innen“19.
Abb. 4-21 : Package Quelltext im Editor (Datei „PackageBeispiel.java“)
Damit das Beispiel auch später noch nutzbar ist, wenn wir die Source- und Class-Path
Optionen erklären (siehe Kapitel 4.3.2.3 und Kapitel 4.5), legen wir die Verzeichnis-Struktur
„aussen\mitte\innen“ nicht direkt in „e:\java“ an, sondern „betten“ sie noch zusätzlich in ein
Zwischen-Verzeichnis „Sourcen“ ein. So sieht unsere Struktur dann aus:
Abb. 4-22 : Verzeichnis-Struktur für das Package Beispiel
Erinnern sie sich? Packages müssen mit den Verzeichnissen korrespondieren – siehe Kapitel
3.8 und todo.
19
Seite 61 / 409
4.3.2.1 Einfache, aber falsche Vorgehensweise
Wenn Sie jetzt einfach die Vorgehensweise von eben übertragen, erleben Sie eine kleine
Überraschung. Aber warum nicht – probieren wir es einfach mal aus:
• Wir wechseln mit der Konsole in das Verzeichnis „innen“
• Wir rufen den Java Compiler auf
• Und wir starten das Programm...
Abb. 4-23 : Der Java Compiler erzeugt den Byte-Code des Package Beispiels
Wie wir sehen, compilierte der Compiler den Quelltext ganz problemlos, und der Byte-Code
liegt damit vor. Also starten wir das Programm mal:
Abb. 4-24 : Fehler bei der Ausführung des Package Beispiels
Was ist das? Unser Programm startet nicht – statt dessen meldet uns die JVM einen Fehler.
Um das Problem vollständig zu verstehen, fehlt uns noch etwas Wissen. Im Augenblick soll die
Seite 62 / 409
Bemerkung reichen, dass wir versucht haben, den Compiler und vor allem die JVM zu
betrügen. Beim Starten des Programms erzählen wir der JVM von einer Klasse „Beispiel“ ohne
Packages, die aber in Packages liegt.
Belassen wir es dabei – keine Details, die kommen später – lernen wir lieber, wie man es richtig
macht. Aber vorher löschen Sie den fehlerhaft erzeugten Byte-Code „PackageBeispiel.class“,
bevor er uns noch mehr Ärger macht.
4.3.2.2 So ist es richtig
Statt in das Verzeichnis mit dem Java Quelltext zu wechseln, müssen Sie bei der Übersetzung
das Wurzel-Verzeichnis für die Quelltexte angeben. Das Wurzel-Verzeichnis ist quasi das
Verzeichnis, das das äußere Package enthält, bei uns also „e:\java\Sourcen“.
Wechsel wir also zurück in unser Java-Verzeichnis. Wären wir dort also einfach mit unserer
Konsole geblieben, hätten wir uns viel vergebene Arbeit sparen können. Zurück in „e:\java“
werfen wir den Compiler an, und geben jetzt beim Compiler-Aufruf zwei weitere Optionen an:
• Die Option „-sourcepath“ gibt das (oder die) Wurzel-Verzeichnis Ihrer zu übersetzenden
Klassen an – in unserem Beispiel „Sourcen“ als relative Pfad-Angabe oder „e:\java\Sourcen“
als absolute Pfad-Angabe.
• Die zu übersetzende Java-Datei (oder die Java-Dateien) müssen wir jetzt natürlich inkl. Pfad
angeben.
> javac -sourcepath Sourcen Sourcen\aussen\mitte\innen\PackageBeispiel.java
Abb. 4-25 : Der Java Compiler erzeugt den Byte-Code mit „sourcepath“ Option
Hinweise:
Seite 63 / 409
• Natürlich kann man auch hierbei Wildcards benutzen, um alle Dateien gleichzeitig zu
compilieren.
• Stehen Sie während des Compilierens im Wurzel-Verzeichnis Ihres Programms, so geben
Sie als Soure-Path einfach nur den Punkt „.“ an, der ja für das aktuelle Verzeichnis steht.
Für die Ausführung wechseln wir nun in das Wurzel-Verzeichnis unseres Programms, d.h. in
„e:\java\Sourcen“. Wir werden gleich noch lernen, wie man das Programm aus einem
beliebigen Verzeichnis ausführt – aber erstmal einfach:
Beim Aufruf der JVM muss der vollständige Klassen-Name der Main-Klasse mitgegeben
werden. Das war auch eben schon so, aber eben lag die Klasse nicht in einem Package – von
daher war der einfache Klassen-Name auch gleichzeitig der vollständige Klassen-Name. Jetzt,
mit Packages, ist der vollständige Klassen-Name der Klassen-Name inkl. Package-Namen –
getrennt durch Punkte, d.h.: „aussen.mitte.innen.PackageBeispiel“.
> cd Sourcen
> java aussen.mitte.innen.PackageBeispiel
Abb. 4-26 : Korrekte Ausführung des Package Beispiels
4.3.2.3 Und was, wenn man nicht im Wurzel-Verzeichnis steht?
Lassen Sie uns wieder zurück in unser Java-Verzeichnis „e:\java“ wechseln. Nun stehen wir
nicht mehr im Wurzel-Verzeichnis unseres Programms – wie starten wir es denn nun? Wenn
wir hier die JVM mit der Main-Klasse aufrufen bekommen wir nur einen Fehler:
Abb. 4-27 : Fehler bei Ausführung außerhalb des Wurzel-Verzeichnisses
Seite 64 / 409
Das war auch zu erwarten. Woher soll die JVM wissen, wo unser Programm auf der Platte liegt.
Wir stehen quasi in einem beliebigen Verzeichnis – und in einem beliebigen anderen
Verzeichnis liegt unser Programm.
In diesem Fall, muß man – analog zur Option „-sourcepath“ beimm Compiler – nun der JVM
das Wurzel-Verzeichnis angeben. Nur heißt die Option hier „-classpath“ oder kurz „-cp“, da sich
die JVM nicht mehr für die Sourcen interessiert, sondern statt dessen den Klassen-Pfad für den
Byte-Code kennen muss.
> java -cp Sourcen aussen.mitte.innen.PackageBeispiel
Abb. 4-28 : Korrekte Ausführung des Package Beispiels mit Class-Path Option „-cp“
Achtung – genauso wie die Sourcen definiert heißen und an genau definierten Stellen (relativ
zum Source-Wurzel-Verzeichnis) liegen müssen, so muß auch der Byte-Code genau definiert
heißen und relativ zu einer Klassen-Pfad-Wurzel genau definiert liegen. Also benennen Sie
niemals Byte-Code um bzw. verschieben Sie ihn auch nicht, bzw. nur sehr bewußt.
4.3.3 Trennung von Sourcen und Byte-Code
Nun ist die Vermischung von Source-Code und Byte-Code im gleichen Verzeichnis keine gute
Idee – oder sagen wir allgemein: die Vermischung von User-erzeugten und automatisch
generierten Dateien. Schön wäre es, wenn der Java-Compiler den Byte-Code in ein extra
Verzeichnis legen würde. Dies kann mit der Option „-directory“ oder kurz „-d“ erreicht werden.
Seite 65 / 409
Abb. 4-29 : Ausgangs Struktur für Byte-Code eigene Verzeichnisse
Achtung, - das Ausgabe Verzeichnis (hier „output“) muss existieren.
Beispielhaftes Compilieren aus dem Verzeichnis „e:\java“ heraus.
> javac -sourcepath sourcen -d output sourcen\aussen\mitte\innen\*.java
Abb. 4-30 : Der Java Compiler erzeugt den Byte-Code mit Trennung des Byte-Codes
Der Compiler erzeugt nun beim Compilieren nicht nur den Byte-Code, sondern auch die den
Packages bzw. dem Source-Path entsprechende Verzeichnis-Struktur. D.h. im AusgabeVerzeichnis liegt nicht einfach die Byte-Code Datei „PackageBeispiel.class“. Statt dessen hat
der Compiler auch die Verzeichnisse „aussen“, „mitte“ und „innen“ angelegt, und erst im
Verzeichnis „innen“ liegt der Byte-Code.
Seite 66 / 409
Abb. 4-31 : Erzeugte Verzeichnis Struktur und Byte-Code
Denken Sie jetzt beim Starten des Programms nur daran, dass Sie den Class-Path (hier z.B.
„output“), und nicht den Source-Path (hier z.B. „sourcen“) angeben müssen. Die Sourcen und
der Byte-Code liegen jetzt ja in zwei unterschiedlichen Verzeichnis-Strukturen.
> java -cp output aussen.mitte.innen.PackageBeispiel
Abb. 4-32 : Korrekte Ausführung des Package Beispiels mit Trennung des Byte-Codes
Hinweis – wenn Sie so arbeiten, d.h. mit der Trennung des Source-Codes vom Byte-Code,
dann müssen Sie immer nur Ihr Source-Verzeichnis sichern, und haben damit immer alles im
Griff. Der Byte-Code läßt sich ja jederzeit wieder herstellen.
4.3.4 Kommandozeilen-Argumente
Sie können an ein Java Programm Argumente übergeben, indem Sie diese als letzte
Argumente – d.h. nach dem Klassen-Namen – an die JVM übergeben. Unser Beispiel ist der
Einfachheit halber ohne Packages, und lehnt sich an das Beispiel aus Kapitel 3.5 an. Achtung,
das Beispiel soll mit zwei Kommandozeilen-Argument aufgerufen werden:
Seite 67 / 409
Abb. 4-33 : Kommandozeilen Argument Quelltext im Editor (Datei „e:\java\Args.java“)
> javac Args.java
> java Args
> java Args Hallo
> java Args Hallo Java
Abb. 4-34 : Compilation und Ausführung des Kommandozeilen Argumente Beispiels
4.4 Projekt Tools
Nehmen wir mal an, Sie entwickeln ein großes Projekt, mit vielen Packages und noch mehr
Klassen. Das neben Quelltexten auch noch viele andere Dinge wie z.B. Icons, Bilder, Videos
und lokalisierte Textdateien enthält. Und wo es nicht nur Class-Dateien, sondern auch andere
Seite 68 / 409
Dinge erzeugt werden, wie z.B. Jar-Dateien – und sei es nur aus Gründen der Testbarkeit.
Dann wird diese Vorgehensweise – jedes Package händisch auf der Kommandozeile zu
übersetzen – viel zu arbeits- und fehlerintensiv.
Eine Lösung ist natürlich die Verwendung einer IDE wie z.B. Eclipse, in der alle diese Dinge mit
einem hohen Grad an Automation erledigt werden können. Aber möglicherweise wollen oder
können Sie keine IDE verwenden. Oder – und das spiegelt die Praxis in typischen Projekten
eher wider – Sie müssen neben der IDE auch noch eine Kommandozeilen-Lösung
unterstützen20.
In diesem Fall ist das typische Werkzeug im Java Umfeld „Ant“. Die fleissige Ameise Ant ist ein
in Java geschriebenes Open-Source Tool21, mit dem komplette Builds beschrieben und
automatisiert durchgeführt werden können – solange auf dem Build-System eine JVM zur
Verfügung steht. Für Details und weitere Informationen sei hier auf das Internet verwiesen –
siehe z.B. http://jakarta.apache.org/ant.
Ein zweites im Java Umfeld sehr verbreitetes Build-Tool ist Maven (http://maven.apache.org/ ),
aber es existieren noch viele weitere Build-Tools.
Zusätzlich empfehle ich Ihnen neben einem Build-Tool auf jeden Fall eine Versions-Verwaltung
für Ihre Quelltexte – VCS – Version-Control-Systems. Leider sprengen detailierte Informationen
zu VCS den Rahmen des Java Tutorials, lesen Sie z.B. in Wikipedia nach:
http://de.wikipedia.org/wiki/Versionsverwaltung. Folgende Versions-Verwaltungen sind die wohl
zur Zeit verbreitesten Systeme:
• CVS
http://savannah.nongnu.org/projects/cvs
• Subversion – SVN
http://subversion.apache.org/
• Mercurial
http://mercurial.selenic.com/
• Git
http://git-scm.com/
• Perforce
http://www.perforce.com/
4.5 Source-Path und Class-Path
4.5.1 Source-Path
Was sollen eigentlich beim Compilieren und Ausführen diese komischen Source- und ClassZ.B. für automatische Builds jede Nacht, oder für Builds auf zentralen Servern für die keine
IDE vorhanden ist.
21 Ant ist ein Teil des Jakarta Projekts.
20
Seite 69 / 409
Path Angaben. Schauen wir uns dafür mal den Source-Path beim Compilieren an, und nehmen
wir an, wir haben in einem Projekt die zwei Klassen „Class1“ und „Class2“ in zwei parallel
liegenden Packages „pack1“ und „pack2“.
pack1
pack2
Class1
Class2
Abb. 4-35 : 2 Klassen in zwei parallelen Packages
Selbst wenn wir noch nicht viel über Klassen und Packages wissen, sollte uns klar sein, dass
es passieren kann (und auch soll) dass eine Klasse die andere nutzt.
package pack1;
public class Class1 {
private pack2.Class2 cl;
}
// Class1 nutzt Class2 aus dem Package pack2
Klar sollte uns auch sein, dass der Compiler überprüft, ob es die Klasse z.B. überhaupt gibt, ob
„Class1“ sie benutzen darf, oder ob die Benutzung korrekt erfolgt (z.B. entsprechende
Funktionen in der Klasse vorhanden sind)22.
Woher weiss der Compiler aber nun, wo die Klasse „pack2.Class2“ zu finden ist, um diese
Dinge zu überprüfen? Hier kommt drei Dinge ins Spiel:
1) Eine Klasse heißt wie die Datei, in der sie steht.
2) Ein Package heißt wie das Verzeichnis, das es darstellt.
3) Der Source-Path zeigt auf die Wurzel(n) der Package-Struktur.
pack1
Class-Path == d:\source
d:\
source
pack1
Class1.java
pack2
Class2.java
Class1
pack2
Class2
Abb. 4-36 : Klassen, Dateien, Packages, Verzeichnisse und der Source-Path
Der Compiler findet im Quelltext also die Referenzierung der Klasse „pack2.Class2“ und weiß
In Java werden solche Dinge zum Compile-Zeitpunkt vom Compiler gecheckt. Damit können
Fehler schon zur Compile-Zeit gefunden werden, die ansonsten zu Fehlern zur Laufzeit führen.
Es gibt Sprachen, die dies nicht so machen – und die Fehler für den Benutzer aufsparen.
22
Seite 70 / 409
sofort folgende Dinge:
1) Das Package heißt „pack2“ – also muss es im Source-Path Verzeichnis als der Wurzel aller
Sourcen ein Verzeichnis mit Namen „pack2“ geben.
2) Die Klasse heißt „Class2“, also muss es in diesem Verzeichnis eine Datei „Class2.java“
geben, die die Klasse „Class2“ enthält und detailiert definiert.
Mit diesem Wissen kann er also die Definition der Klasse „Class2“ finden, sie einlesen, und alle
notwendigen Überprüfungen durchführen.
Hinweis – in Wirklichkeit kann da noch ein bisschen mehr passieren, da z.B. der Source-Path
mehrere Verzeichnisse umfassen kann, oder der Compiler auch mit Class-Dateien und JarFiles umgehen kann. Aber auch da passiert im Prinzip genau das gleiche wie hier beschrieben.
Der Source-Path hilft dem Compiler also referenzierte Klassen zu finden, um seinen CompileJob mit möglichst vielen Überprüfung durchführen zu können.
4.5.2 Class-Path
Und was ist mit dem Class-Path? Das ist genau das gleiche für die virtuelle Maschine. Der
Class-Path beschreibt, wo der Byte-Code der Klassen zu finden ist. D.h. referenziert er die
Wurzel-Verzeichnisse für die Class-Dateien. Und daher müssen auch die Class-Dateien in
korrespondierenden Verzeichnissen abgelegt werden, und haben auch den Namen der Klasse
als Datei-Namen.
Wird kein Class-Path angeben, wird das aktuelle Verzeichnis als Class-Path angenommen.
Folgende Aufrufe sind also identisch:
> java KlassenName
> java –cp . KlassenName
Der Class-Path kann aber auch über die Environment Variable „CLASSPATH“ einen Default
bekommen, der dann statt des aktuellen Verzeichnisses genommen wird. In so einem Fall
wären die beiden obigen Aufrufe nicht identisch, und der Class-Path müßte auch bei ClassDateien im aktuellen Verzeichnis angegeben werden.
4.6 Eclipse
Viel einfacher wird die Java Entwicklung mit einer IDE (Integrated Development Environment),
da dort alle Tools wie Editor, Compiler, JVM und viele weitere unter einer grafischen Oberfläche
zusammengeführt sind. Besonders komfortabel wird die Entwicklung, wenn ein wahres Monster
von IDE wie z.B. Eclipse (siehe Kapitel 4.1.3) genutzt wird. Aber – seien Sie gewarnt – mit dem
Komfort kommt Hand-in-Hand auch eine gewisse Komplexität. Denn Eclipse kann super-viel,
und hat auch seine eigene Benutzungs-Philosophie.
Dieses Kapitel soll eine einfache kleine Einführung in Eclipse sein. Ihnen sollte aber klar sein,
Seite 71 / 409
dass es nur die rudimentärtsten Features von Eclipse erklären kann23.
Achtung – alle Screen-Shots in diesem Eclipse-Einführungs-Kapitel sind unter Microsoft
Windows 7 im klassischen Design entstanden. Je nach dem von Ihnen verwendeten
Betriebssystem und Design kann das Aussehen bei Ihnen von den Screen-Shots abweichen.
Hinzu kommt noch, dass sich auch das Erscheinungsbild der Eclipse selber und aller
Perspektiven in einem hohen Maße angepaßen und individualisieren werden. Es kann also
ohne weiteres sein, dass Ihre konkrete Eclipse-Installation bei Ihnen ganz anders aussieht.
4.6.1 Workspaces
Nach dem Start von Eclipse müssen Sie als erstes einen Workspace auswählen bzw. neu
anlegen. In Eclipse sind Workspaces für die globale Strukturierung von Projekten da – d.h. in
ihnen können mehrere Projekte zusammengefaßt werden24. Ein Workspace entspricht einem
Verzeichnis, in dem nachher alle Teile des Workspaces liegen. Wenn Sie einen neuen
Workspace anlegen wollen, müssen Sie im Workspace-Launcher daher nur ein
entsprechendes Verzeichnis angeben – hier im Beispiel „e:\java\bsp-workspace“.
Abb. 4-37 : Eclipse Workspace Launcher
Eclipse startet dann mit seinem Begrüßungs-Bildschirm, den wir jetzt ignorieren wollen – d.h.
wir schließen ihn einfach. Später können Sie über den Begrüßungs-Bildschirm z.B. Tutorials
und Beispiele aus dem Internet öffnen.
Es gibt dicke Bücher nur zum Thema Eclipse – darin finden sie alles wichtige,
In der Praxis ist dies sehr normal, dass ein Projekt aus mehreren kleinen Projekten besteht.
Man macht dies, um mehr Übersichtlichkeit zu erreichen.
23
24
Seite 72 / 409
Abb. 4-38 : Eclipse Begrüßungs Bildschirm
Abb. 4-39 : Eclipse Begrüßungs Bildschirm schließen
Danach sehen wir unseren neuen (noch leeren) Workspace in der Java Perspektive.
Seite 73 / 409
Abb. 4-40 : Leerer Workspace in der Java Perspektive
4.6.2 Projekt
Um in der Eclipse ein Java Programm zu schreiben – und sei es noch so klein – muß ein JavaProjekt vorhanden sein. Dies muss also als erstes angelegt werden. Möglich ist dies über viele
alternative Wege, z.B. über das Menü mit „File => New => Java Project...“, über die Toolbar
oder über das Kontext-Menü im Package-Explorer auf der linken Seite, den man im folgenden
Screen-Shot sieht:
Seite 74 / 409
Abb. 4-41 : Neues Projekt anlegen
Es erscheint ein Wizard, der Sie durch das Anlegen eines neues Projekts führt. Auf der ersten
Seite müssen Sie dem Projekt einen Namen geben, hier im Beispiel „Hallo Welt“, da wir ein
Hallo-Welt Programm implementieren wollen.
Man kann hier auf der ersten Seite und der folgende Seite des Wizards noch weitere
Voreinstellungen vornehmen – aber sie interessieren uns zur Zeit nicht, da wir nur ein ganz
einfaches Java-Projekt anlegen wollen. Also beenden Sie den Wizard mit „Finish“.
Seite 75 / 409
Abb. 4-42 : Projekt-Wizard
Nach erfolgreichem Beenden des Projekt-Wizards sehen Sie folgende Workspace Ansicht mit
unserem „Hallo Welt“ Projekt.
Seite 76 / 409
Abb. 4-43 : Workspace mit neuem „Hallo Welt“ Projekt
4.6.3 Klasse
Als nächstes müssen wir eine Klasse erzeugen, denn Klassen sind ja das Strukturierungsmittel
von Java, und ohne eine Klasse läuft gar nichts – siehe Kapitel 3.6. Dafür haben wir wieder
mehrere Möglichkeiten, z.B. über das File-Menü, mit dem Toolbar-Button (siehe rote
Markierung im folgenden Screen-Shot) – oder mit dem Kontext-Menü auf dem Source-Folder
des Projekts mit „New => Class“, wie im Screen-Shot zu sehen:
Seite 77 / 409
Abb. 4-44 : Neue Klasse anlegen
Dann öffnet sich der Klassen-Wizard der Eclipse. Primär muß hier der Name der Klasse und
das Package angegeben werden:
• In unserem Beispiel nenne ich die Klasse „HelloWorldAppl“ – siehe zweiter roter Kasten im
folgenden Screen-Shot.
• Außerdem lege ich die Klasse in das Package „examplepackage“ – siehe erster roter Kasten
im folgenden Screen-Shot – denn in realen Programmen sollten alle Klassen Packages
zugeordnet sein, vergleiche Kapitel 3.8 und Kapitel 13.5.
• Eine weiteres Feature des Klassen-Wizards, das wir direkt nutzen wollen, betrifft die
Möglichkeit sich automatisch eine Main-Funktion generieren zu lassen. Das wollen wir
nutzen, und selektieren die entsprechende Checkbox daher – siehe dritter roter Kasten
Seite 78 / 409
Abb. 4-45 : Klassen-Wizard
Die Namen „HelloWorldAppl“ und „examplepackage“ entsprechen den Java-Konventionen, die
wir in Kapitel 3.2.5 kennen gelernt haben:
• Klassen-Namen beginnen groß und werden kapitalisiert geschrieben
• Package-Namen werden durchgängig klein geschrieben
Auch bei der Einhaltung solcher Konventionen unterstützt uns die Eclipse. Im oberen Bereich
des Wizards wird eine Warnung eingeblendet, wenn wir solche oder andere Konventionen
verletzen. Im folgenden Screen-Shot z.B. sehen wir eine Warnung, wenn wir kein Package, d.h.
das sogenannte Default-Package, verwenden:
Seite 79 / 409
Abb. 4-46 : Warnung bei Nutzung des Default-Packages
Oder im folgenden Beispiel sehen wir eine Warnung, da die Konvention für Klassen-Namen
verletzt wurde – hier z.B. beginnt der Klassen-Name mit einem Kleinbuchstaben:
Abb. 4-47 : Warnung bei fehlerhaftem Klassen-Namen
Alle weiteren Features des Klassen-Wizards ignorieren wir erstmal. Zum einen sagen uns viele
noch nichts, zum anderen müssen Sie ja noch was zum Spielen und Ausprobieren haben.
Mit „Finish“ beenden Sie den Wizard, und Eclipse generiert nach Ihren Angaben:
• Ein Package, wenn angeben, und natürlich inkl. Verzeichnis im Workspace Verzeichnis auf
der Festplatte.
• Eine Klasse in der korrekten Datei, abgelegt im richtigen Package (Verzeichnis).
• Und eine Main-Funktion in der Klasse.
So sieht es das alles dann im Workspace aus.
Seite 80 / 409
Abb. 4-48 : Neue Klasse „HalloWeltAppl“ im Workspace
Ich will auch hier gar nicht auf alle Features von Eclipse eingehen – genau genommen nicht
mal einen Bruchteil – aber ein paar Dinge möchte ich erklären. Den Rest überlasse ich Ihrem
Forschergeist.
• In der Mitte ist der sogenannte Editor-Bereich, in dem die Quelltexte angezeigt und von
Ihnen editiert werden können. Der Editor unterstützt sie mit einer Unmenge von Features, so
z.B. Code-Completion, automatischen Builds, Quick-Fixes, Mark-Occurrences, Folding,
Syntax-Highligthing, Refactoring, uvm. Viel Spaß beim Forschen und Ausprobieren.
• Links im Package-Explorer haben Sie eine logische Sicht auf Ihren Workspace und Ihre
Projekte. Hier finden Sie alle Projekte, Package, Klassen, Libraries und all die anderen
Dinge, die in einem typischen Projekt vorkommen, wieder.
• Unten finden Sie mehrere Views, von denen der Problems-View vorne liegt. In ihm werden
die Compiler-Fehler und –Warnungen des Codes angezeigt. Im Hintergrund liegen Views,
die die Java-Doc bzw. die Deklaration des jeweils selektierten Elements anzeigen. In diesem
Bereich wird sich später auch der Consolen-View öffnen.
• Rechts finden sich mehrere Views untereinander. Da der Screen-Shot so klein ist, sind sie
kaum zu erkennen und so auch nicht zu verwenden. Ich hoffe, Sie haben einen größeren
Seite 81 / 409
Bildschirm:
- Ganz oben findet sich der Task-Views, der Aufgaben verwalten kann.
- Darunter liegt der sogenannte Outline-View, der eine logische Sicht der aktuellen Datei
ermöglicht. D.h. hier finden Sie alle Imports, Klassen, Konstruktoren, Funktionen und
Attribute wieder. Per Doppelklick können Sie sie direkt anspringen.
Dies ist das Default-Aussehen der Eclipse 4.4 – Sie können es aber in großem Umfang ändern
und an Ihre Bedürfnisse und Vorlieben anpassen.
All diese Features sollen uns aber nicht davon abhalten zu programmieren – darum geht es uns
ja gerade. Und dazu gehört natürlich auch unser Hallo-Welt Programm fertig zu
programmieren. All die Features helfen Ihnen hier zwar – aber denken und tippen müssen Sie
immer noch selber. Ich habe es mal gemacht – und das Ergebnis sehen Sie in der nächsten
Abbildung – unsere Main-Funktion enthält nun eine Anweisung, um „Hallo Welt“ auszugeben:
Abb. 4-49 : Fertiger Quelltext im Wizard
4.6.4 Start und Ab...
Jetzt muss unser ultimatives Programm nur noch laufen, und wir können ans Verkaufen und
Seite 82 / 409
Geld verdienen gehen25. Es gibt viele Möglichkeiten unser Programm zu starten. Und manche
davon sind kompliziert, da man viele Einfluss-Möglichkeiten hat (z.B. könnte man dem
Programm mal ein anderes JRE unterschieben, um seine Kompatibilität nach unten oder oben
zu checken).
Mit einer der einfachsten Arten das Programm zu starten ist die Klasse mit der Main-Funktion
im Package-Explorer zu selektieren, und dann über das Kontext-Menü „Run As => Java
Application“ das Programm direkt von hier zu starten.
Falls Sie diese Vision glauben, sind sie a) sehr leichtgläubig und haben b) das Tutorial nicht
ordentlich gelesen. Denn in Kapitel 1 steht extra, dass man nicht alles glauben soll was
geschrieben steht – erst recht nicht, wenn es hier im Tutorial steht ;-).
25
Seite 83 / 409
Abb. 4-50 : Starten des Programms
Unser Programm ist ein reines Kommandozeilen-Programm ohne GUI. Eclipse öffnet jetzt
keine Kommandozeile, sondern stellt einen Consolen-View zur Verfügung, in den das
Programm seine Ausgaben (und später auch Eingaben) macht.
Abb. 4-51 : Ausgabe des Programms
4.6.5 Warnungen
Der Java-Compiler in der Eclipse wird in der Default-Einstellung bei einigen Beispielen aus dem
Tutorial Warnungen erzeugen. Im Prinzip sind diese Warnungen gut und sehr hilfreich, und wir
sollten Code schreiben der keine Warnungen produziert. Aber bei unseren Beispielen machen
wir aber ab und zu Dinge absichtlich falsch, um etwas zu lernen – dann sind uns diese
Warnungen egal.
Wenn Ihr Workspace aber viele Projekte enthält, in denen – aus welchen Gründen auch immer
– zum Teil solche Warnungen auftauchen, dann können eine Menge Warnungen
zusammenkommen. In einem solchen Fall gehen dann schnell wichtige Warnungen
gegenüber den „fehlerhaften“ Warnungen unter und fallen nicht auf. In einem solchen Fall sollte
man die „fehlerhaften“ Warnungen deaktivieren. Sie haben hierzu zwei Möglichkeiten:
• Sie können die Warnung selektiv im Quelltext mit Annotations (siehe Kapitel todo)
Seite 84 / 409
deaktivieren. Dies ist die meistens zweckmäßige Variante, wenn die Warnung an sich
sinnvoll ist – und nur an dieser einen Stelle nicht.
• Oder Sie deaktivieren die Warnung global in der Eclipse in den Eclipse Preferences – siehe
nächste Screenshots. Damit wird die Warnung natürlich nirgendswo mehr erzeugt, und
möglicherweise verhindern Sie damit wichtige Hinweise des Compilers auf fehlerhaften
Code.
Hier zwei Beispiele von Code-Features, die Warnungen erzeugen und in den Beispielen des
Tutorials auftauchen können:
• Das Schreiben serialisierbarer Klassen ohne „serialVersionUID“ Attribute – siehe Kapitel
todo
• Die Verwendung typloser Container – siehe Kapitel todo
Möchten Sie diese Warnungen unterdrücken, so empfehlen sich selektive Annotations (siehe
oben). Alternativ können Sie die Warnungen in den Eclipse Preferences einfach abstellen. Die
Eclipse Preferences erreichen Sie über das Menü „Window => Preferences...“. Unter „Java =>
Compiler => Errors/Warnings“ finden Sie die Details zu den Eclipse/Java Warnungen und
Fehlern – hier ändern Sie dann die Einstellungen von „Warning“ auf „Ignore“ – und schon
haben Sie Ihre Ruhe.
Seite 85 / 409
Abb. 4-52 : Eclipse Warnungs Preferences für „serialVersionUID“
Abb. 4-53 : Eclipse Warnungs Preferences für „typlose Container“
4.6.6 Eclipse
Okay, damit ist unser Kurz-Trip durch die Eclipse fast beendet. Wir haben kurz die wichtigsten
Features für die erste Entwicklung kennen gelernt, wie Workspaces, Projekte, Klassen und den
Consolen-View. Im nächsten Kapitel todo werden wir noch sehen, wie man fertige Projekt und
Einstellungen importiert. Alles weitere kommt im Laufe der Zeit von alleine
Aber vergessen Sie nicht bei all dem Spielen in und mit Eclipse. Eclipse ist nur ein Werkzeug,
eine IDE – das Kern-Thema der Vorlesung ist und bleibt Java.
4.7 Projekte importieren
Damit Sie nicht alle Beispiele abtippen müssen, finden Sie auf meiner Homepage unter
Seite 86 / 409
http://www.wilkening-online.de/tutorial-java.html nicht nur das jeweils neuste Java-Tutorial,
sondern auch viele der Beispiele und Musterlösungen des Tutorials als Eclipse Workspace.
Laden Sie die entsprechende 7z Datei „JavaTutorialWorkspace.7z“ herunter und packen Sie
sie aus. Ich habe das mal beispielhaft direkt unter „E:\“ gemacht.
Abb. 4-54 : Ausgepackter Tutorial Workspace auf “E:\”
Dann starten Sie die Eclipse und legen einen neuen Workspace an – ich habe z.B.
„e:\java\tutorial-wsp“ genommen. Natürlich müssen Sie keinen neuen Eclipse Workspace
anlegen, sondern können die Beispiele auch in einen vorhandenen Eclipse Workspace
übernehmen – ich habe hier aus Gründen der Übersichtlichkeit einen Neuen gewählt.
Seite 87 / 409
Abb. 4-55 : Neuer Eclipse Workspace für die Tutorial Beispiele
Öffnen Sie im Package-Explorer das Kontext-Menü (z.B. mit der rechten Maustaste) und
wählen Sie den Menü-Eintrag „Import“ aus.
Abb. 4-56 : Kontext-Menü mit Import Eintrag
Dann öffnet sich der Import Wizard. Wählen Sie unter „General“ den Eintrag „Existing Projects
into Workspace“ aus und drücken dann den Button „Next“.
Seite 88 / 409
Abb. 4-57 : Import Wizard Seite 1
Damit wechseln Sie zur Seite 2 des Import Wizards:
• Im oberen Bereich geben Sie an, wo der ausgepackte Workspace liegt – in meinem Fall
„E:\JavaTutorialWorkspace“
• Nach Eingabe des Verzeichnisses werden im mittleren Projekt Bereich alle Eclipse-Projekte
aufgelistet, die die Eclipse in dem angegebenen Verzeichnis gefunden hat. Hier können Sie
selektiv die Projekte auswählen, die Sie importieren möchten – defaultmäßig sind hier alle
Projekte selektiert.
• Wenn Sie die Quelltexte in Ihren neuen Workspace kopieren möchten, dann müssen Sie
noch die Checkbox bei „Copy projects into workspace“ setzen. Falls Sie dies nicht machen,
verlinkt die Eclipse Ihre neuen Projekte in Ihrem neuen Workspace mit den Dateien im
Tutorial-Verzeichnis. Dann dürfen Sie das Verzeichnis natürlich nicht löschen oder
anderweitig verändern. Darum kopiere ich die Dateien hier lieber in meinen neuen
Workspace. Je nach Workflow und Anforderung kann natürlich auch das Verlinken in der
Praxis sehr sinnvoll und hilfreich sein.
• Danach müssen Sie nur noch den Button „Finish“ drücken.
Seite 89 / 409
Abb. 4-58 : Import Wizard Seite 2
Damit stehen Ihnen dann alle Beispiele und Musterlösungen in Ihrem Workspace zur
Verfügung. Viel Spaß beim Ausführen, Analysieren, Verstehen und Verändern.
Seite 90 / 409
Abb. 4-59 : Der fertig importierte Eclipse Workspace
4.8 Aufgaben
Der Sinn dieser ersten Aufgaben besteht primär darin, sich mit den Entwicklungs-Tools in Form
von Editor, Java-Compiler „javac“, JVM „java“, und Ihrer ausgewählten IDE wie z.B. Eclipse
oder NetBeans vertraut zu machen. Sekundär werden damit natürlich auch die ersten SprachElemente geübt.
Achten Sie bitte auch bei diesen ersten Programm schon auf sinnvolle Namen und eine
vernünftige Einrückung. Und das gilt natürlich erst Recht für alle weiteren Aufgaben.
4.8.1 Aufgabe „Hallo Welt“
Schreiben Sie eine erste Klasse ohne Package mit Main-Funktion, in der „Hallo Welt“ auf der
Kommandozeile ausgegeben wird.
1) Entwickeln und testen Sie das Programm mit einem Editor, dem Java Compiler „javac“, und
mit der JVM „java“ in einer Kommandozeile.
2) Entwickeln und testen Sie das Programm in Ihrer IDE wie z.B. Eclipse oder NetBeans.
Lösung siehe Kapitel 4.9.
4.8.2 Aufgabe „GUI-Fenster“
Schreiben Sie eine Klasse ohne Package mit Main-Funktion, in der ein GUI Fenster geöffnet
wird.
Seite 91 / 409
4.8.3 Aufgabe „Package“
Schreiben Sie eine Klasse in einem Package mit Main-Funktion, in der etwas passendes auf
der Kommandozeile ausgegeben wird.
4.8.4 Aufgabe „Packages“
Schreiben Sie eine Klasse in einem verschachteltem Package (d.h. das Package liegt wieder
in einem Package) mit Main-Funktion, in der etwas passendes auf der Kommandozeile
ausgegeben wird.
4.8.5 Aufgabe „Summe“
Schreiben Sie ein Programm, dass zwei Gleitkomma-Zahlen von der Kommandozeile einliest
und ihre Summe ausgibt. Fangen sie fehlerhafte Eingaben ab, und geben sie im Falle eines
Fehlers eine Meldung aus.
Dieses Programm hat – bezogen auf unser aktuelles Wissen – einen Knackpunkt: das Einlesen
von Kommandozeile (siehe Kapitel 3.10) ist relativ aufwändig und setzt eine Menge
Pragmatismus voraus26. Etwas einfacher wäre die Benutzung von KommandozeilenArgumenten (siehe Kapitel 3.5).
Pragmatismus meint hier: ich übernehme den Code und passe ihn an meine Bedürfnisse an,
ohne ihn auch nur annähernd zu verstehen.
26
Seite 92 / 409
Nun werden viele der noch folgenden Programme so viel Benutzer-Interaktion erfordern, dass
Kommandozeilen-Argumente keine Lösung darstellen, aber für diese Aufgabe (und noch einige
folgende) wäre dies eine akzeptable Lösung. Und später haben wir ja mehr Erfahrung und
mehr Wissen – bis dahin erscheint uns die Eingabe vielleicht gar nicht mehr so mystisch.
Nachteilig an der Kommandozeilen-Argument Lösung ist aber, dass die Änderung der
Kommandozeilen-Argumente in Eclipse aufwändiger ist. Für das Entwickeln und Testen in
Eclipse wäre das Einlesen von Kommandozeile viel angenehmer und flexibler.
Von daher schlage ich folgenden Kompromiß vor:
• Für den ersten Wurf mit dem Java-Compiler „javac“ und der JVM „java“ implementieren sie
die Aufgabe mit Kommandozeilen-Argumenten.
• Und im zweiten Wurf mit Eclipse – und dann ja auch mit viel mehr Erfahrung – lesen Sie die
Summanden von der Kommandozeile ein.
4.8.6 Aufgabe „Ausgabe Verzeichnis“
Compilieren Sie die Programme der fünf vorherigen Aufgaben mit dem Java Compiler „javac“
so, dass der Byte-Code in einem eigenen Verzeichnis liegt. Starten Sie die Programme danach
Denken Sie sich einen sinnvollen Ausgabe-Pfad Namen aus.
4.9 Lsg. zu Aufgabe „Hallo Welt“ – Kap. 4.8.1
Diese Aufgabe – wie eigentlich fast alle in diesem Kapitel – ist von der Java Seite her sehr
einfach, da der Quelltext z.B. in den Kapiteln 3.1.1 oder 4.3.1.1 oder 4.6.3 fertig vorliegt. Der
Vollständigkeit halber sei hier aber noch mal aufgeführt.
public class Kap0410LsgHalloWelt {
}
}
Für den ersten Teil der Aufgabe, müssen nur noch der Java-Compiler „javac“ und die JVM
„java“, wie in Kapitel 4.3.1.1 beschrieben, benutzt werden.
Die Benutzung der IDE Eclipse wird in Kapitel 4.6 beschrieben. Dies auszuführen ist dann der
zweite Teil der Aufgabe.
Seite 93 / 409
4.10 Lsg. zu Aufgabe „GUI-Fenster“ – Kap. 4.8.2
Auch diese Aufgabe ist ein Übernehmen des fertigen Quelltextes aus z.B. Kapitel 3.1.2, und ein
Anwenden der Tools „javac“ und „java“ wie in Kapitel 4.3.1.2 beschrieben, bzw. von Eclipse
(siehe Kapitel 4.6).
public class Kap0411LsgGui {
JFrame frame = new JFrame("Mein erstes GUI Fenster");
}
}
4.11 Lsg. zu Aufgabe „Package“ – Kap. 4.8.3
Von der Seite der Programmierung ist diese Aufgabe im Prinzip wieder ein „Hallo Welt“.
Einziger Unterschied ist, dass die Klasse in einem Package stehen soll, und daher der Quelltext
mit einer entsprechenden Package-Anweisung beginnen muss – siehe Kapitel 3.8. Er könnte
also z.B. so aussehen:
package mypackage;
public class Appl {
System.out.println("Ausgabe aus einer Klasse in einem Package");
}
}
Die eigentliche Schwierigkeit der Aufgabe liegt im Bereich der Daten-Organisation und der
Tools:
• Bei Verwendung von der Tools „javac“ und „java“ müssen Sie dafür sorgen, dass der
Quelltext in einem entsprechenden Verzeichnis liegt. Und Sie müssen das Compilieren und
Starten des Programms entsprechend Kapitel 4.3.2.2 durchführen.
• Mit Eclipse ist das ganze viel einfacher. Bei der Erzeugung der Klasse mit dem KlassenWizard (siehe Kapitel 4.6.3) müssen Sie einfach im Package-Feld den gewünschten
Package-Namen angeben: alles andere erledigt Eclipse für Sie automatisch richtig.
4.12 Lsg. zu Aufgabe „Packages“ – Kap. 4.8.4
Diese Aufgabe unterscheidet sich von Aufgabe 4.8.3 (Lösung Kapitel 4.11) nur durch drei
verschachtelte statt einem einzigen Package. Der Quelltext ist also bis auf die angepaßte
Package Anweisung und die angepaßte Ausgabe identisch zu Kapitel 4.11.
package aussen.mitte.innen;
Seite 94 / 409
public class Appl {
System.out.println("Ausgabe aus einer Klasse in drei Packages");
}
}
Und was ist sonst zu tun?
• Mit den Kommandozeilen-Tools ist händisch für die richtige Verzeichnis-Struktur zu sorgen.
Danach wieder die Benutzung vergleichbar zur Lösung 4.11.
• In Eclipse müssen im Klassen-Wizard nur alle Packages angegeben werden – den Rest
erledigt Eclipse für uns ☺.
4.13 Lsg. zu Aufgabe „Summe“ – Kap. 4.8.5
4.13.1 Mit Kommandozeilen Argumenten 1
Die erste Lösung basiert auf der Auswertung der Kommandozeilen Argumente, statt die Zahlen
von der Kommandozeile interaktiv einzulesen.
Dieses Programm läßt sich mit etwas Pragmatismus bei der Anwendung der Sprach-Elemente
aus den Kapiteln 3.5 („Arrays und Kommandozeilen-Argumente“), 3.9 („Exceptions“) und 3.11
(„Konvertierungen“) recht einfach implementieren.
Für die Addition benötigen wir zwei Summanden, d.h. müssen auch zwei Kommandozeilen
Argumente übergeben werden. Ist dies nicht der Fall, geben wir eine Fehlermeldung aus, und
beenden das Programm.
if (args.length!=2) {
System.out.println("Das Programm erwartet zwei Zahlen als Eingabe");
return;
}
...
}
Dann müssen die Operanden, die ja als Strings vorliegen, in Double Werte gewandelt werden.
Da dies schief gehen kann – der Benutzer könnte ja z.B. Texte statt Zahlen übergeben, könnte
die Wandlungs-Funktion „Double.parseDouble“ eine Exception werfen. Diese fangen wir ab,
melden dann einen Fehler, und beenden das Programm.
double d1;
try {
d1 = Double.parseDouble(args[0]);
System.out.println("Der erste Parameter ist keine Gleitkomma-Zahl");
return;
}
Und da wir zwei Summanden haben, benötigen wir den Code zweimal in fast identischer
Weise. Unterschiede finden sich in der Double-Variablen „d1“ bzw. „d2“, dem Kommandozeilen
Argument „args[0]“ bzw. „args[1]“ und der Fehlermeldung.
Seite 95 / 409
Am Schluss müssen die zwei Zahlen nur noch addiert werden, und die Summe muss mit einer
Meldung ausgegeben werden.
double sum = d1 + d2;
System.out.println(d1 + " + " + d2 + " = " + sum);
Alles zusammen ergibt dann folgendes Programm:
public class Appl {
System.out.println("Das Programm erwartet zwei Zahlen als Eingabe");
return;
}
double d1;
try {
System.out.println("Der erste Parameter ist keine Gleitkomma-Zahl");
return;
}
double d2;
try {
System.out.println("Der zweite Parameter ist keine Gleitkomma-Zahl");
return;
}
}
}
4.13.2 Mit Kommandozeilen Argumenten 2
Wenn man nicht so viel Werte auf super-detailierte Fehler-Meldungen legt, kann man Lösung 1
noch vereinfachen. In Kapitel 3.9 wurde schon erwähnt, dass Probleme in Java durch
Exceptions gemeldet werden – und dazu gehört auch der Zugriff auf nicht existente ArrayElemente (Kapitel 3.5).
Mit dieser Erkenntnis kann man sich das Leben (das Programm) vereinfachen, und die erste
Fehlerabfrage auf die Existenz der beiden Kommandozeilen Argumente sparen. Man greift
beim Konvertieren einfach blind ins Array, und existiert das Element nicht, so wird auch dies
durch eine Exception gemeldet. Wir sollten vielleicht nur die Fehler-Meldung etwas anpassen,
und schon sieht die Konvertierung so aus:
double d1;
try {
System.out.println("Probleme mit dem ersten Parameter");
return;
}
Seite 96 / 409
Und das ganze Programm ist im Prinzip nur eine Wiederholung dieses Blocks mit Ausgabe der
Summe und dem notwendigen Drum-Herum (Klasse mit Main-Funktion).
public class Appl {
double d1;
try {
System.out.println("Probleme mit dem ersten Parameter");
return;
}
double d2;
try {
System.out.println("Probleme mit dem zweiten Parameter");
return;
}
}
}
4.13.3 Einlesen von Kommandozeile
Auch die Version mit dem interaktiven Einlesen von Kommandozeile ist nicht wirklich
schwieriger. Zuerst muss – wie in Kapitel 3.10 beschrieben – die Tastatur „System.in“ in einem
„InputStreamReader“ und einem „BufferedReader“ gewrappt werden.
Achtung - vergessen Sie die beiden Import-Anweisungen nicht.
Statt jetzt die Kommandozeilen Argumente auszuwerten, müssen Sie einfach nur eine Zeile als
String von der Kommandozeile einlesen:
• Am besten vorher mit einer sinnvollen Aufforderung für den Benutzer.
• Da das Einlesen schief gehen kann, kann „reader.readLine()“ eine Exception werfen. Da
dies eine Checked-Exception ist, muß diese Zeile in einem Try-Catch-Block stehen. Aber
den haben wir ja schon wegen der Konvertierung „String-zu-Double“.
• Da jetzt sowohl die Eingabe als auch die Konvertierung in ein und dem gleich Try-CatchBlock stehen, kann nicht mehr unterschieden werden, ob das Problem beim Einlesen
entstanden ist, oder bei der Konvertierung. Unsere Fehlermeldung sollte also recht
allgemein gehalten sein.27
double d1;
try {
System.out.print("Bitte geben Sie den ersten Summanden ein: ");
Wer gerne bessere Fehlermeldungen hätte, muss die Eingabe und die Konvertierung einzeln
mit einem Try-Catch-Block wrappen, und kann dann dediziert reagieren.
27
Seite 97 / 409
d1 = Double.parseDouble(in);
System.out.println("Probleme mit der Eingabe");
return;
}
Das ganze zweimal, und dann wie gehabt die Summe bilden und ausgeben. Dann noch das
Rum-Herum von Klasse und Main-Funktion, und fertig ist das Programm mit Einlesen von der
Kommandozeile. Es hat doch gar nicht weg getan, oder?
public class Appl {
double d1;
try {
System.out.print("Bitte geben Sie den ersten Summanden ein: ");
return;
}
double d2;
try {
System.out.print("Bitte geben Sie den zweiten Summanden ein: ");
return;
}
}
}
4.14 Lsg. zu Aufgabe „Ausgabe Verzeichnis“ – Kap. 4.8.6
Zu dieser Lösung gibt es nicht viel zu schreiben, da alle Quelltexte schon in den LösungsKapiteln zuvor entwickelt worden sind. Hier sollen ja nur beim Compilieren mit dem JavaCompiler „javac“ der Byte-Code, d.h. die Class-Dateien, in ein extra Ausgabe Verzeichnis
generiert werden.
Typische Namen für Ausgabe-Verzeichnisse sind:
• output - wegen Ausgabe
• class - wegen Class-Dateien
• bin - wegen binärem Code (Byte-Code)
Aber auch andere Namen, die Assoziationen zu Ausgabe, Byte-Code oder Class-Dateien
erzeugen, sind okay.
Seite 98 / 409
Ansonsten gilt nur: das in Kapitel 4.3.3 erklärte anwenden - und fertig ist die Aufgabe.
5 Elementare Datentypen und Variablen
5.1 Datentypen
5.1.1 Datentypen
Java ist eine statisch typisierte Sprache, d.h. jedes Objekt, Variable, Konstante, Literal, usw.
hat einen eindeutigen Typ, der schon zur Compilezeit feststeht.
Java unterscheidet zwischen elementaren und benutzerdefinierten Datentypen.
• Elementare Datentypen sind fest in die Sprache eingebaut – siehe Kapitel 5.2.
• Benutzerdefinierte Datentypen sind Klassen, Enums bzw. Interfaces – siehe Kapitel 11,
Kapitel 12.6 und Kapitel 14.13.
Java unterscheidet zwischen statischen und dynamischen Typen:
• Der statische Typ ist der Typ, den der Compiler sieht.
• Der dynamische Typ ist der wahre Typ des Objekts zur Laufzeit.
Einen Unterschied zwischen statischen und dynamischen Typ kann es bei Objekten im Kontext
von Vererbung geben. Diese wird uns ab Kapitel 14 begegnen.
5.1.2 Typ-Umwandlungen
In Java können sogenannte Typ-Umwandlungen (auch Casts bzw. Type-Casts genannt)
vorgenommen werden. Dies ist notwendig wenn ein Quelltyp nicht zum Zieltyp passt, z.B. bei
einer Zuweisung oder einem Funktionsaufruf.
Eine Typ-Umwandlung wird durch die Angabe des Zieltyps in Klammern vor dem Quellausdruck
vorgenommen.
byte b = (byte) 'A';
Hinweise:
• Sie sollten sich bemühen, Code zu schreiben, der keine oder nur wenige TypUmwandlungen benötigt.
• In Java sind nur Typ-Umwandlungen erlaubt, die syntaktisch Sinn machen.
• Typ-Umwandlungen gibt es nur im Kontext der elementaren Datentypen und innerhalb von
Vererbungs-Hierachien – siehe Kapitel 14.10.
• Typ-Umwandlungen zwischen elementaren Datentypen werden benötigt, wenn der
Quellausdruck nicht ohne Datenverlust in den Zieltyp paßt – dann müssen Sie diese
Wandlung explizit anfordern.
Seite 99 / 409
• Typ-Umwandlungen innerhalb von Vererbungs-Hierachien können zur Laufzeit schief gehen,
sie werfen dann eine Exception – siehe Kapitel 14.10.
5.2 Elementare Datentypen
Folgende elementaren Datentypen sind in Java enthalten:
Name
void
char
boolean
byte
short
int
long
float
double
Grösse / Byte
2
1 Bit
1
2
4
8
4
8
Default
\u0000
false
0
0
0
0
0.0
0.0
Minimum
\u0000
-128
-32768
-2147483648
-9223372036854775808
± 1.40239846 E - 45
± 4.94065645841246544 E - 324
Maximum
\uFFFF
127
32767
2147483647
9223372036854775807
± 3.40282347 E + 38
± 1.79769313486231570 E + 308
5.2.1 void
void ist ein Dummy-Typ, um bei Funktionen anzuzeigen, dass sie nichts zurückgeben.
void fct() {
}
// Diese Funktion gibt nichts zurueck
5.2.2 char
Ein char enthält ein Zeichen im Unicode Zeichensatz – d.h. 2 Byte Grösse.
• Zeichenkonstanten werden in einfache Hochkommata gesetzt.
• Als Zeichenkonsten sind normalen Zeichen, Escape-Sequenzen (z. B. ‘\n‘ für einen
Zeilenumbruch oder ‘\t’ für einen Tabulator) und Unicode Sequenzen (die Angabe muss
hexa-dezimal erfolgen, z. B. '\u03a3') erlaubt.
char c1 = 'A';
char c2 = '\n';
char c3 = '\u03a3';
// Zeichen A
// Zeilenumbruch
// Griechisches Summenzeichen (dezimal 931)
Ein char kann ohne Typ-Cast einem int, long, float und double zugewiesen werden. Ein char
kann mit explizitem Typ-Cast einem byte und short zugewiesen werden – denken Sie aber an
den möglichen Datenverlust!
byte b = (byte) 'A';
long l = 'A';
Umgekehrt kann einem char nur mit Typ-Cast ein integraler- oder Fliesskomma-Wert
zugewiesen werden – denken Sie aber an den möglichen Datenverlust!
char c1 = (char) 42;
char c2 = (char) 3.14;
Seite 100 / 409
Achtung – vielleicht haben Sie sich gewundert, dass ein char und ein short nicht zuweisungskompatibel sind, sondern ein Typ-Cast nötig ist, wo doch beide Typen ein Grösse von 2 Byte
haben. Aber bedenken Sie, dass ein char den Wertebereich von ‘\u0000’ bis ‘\uFFFF’ umfasst,
d.h. keine negativen Zahlen aufweist, während ein short den Wertebereich von ‘-32768’ bis
‘+32767’ umfasst.
5.2.3 boolean
Der Typ „boolean“ ist der Typ für Wahrheitswerte, daher wenn ein Zustand nur falsch („false“)
oder richtig (true) sein kann. Wir benutzen ihn auch häufig als Kriterium in den Java
Konstrollstrukturen – wie z.B. If-Anweisungen oder Schleifen, siehe Kapitel 7.
Ein boolean Wert kann nur „true“ oder „false“ enthalten28.
boolean flag = true;
boolean okay = false;
Ein boolean Wert kann keiner Variablen eines anderen Typs zugewiesen werden, auch nicht
durch Typ-Cast’s.
int i1 = true;
int i2 = (int)true;
// Compiler-Error
// Compiler-Error
Hinweis – diese Idee der Zuweisung eines Boolean an einen Int, wie auch die Idee im
folgenden Beispiel, mag Sie vielleicht etwas verwundern. Wenn ja, dann ist das gut – und dann
vergessen Sie dies direkt wieder. Aber es gibt Programmier-Sprachen, bei denen so etwas
möglich ist – und für all die, die solche Sprachen kennen: in Java geht dies nicht.
Auch umgekehrt kann kein Wert eines anderen Typs einer boolean Variable zugewiesen
werden, oder als boolean Wert benutzt werden, auch nicht durch Typ-Cast’s.
boolean b = (boolean)1;
int i=0;
if (i) {
// Compiler-Error
// Compiler-Error
5.2.4 Integrale Typen
Als integrale Typen stehen byte, short, int und long zur Verfügung. Zahlen-Literale sind
normalerweise immer int, können aber auch einem byte oder short zugewiesen werden, wenn
sie den entsprechenden Zahlenbereich nicht überschreiten. long-Zahlen-Literale werden durch
ein ‘l‘ oder ‘L‘ hinter der Zahl deklariert.
byte b = 13;
short s = 42;
int i = 1234;
long l = 123456789012345L;
28
true und false sind Schlüsselwörter
Seite 101 / 409
In Richtung der größeren Typen kann problemlos eine Zuweisung statt finden. In Richtung der
kleineren nur über einen expliziten Typ-Cast - denken sie aber an den möglichen Datenverlust!
int i = 17;
short s = (short)i;
long l = i;
Jeder integrale Typ kann problemlos jedem Fliesskomma Typ zugewiesen werden – sie können
dabei aber Genauigkeit verlieren!
long l = 123456789012345L
float f = l;
double d = l;
5.2.5 Fliesskomma Typen
Als Fliesskomma Typen stehen float und double zur Verfügung. Fliesskomma-Literale
unterscheiden sich von den integralen Zahlen-Literalen dadurch, dass sie einen Punkt
enthalten. Defaultmässig ist ein Fliesskomma-Literal immer vom Typ double, durch ein
nachgestelltes ‘f‘ oder ‘F‘ wird es zu einem float Literal.
float f = 3.14F;
double d = 3.14;
Ein float-Wert kann problemlos einem double zugewiesen werden, umgekehrt geht dies nur mit
einem expliziten Typ-Cast - denken sie aber an den möglichen Datenverlust!
float f1 = 3.14F;
double d1 = 3.14;
float f2 = (float)d1;
double d2 = f1;
5.3 Variablen
Variablen-Definiton
Syntax:
[Modifizierer] <Typ> <Name> [ = <Initialisierer>] ;
Bsp:
public final int i;
private String name = "Albert Einstein";
double d = 3.1415;
String s;
Variablen können nur in Klassen und in Funktionen definiert werden.
• Variablen in Klassen sind entweder Felder (Attribute oder Klassen-Variablen) – siehe Kapitel
11.4.6 und 12.5.
• Variablen in Funktionen sind lokale Variablen – siehe Kapitel 8.3.
Variablen werden einfach über ihren Namen angesprochen, und können z.B. ausgewertet,
verglichen und neu gesetzt werden.
Seite 102 / 409
String name = "Albert Einstein";
System.out.println("Mein Name ist " + name);
}
}
Mehr über Variablen findet sich in den Kapiteln 5.4, 8.3, 8.4, 11.4.6 und 12.5.
5.4 Wert- und Referenz-Semantik
Variablen unterliegen je nach Typ einer unterschiedlichen Semantik.
• Variablen eines elementaren Datentyps (siehe Kapitel 5.2) unterliegen einer sogenannten
Wert-Semantik.
• Variablen eines beliebigen anderen Datentyps unterliegen der Referenz-Semantik.
5.4.1 Wert-Semantik
Eine Variable hat Wert-Semantik, wenn sie den zu speichernden Wert direkt enthält, und alle
Aktionen auf der Variablen direkt auf dem Wert statt finden.
Nehmen wir z.B. eine Int-Variable „v1“, die mit dem Wert „42“ initialisiert wird.
int v1 = 42;
Für diese Variable wird irgendwo im Speicher ein 4 Byte großer Bereich reserviert, der den
Wert „42“ enthält, und der über den Namen „v1“ angesprochen werden kann.
Wird jetzt eine zweite Int-Variable „v2“ definiert, die mit der Variablen „v1“ initialisiert wird, so
bekommt „v2“ eine Kopie des Wertes von „v1“. Jede Variable enthält ihren eigenen Wert.
int v1 = 42;
int v2 = v1;
System.out.println(v1);
// 42
// 42
Das jede Variable ihren eigenen Wert enthält wird dann deutlich, wenn wir den Wert einer
Variablen ändern – die andere behält ihren alten Wert bei.
int v1 = 42;
int v2 = v1;
// 42
// 42
v1 = 23;
// 23 <- veraendert
// 42 <- nicht veraendert
1.
Seite 103 / 409
2.
v1:
42
3.
v1:
42
v1:
23
v2:
42
v2:
42
Abb. 5-1 : Wert-Semantik
Werte-Semantik liegt aber nicht nur bei einer Initialisierung oder einer Zuweisung vor, sondern
z.B. auch bei Vergleichen (siehe auch Kapitel 6.2) und Funktions-Aufrufen (siehe Kapitel 8.4).
Hier ein Beispiel mit zwei Vergleichen.
int v1 = 42;
int v2 = 42;
if (v1==v2) {
System.out.println("v1 und v2 sind gleich");
}
if (v1==42) {
System.out.println("v1 ist gleich 42");
}
Ausgabe
v1 und v2 sind gleich
v1 ist gleich 42
In beiden Fällen wird der Wert von „v1“ (d.h. die „42“) mit dem Wert des zweiten Operanden
verglichen.
Diese Wert-Semantik gilt für alle Variablen eines elementaren Datentyps (d.h. char, boolean,
byte, short, int, long, float oder double), unabhängig davon ob die Variable eine lokale Variable,
ein Parameter, eine Objekt- oder Klassen-Variable ist.
5.4.2 Referenz-Semantik
Abgesehen von den elementaren Datentypen werden alle Objekte (auch Arrays) in Java mit
einer Referenz-Semantik angesprochen:
• Eine Variable auf einen nicht-elementaren Datentyp enthält nicht das Objekt selber,
sondern nur eine Referenz auf das Objekt, man spricht auch von Referenz-Variablen.
• Eine Referenz-Variable wird mit null initialisiert29.
• Vor der Nutzung einer Referenz-Variablen muss ihr ein Objekt zugewiesen werden.
• ‚Normale‘ Referenz-Variablen-Zuweisungen (Operator =) kopieren das Objekt nicht,
sondern erzeugen nur eine weitere Referenz auf das Objekt.
29
null ist in Java ein Schlüsselwort und ist der Defaultwert von Referenz-Variablen. Er hat
nichts mit dem Wert ‘0‘ der elementaren Datentypen zu tun.
•
•
•
Seite 104 / 409
Bei Funktionsaufrufen unterliegen natürlich auch die Parameter und der Rückgabewert von
nicht-elementaren Datentypen der Referenz-Semantik. Z. B. können also die OriginalObjekte von der aufgerufenen Funktion problemlos verändert werden.
Der Zugriff auf Attribute und Funktionen von Objekten erfolgt über die Referenz-Variable
und den Punkt-Operator.
Der Vergleich zweier Referenz-Variablen vergleicht nicht die Werte der referenzierten
Objekte (Wertgleichheit, bzw. tiefer Vergleich), sondern nur die Gleichheit des
referenzierten Objekts (d.h. Identität, bzw. flacher Vergleich). Achtung – bei Strings kann es
hier ein unerwartetes Verhalten geben – siehe unten bzw. Kapitel 6.2.
StringBuffer buffer1 = null;
if (buffer1==null)
System.out.println("buffer1 ist noch null");
else
System.out.println("buffer1 ist: " + buffer1);
// (1)
buffer1 = new StringBuffer("Hallo");
if (buffer1==null)
System.out.println("buffer1 ist noch null");
else
// (2)
StringBuffer buffer2 = buffer1;
// (3)
buffer1.append(" Welt");
// (4)
Ausgabe
buffer1
buffer1
buffer2
buffer1
buffer2
ist noch null
ist: Hallo
ist: Hallo
ist: Hallo Welt
ist: Hallo Welt
1.
buffer1:
null
2.
StringBuffer
buffer1:
=>
3.
"Hallo"
StringBuffer
buffer1:
=>
buffer2:
=>
4.
"Hallo"
StringBuffer
buffer1:
=>
buffer2:
=>
"Hallo Welt"
Abb. 5-2 : Referenz-Semantik
Seite 105 / 409
Achtung – auch Strings sind Objekte und daher führt der Vergleichs-Operator „==“ nur einen
Identitätsvergleich durch, und keinen Wert-Vergleich. Dies ist ein gern gemachter Fehler, der
um so kritischer ist, da der Code manchmal sogar funktioniert – siehe Kapitel 6.2.
Wird versucht über eine Referenz-Variable mit dem Wert „null“ auf das referenzierte Objekt
zuzugreifen (das ja nicht da ist, da ja nichts (null) referenziert wird), so wird dieser Fehler javatypisch mit einer Exception („java.lang.NullPointerException“) gemeldet.
String s = null;
s.length();
// Wirft NullPointerException
6 Operatoren
Folgende Operatoren stellt Java zur Verfügung.
Vorr.
1
Operator
.
[]
(args)
++, --
2
++, -+, -
Operandentyp(en)
Objekt
Array, Integer
Funktion
arithmetisch
As.
L
L
L
L
Operation
Zugriff auf Objekt-Element
Zugriff auf Array-Element
Funktionsaufruf
Postinkrement, -dekrement (unär)
~
arithmetisch
arithmetisch
integral
R
R
R
Präinkrement, -dekrement (unär)
unäres Plus, unäres Minus
bitweises Komplement (unär)
!
boolean
R
logisches Komplement (unär) (logisches Not)
3
new
(Typ)
Klasse
beliebig
R
R
Objekterzeugung
Typumwandlung
4
*, /, %
arithmetisch
L
Multiplikation, Division, Rest
5
+, +
arithmetisch
String
L
L
Addition, Subtraktion
String-Verkettung
6
<<
>>
>>>
integral
integral
integral
L
L
L
Links-Shift
Rechts-Shift mit Vorzeichen-Erweiterung
Rechts-Shift mit Null-Erweiterung
7
<, <=
>, >=
instanceof
arithmetisch
arithmetisch
Typ
L
L
L
kleiner, kleiner-gleich
grösser, grösser-gleich
Typvergleich
8
==
!=
==
!=
einfach
einfach
Objekt
Objekt
L
L
L
L
gleich (identische Werte)
ungleich (unterschiedliche Werte)
gleich (identisches Objekt)
ungleich (unterschiedliche Objekte)
9
&
&
integral
boolean
L
L
bitweises AND
boolsches AND (alle Operanden werden ausgewertet)
10
^
integral
L
bitweises XOR
Seite 106 / 409
^
boolean
L
boolsches XOR (alle Operanden werden ausgewertet)
11
|
|
integral
boolean
L
L
bitweises OR
boolsches OR (alle Operanden werden ausgewertet)
12
&&
boolean
L
bedingtes AND (Abbruch bei feststehendem Ergebnis)
13
||
boolean
L
bedingtes OR (Abbruch bei feststehendem Ergebnis)
14
?:
boolean, beliebig
R
bedingter (ternärer) Operator
R
R
Zuweisung
Zuweisung mit Operation
15
=
beliebig
*=, /=, %=, beliebig
+=, -=, <<=,
>>=, >>>=,
&=, ^=, |=
• Die meisten dieser Operatoren sollten intuitiv klar sein, da Sie Programmier-Erfahrung
mitbringen.
• Ein paar Operatoren sind nicht zwingend intuitiv in ihrer Benutzung und Semantik, so dass
sie im Weiteren besprochen werden.
• Ein weiterer Teil der Operatoren macht erst im späteren Verlauf der Vorlesung Sinn, da uns
hier noch das entsprechende notwendige Sprachverständnis fehlt. Sie werden in den
jeweiligen Themen-Kapiteln vorgestellt, z.B. der Operator „instanceof“ in Kapitel 14.10.
6.1 Zuweisungs-Operatoren
Der normale Zuweisungs-Operator ‘=’ weist den Wert des rechten Ausdrucks der Variablen auf
der linken Seite zu.
Zusätzlich gibt es in Java noch Zuweisungs-Operatoren mit Operationen. Die Anweisung ‘erg
#= arg;’ entspricht dabei immer der Anweisung ‘erg = erg # (arg);’30.
int i = 7;
int j = 4;
i += 3*j;
// entspricht:
// Ausgabe: 19
i = i + (3*j);
6.2 Gleich- und Ungleich-Operatoren
Bei den elementaren Datentypen vergleichen die Operatoren ‘==’ und ‘!=’ den Wert, während
bei Objekten die Identität (gleiches bzw. verschiedenes Objekt) verglichen wird – siehe auch
z.B. Kapitel 5.4.
Fangen wir mit einem Beispiel an, wo wir sehen, dass bei int’s mit den Werten gearbeitet wird:
int i = 7;
int j = 7;
Durch die angegebene implizite Klammerung um ‘arg’ gibt es niemals Probleme mit den
Operator-Prioritäten - es wird immer Gesamt-‘arg’ auf ‘erg’ angewandt.
30
if (i==j)
System.out.println("Gleich");
else
System.out.println("Ungleich");
j = 8;
if (i==j)
else
Seite 107 / 409
// Ausgabe: Gleich
// Ausgabe: Ungleich
Ganz anders ist das Verhalten bei Objekten, wo mit „==“ bzw. „!=“ die Identität verglichen wird:
StringBuilder sb1 = new StringBuilder("sb");
if (sb1==sb2)
else
sb2 = new StringBuilder("xxx");
if (sb1==sb2)
else
sb2 = sb1;
if (sb1==sb2)
else
// Ausgabe: Gleich
Achtung – dies ist ein gern gemachter Fehler. Wert-Vergleiche auf Objekten müssen meist mit
der Element-Funktion „equals“ gemacht werden, da „==“ nur die Identität vergleicht. Leider muß
man hier sehr vorsichtig sein, da es Klassen gibt bei denen auch „equals“ nur die Identität
vergleicht und nicht den Wert.
if (sb1.equals(sb2))
else
sb2 = new StringBuilder("xxx");
else
sb2 = sb1;
else
// Ausgabe: Gleich
// Ausgabe: Gleich
Achtung – ganz gefährlich wird es bei Strings. In Kapitel 9.1 werden wir lernen, dass Strings
„immutable“, d.h. unveränderlich, sind. Daher kann die JVM gleiche Strings ohne Gefahr
zusammenlegen, um z.B. Speicher zu sparen. Daher können einzelne – eigentlich nicht
identische Objekte – identisch sein. Es kann also sein, dass Sie in Ihrem Programm bei Strings
fehlerhafterweise „==“ statt „equals“ verwenden, und es erstmal läuft. Gefährlich ist dies
Seite 108 / 409
deshalb, weil dieses Verhalten nicht zugesichert ist, sondern sich in anderen JVMs wieder
ändern kann.
String s1 = "Hallo";
// Kann vielleicht auf das gleiche Objekt zeigen
if (s1==s2) {
System.out.println("Identisch ");
}
else {
System.out.println("NICHT identisch ");
}
// Identitaets-Abfrage
if (s1.equals(s2)) {
System.out.println("Gleicher Wert");
}
// Defenitiv Wert-Vergleich
mögliche Ausgabe
NICHT identisch
Gleicher Wert
6.3 Geteilt- und Modulo-Operator
Während die normalen mathematischen Operatoren (plus, minus und mal) in ihrem Verhalten
ziemlich intuitiv sind, ist dies beim Geteilt- und Modulo-Operator vielleicht nicht so.
6.3.1 Geteilt-Operator
Im Prinzip arbeitet auch der Geteilt-Operator ganz intuitiv, außer man wendet ihn auf integrale
Typen (byte, short, int und long) an und erwartet dann ein Fließkomma-Ergebnis (z.B. double).
Das funktioniert so nicht – die Division bleibt im Bereich der Typen der Operanden, und das
betrifft auch das Ergebnis.
Teilen Sie Integer durch Integer, so ist das Ergebnis wieder ein Integer – selbst wenn das
Ergebnis damit nicht exakt ist. Das Ergebnis ist nur der ganz-teilige Anteil der Division, den
Rest kann man mit dem Modulo-Operator bestimmen – siehe Kapitel 6.3.2.
System.out.println("10
Ausgabe
10 / 1
10 / 2
10 / 3
10 / 4
10 / 5
10 / 6
10 / 7
10 / 8
10 / 9
->
->
->
->
->
->
->
->
->
/ 1 -> "
/ 2 -> "
/ 3 -> "
/ 4 -> "
/ 5 -> "
/ 6 -> "
/ 7 -> "
/ 8 -> "
/ 9 -> "
/ 10 -> "
/ 11 -> "
/ 12 -> "
+
+
+
+
+
+
+
+
+
+
+
+
(10
(10
(10
(10
(10
(10
(10
(10
(10
(10
(10
(10
/
/
/
/
/
/
/
/
/
/
/
/
1));
2));
3));
4));
5));
6));
7));
8));
9));
10));
11));
12));
//
//
//
//
//
//
//
//
//
//
//
//
-> 10
-> 5
-> 3
-> 2
-> 2
-> 1
-> 1
-> 1
-> 1
-> 1
-> 0
-> 0
10
5
3
2
2
1
1
1
1
Seite 109 / 409
10 / 10 -> 1
10 / 11 -> 0
10 / 12 -> 0
Wie dividiert aber nun zwei Integer-Zahlen so, daß man das korrekte Fließkomma-Zahlen
Ergebnis erhält? Ganz einfach: man muß vor der Division mindestens einen der beiden
Operanden in den gewünschten Fließkomma-Zahlen-Typ („float“ oder „double“) konvertieren.
final int divisor = 7;
final int divident = 2;
int res1 = divisor / divident;
double res2 = (double) divisor / divident;
double res3 = divisor / (double) divident;
double res4 = (double) divisor / (double) divident;
System.out.println("res1
Ausgabe
res1 ->
res2 ->
res3 ->
res4 ->
->
->
->
->
"
"
"
"
+
+
+
+
res1);
res2);
res3);
res4);
//
//
//
//
->
->
->
->
3
3,5
3,5
3,5
3
3.5
3.5
3.5
Hinweis – für Konvertierungen zwischen elementaren Datentypen siehe Kapitel 5.1.2.
6.3.2 Modulo-Operator
Der Modulo-Operator kann nur auf integrale Typen angewendet werden, und liefert dann den
Rest der Integer-Division – siehe Kapitel 6.3.1.
Ausgabe
10 % 1
10 % 2
10 % 3
10 % 4
10 % 5
10 % 6
10 % 7
10 % 8
10 % 9
10 % 10
10 % 11
10 % 12
->
->
->
->
->
->
->
->
->
->
->
->
% 1 -> "
% 2 -> "
% 3 -> "
% 4 -> "
% 5 -> "
% 6 -> "
% 7 -> "
% 8 -> "
% 9 -> "
% 10 -> "
% 11 -> "
% 12 -> "
+
+
+
+
+
+
+
+
+
+
+
+
(10
(10
(10
(10
(10
(10
(10
(10
(10
(10
(10
(10
%
%
%
%
%
%
%
%
%
%
%
%
1));
2));
3));
4));
5));
6));
7));
8));
9));
10));
11));
12));
//
//
//
//
//
//
//
//
//
//
//
//
-> 0
-> 0
-> 1
-> 2
-> 0
-> 4
-> 3
-> 2
-> 1
-> 0
-> 10
-> 10
0
0
1
2
0
4
3
2
1
0
10
10
Seite 110 / 409
6.4 Bitweises AND, OR, XOR
Überarbeiten todo
Die Operatoren ‘&’, ‘|’ und ‘^’ arbeiten sowohl mit integralen als auch mit boolschen Datentypen
zusammen.
Bei integralen Datentypen werden die interne Darstellung bitweise miteinander verknüpft.
AND
Op. 1
0
0
1
1
Op.2
0
1
0
1
OR
Erg.
0
0
0
1
Op. 1
0
0
1
1
Op.2
0
1
0
1
XOR
Erg.
0
1
1
1
Op. 1
0
0
1
1
Op.2
0
1
0
1
Erg.
0
1
1
0
6.5 Boolsches bzw. bedingtes AND, OR, XOR
Bei boolschen Operanden werden die Operanden logisch miteinander verknüpft, wobei immer
alle Operanden ausgewertet werden.
Bei den bedingten Operatoren ‘&&’ und ‘||’ werden die Operanden auch logisch miteinander
verknüpft, aber die Auswertung wird abgebrochen wird, sobald das Ergebnis feststeht. Es kann
daher passieren, dass nicht alle Operanden ausgewertet werden.
public static boolean fct(int i) {
System.out.println("fct(" + i + ')');
return true;
}
boolean erg, b = true;
erg = b & fct(1);
erg = b | fct(2);
erg = b ^ fct(3);
erg = b && fct(4);
erg = b || fct(5);
b = false;
erg = b & fct(6);
erg = b | fct(7);
erg = b ^ fct(8);
erg = b && fct(9);
erg = b || fct(10);
}
Ausgabe
fct(1)
fct(2)
fct(3)
fct(4)
fct(6)
fct(7)
fct(8)
fct(10)
Seite 111 / 409
6.6 Prä- und Post-Inkrement und -Dekrement Operatoren
Den Operator ‘++’ gibt es in Prä- und Postfix-Notation. Er ist für alle arithmetischen Typen
definiert und entspricht einer Erhöhung um ‘1’. Analog entspricht der ‘—‘ Operator einer
Erniedrigung um ‘1’.
int i = 7;
i++;
++i;
i--;
--i;
// Ausgabe: 8
// Ausgabe: 9
// Ausgabe: 8
// Ausgabe: 7
Im obigen Beispiel ist die Unterscheidung in Prä- und Postfix-Notation egal, aber in anderen
Zusammenhängen ist sie es nicht.
Diese Operatoren können direkt in arithmetischen Ausdrücken benutzt werden - in so einem
Fall entscheidet die Notation, ob die Variable zuerst ausgewertet und dann verändert wird, oder
umgekehrt:
• Präfix-Notation ‘++x’ bzw. ‘–-x’
1. verändern von ‘x’
2. auswerten von ‘x’
• Postfix-Notation ‘x++’ bzw. ‘x--’
1. auswerten von ‘x’
2. verändern von ‘x’
int i = 7;
int j = ++i;
System.out.println(i + " " + j);
j = i--;
System.out.println(i + " " + j);
// Ausgabe: 8 8
// Ausgabe: 7 8
Im Gegensatz zu einigen anderen Programmiersprachen wie z.B. C und C++ ist auch bei
Verwendung mehrere dieser Operatoren in einer Anweisung das Ergebnis exakt definiert, da es
in Java eine eindeutige Abarbeitung von Ausdrücken gibt: zuerst werden bei einer Anweisung
die Operanden von links nach rechts ausgewertet, dann wird der Rest der Anweisung
durchgeführt – mit der Ausnahme von Operanden bei bedingtem Und und Oder!
int i = 2;
int j = ++i + ++i * ++i;
// entspricht 3+4*5
// Ausgabe: 23
6.7 Schiebe-Operatoren
Die Schiebe-Operatoren ‘<<’, ‘>>’ und ‘>>>’ wirken nur auf integrale Datentypen.
Der Operator ‘<<’ schiebt die Bits des integralen Operanden um n-Bits nach links, d.h. er
bewirkt bei allen Zahlen (negativ und positiv) eine Multiplikation mit 2.
int i = 3;
int j = -5;
System.out.println((i<<1) + " " + (j<<2));
Seite 112 / 409
// Ausgabe: 6 -20
Der Operator ‘>>’ schiebt die Zahl um n-Bits nach rechts mit Vorzeichen-Erweiterung. D.h. das
Vorzeichen der Zahl bleibt erhalten. Dagegen füllt der Operator ‘>>>’ die Zahl immer mit NullBits auf - er betrachtet die Zahl quasi immer als vorzeichenlos.
int i = 5;
int j = -5;
int k = -5;
System.out.println((i>>1)+" "+(j>>1)+" "+(k>>>1));
// Ausgabe: 2 -3 2147483645
6.8 Frage-Zeichen Operator
todo
6.9 Aufgaben
6.9.1 Aufgabe „Inkrement-Operator“
Schreiben Sie ein kleines Programm, das den Unterschied im Verhalten der Prä- und PostInkrement Operatoren („++“) aus Kapitel 6.6 verdeutlicht, d.h. wo ein Vertauschen der
Operatoren zu einem anderen Ergebnis führt.
6.10 Lsg. zu Aufgabe „Inkrement-Operator“ – Kap. 6.9.1
Um das unterschiedliche Verhalten der Operatoren für Prä- und Post-Inkrement zu sehen, ist
es wichtig zu verstehen, dass die Addition um „1“ nicht die einzige Aktion der Anweisung ist.
Die beiden folgenden Zeilen unterscheiden sich semantisch (d.h. in ihrer Wirkung) nicht, da hier
die Addition die einzige veränderne Aktion in der Anweisung ist.
++i;
i++;
// Diese beiden Zeilen haben so fuer sich die gleiche Wirkung,
// d.h. hat ein Vertauschen der Operatoren hat hier keine Auswirkung
Um den Unterschied zu sehen, muss man den Wert des „++“ Ausdrucks in der Anweisung
auswerten. Dazu führen wir eine zweite Variable ein, der wir den „++“ Ausdruck zuweisen.
j = ++i;
j = i++;
Jetzt müssen wir nur noch für gleiche Startwerte sorgen, und das Ergebnis ausgeben. Hier am
Beispiel des Prä-Inkrement-Operators:
int i = 4;
int j = 0;
System.out.println("Prae-Inkrement");
j = ++i;
System.out.println("j = ++i");
Seite 113 / 409
System.out.println("=> i: 4 -> " + i);
System.out.println("=> j: 0 -> " + j);
Jetzt das gleiche noch für den Post-Inkrement-Operator, und dann das ganze in eine Klasse
und eine Main-Funktion – schon ist das Programm fertig:
public class Appl {
int i = 4;
int j = 0;
System.out.println("Prae-Inkrement");
j = ++i;
System.out.println("j = ++i");
i = 4;
j = 0;
System.out.println("\nPost-Inkrement");
j = i++;
System.out.println("j = i++");
}
}
Ausgabe
Prae-Inkrement
j = ++i
=> i: 4 -> 5
=> j: 0 -> 5
Post-Inkrement
j = i++
=> i: 4 -> 5
=> j: 0 -> 4
An der Ausgabe sieht man sehr schön den Unterschied:
• Beim Prä-Inkrement wird zuerst das „i“ erhöht (von 4 auf 5), und dann der neue Wert von „i“
(5) der Variablen „j“ zugewiesen. Daher haben beide Variablen nach der Anweisung den
Wert „5“.
• Beim Post-Inkrement wird zuerst der bisherige Wert (4) des „i“ genommen und als Ergebnis
des Ausdrucks benutzt, d.h. hier dem „j“ zugewiesen. „j“ hat also den Wert „4“. Erst danach
wird „i“ erhöht, und bekommt damit den Wert „5“. Diese Erhöhung hat keinen Einfluß mehr
auf den Rest dieser Anweisung.
7 Kontroll-Strukturen
7.1 Bedingter-Kontrollfluss – If
Die wichtigste Kontroll-Struktur ist die If-Anweisung. Sie ermöglicht einen bedingten Sprung,
d.h. in Abhängigkeit von einem Boolschen-Ausdruck unterschiedliche Pfade im Programm zu
durchlaufen.
Seite 114 / 409
7.1.1 Einfachste Form
Die einfachste Form der If-Anweisung sieht folgendermaßen aus:
Syntax:
if (boolean-ausdruck)
true-anweisung
Sie beginnt mit dem Schlüsselwort „if“ – dann folgt in runden Klammern ein Ausdruck, der vom
Typ „boolean“ sein muss. Abgeschlossen wird sie durch eine Anweisung. Diese Anweisung
wird nur ausgeführt, wenn der Ausdruck zu „true“ ausgewertet wurde. Im Falle von „false“ wird
die Anweisung übersprungen.
int n = 5;
if (n<7)
System.out.println("n<7");
if (n>20)
System.out.println("n>20");
if (n!=6)
System.out.println("n!=6");
Ausgabe
n<7
n!=6
7.1.2 Blöcke für mehrere Anweisungen
Soll im If-Zweig mehr als eine Anweisung ausgeführt werden, so muß mit den geschweiften
Klammern ein Block gebildet werden. Ein solcher Block steht dabei syntaktisch für eine
einzelne Anweisung.
int n = 5;
if (n<7) {
System.out.println("n ist " + n);
System.out.println("Und weiter geht es...");
}
Ausgabe
n<7
n ist 5
Und weiter geht es...
Hinweis – dies gilt genauso für Schleifen oder andere Konstrukte, die normalerweise nur auf
eine Anweisung wirken.
7.1.3 If-Else Anweisung
Für den Fall, dass neben dem True-Fall auch beim False-Fall Aktionen ausgeführt werden
sollen, kann auf die Anweisung (bzw. dem Block) des True-Falls das Schlüsselwort „else“ mit
einer Anweisung für den False-Fall folgen.
Seite 115 / 409
Syntax:
true-anweisung
else
false-anweisung
Beispiel:
int n = 5;
if (n<7)
else
System.out.println("n>=7");
if (n>20)
System.out.println("n>20");
else
System.out.println("n<=20");
Ausgabe
n<7
n<=20
Hinweis – auf für den False-Zweig gilt natürlich: Wenn mehr als eine Anweisung notwendig ist,
dann muß ein Block genutzt werden – siehe Kapitel 7.1.2.
7.1.4 If-Anweisung ohne True-Zweig
Es gibt keine Syntax, um eine If-Anweisung nur mit False-Zweig ohne True-Zweig zu
implementieren. Ist dies gewünscht, so gibt es zwei Implementierungs-Möglichkeiten:
• True-Zweig mit leerer Anweisung
• Bool-Ausdruck in der If-Anweisung umformulieren
True-Zweig mit leerer Anweisung
In Java sind leere Anweisungen erlaubt – sie bestehen aus einem einzelnen Semikolon. Damit
läßt sich der True-Zweig einer If-Anweisung sehr schnell abhandeln.
int n = 10;
if (n<7);
// <= dieses Semikolen ist der leere True-Zweig
else
Ausgabe
n>=7
Achtung – so ein leerer True-Zweig ist nicht besonders gut lesbar. Und so ein einzelnes
Semikolon ist schnell überlesen bzw. verwirrend – von daher ist die Lösung nicht zu empfehlen.
Formulieren Sie besser den Bool-Ausdruck um.
Bool-Ausdruck in der If-Anweisung umformulieren
Formulieren Sie den boolschen Ausdruck so um, dass er statt „true“ „false“ liefert und
umgekehrt. Wenn sich der Ausdruck nicht umformulieren läßt, bzw. die Umformulierung
Seite 116 / 409
aufwändig und fehlerträchtig ist – dann nutzen Sie einfach den boolschen Not-Operator „!“ um
den boolschen Ausdruck zu negieren.
int n = 10;
if (n>=7)
// Ausdruck umformuliert
if (!(n<7))
// Ausdruck negiert mit !
Ausgabe
n>=7
n>=7
7.1.5 Mehrfach-Verzweigungen mit If-ElseIf
Nicht immer gibt es nur einen True-Fall bzw. einen True- und einen False-Fall. Häufig hat man
eine Art Auflistung von verschiedenen Fällen, d.h. eine Mehrfach-Verzweigung. In diesem
Fällen nimmt man verschachtelte If-Anweisungen, die auch als If-ElseIf-Anweisung bezeichnet
wird.
Im Prinzip ist eine If-ElseIf-Anweisung nichts neues – hier wird nur der False-Zweig durch eine
If-Anweisung dargestellt. Der Unterschied ist eine eigenständige Einrückungs-Konvention, bei
der das „if“ direkt auf das „else“ folgt.
Syntax:
true-anweisung
else if (boolean-ausdruck)
true-2-anweisung
else
false-anweisung
Beispiel:
int age = 27;
if (age<10)
System.out.println("Kind im Alter von " + age);
else if (age<18)
System.out.println("Jugendliche(r) im Alter von " + age);
else if (age<30)
System.out.println("Junge(r) Erwachsene(r) im Alter von " + age);
else if (age<70)
System.out.println("Erwachsene(r) im Alter von " + age);
else
System.out.println("Alte(r) Frau/Mann im Alter von " + age);
Ausgabe
Junge(r) Erwachsene(r) im Alter von 27
Hinweis – auch hier ist der Else-Zweig natürlich optional.
Seite 117 / 409
7.2 Mehrfach-Verzweigung – Switch
Für spezielle Mehrfach-Verzweigungen in Abhängigkeit von einer integralen Variable gibt es in
Java die Switch-Anweisung. Sie funktioniert für die Typen „char“, „byte“, „short“ und „int“, d.h.
Typen mit integralen Werten mit max. 4 Byte Größe, und zusätzlich seit dem JDK 1.5 mit
Enums (siehe Kapitel todo) und seit dem JDK 1.7 auch mit Strings.
Außerdem kann der integrale Ausdruck nur auf Gleichheit zu Compile-Zeit Konstanten des
entsprechenden Typs getestet werden. Wenn man mit diesen Einschränkungen leben kann, ist
eine Switch-Anweisung einer If-Else-If Mehrfach-Verzweigung vorziehen.
Syntax
switch (ausdruck) {
case constant1:
anweisung; ...
[break;]
case constant2:
anweisung; ...
[break;]
...
default:
anweisung; ...
[break;]
}
• ausdruck muss vom Typ „char“, „byte“, „short“, „int“, „Enum“ (seit JDK 1.5) oder „String“
(seit JDK 1.7) sein.
• constant muss eine Compile-Zeit-Konstante vom entsprechenden Typ sein.
public class Appl {
for (int i = 0; i < 5; i++) {
switch (i) {
case 0:
System.out.println("Null");
break;
case 1:
System.out.println("Eins");
break;
case 3:
System.out.println("Drei");
break;
default:
System.out.println("Unbekannt");
}
}
}
}
Ausgabe
Null
Eins
Unbekannt
Drei
Unbekannt
Seite 118 / 409
Erst die „break“ Anweisung beendet einen Case-Block. Ist kein „break“ vorhanden, so läuft der
Programmfluss in den nächsten Case-Block hinein – auch in den Default-Block. Auch im
Default-Block darf das „break“ stehen – hat hier aber keine Bedeutung – siehe Beispiel:
for (int i=0; i<7; i++) {
switch (i) {
case 1:
System.out.println("i ist
break;
case 2:
case 3:
case 4:
System.out.println("Fluss
break;
default:
break;
}
}
1");
2 oder 3");
kommt aus 2/3 oder i ist 4");
weder 1,2,3 oder 4");
// Nicht notwendig
Ausgabe
i ist weder 1,2,3 oder 4
i ist 1
i ist 2 oder 3
Fluss kommt aus 2/3 oder i ist 4
i ist 2 oder 3
Seit JDK 1.5 kann man die Switch-Anweisung auch für Enums (siehe Kapitel 12.6) verwenden.
Achtung, das Beispiel enthält mehrere Sprachmittel (u.a. die Enums), die erst in späteren
Kapiteln eingeführt werden:
public class Appl {
private enum Color {
RED, GREEN, BLUE
};
private static void switchIt(Color c) {
switch (c) {
case RED:
System.out.println("rot");
break;
case GREEN:
System.out.println("gruen");
break;
case BLUE:
System.out.println("blau");
break;
}
}
switchIt(Color.RED);
switchIt(Color.GREEN);
switchIt(Color.BLUE);
}
}
Ausgabe
rot
gruen
Seite 119 / 409
blau
Und seit JDK 1.7 funktioniert die Switch-Anweisungs auch mit Strings.
public class Appl {
private static void doStringSwitch(String s) {
switch (s) {
case "Text 1":
System.out.println("Text 1 gefunden");
break;
case "Text 2":
System.out.println("Text 2 gefunden");
break;
default:
System.out.println("Unbekannter Text");
break;
}
}
doStringSwitch("Text 1");
}
}
Ausgabe
Text 1 gefunden
Text 2 gefunden
Unbekannter Text
Hinweis – der Java Compiler wandelt die Switch-Anweisungen mit Strings in eine Art „HashTable“ mit Sprunganweisung um. Daher wird die Switch-Anweisungen bei vielen Case-Fällen
wahrscheinlich performanter sein als If-Else-If-Else-Anweisungen.
7.3 For-Schleife
Syntax
for (init; test; update)
anweisung
Beispiel
for (int i=0; i<8; i++) {
System.out.print(i);
}
Ausgabe
01234567
Hinweis – werden im Initialisierungs-Teil ein oder mehrere Variablen definiert, so sind diese
nur im Scope der Schleife bekannt.
for (int i=0; i<8; i++) {
}
// Definition von i gilt nur fuer die Schleife
// Compiler-Fehler – Variable i ist unbekannt
Seite 120 / 409
Hinweis – mit dem JDK 1.5 wurde ein weiterer For-Schleifentyp für Container und Arrays
eingeführt – dieser wird im nächsten Kapitel 7.4 beschrieben.
7.4 For-Schleife für Container und Arrays
In Java 5 (JDK 1.5) wurde ein neuer For-Schleifen-Typ für Container (siehe Kapitel 9.3) und
Arrays (siehe Kapitel 10.3) eingeführt.
Achtung – die folgenden beiden Programme können Sie hier noch nicht verstehen, da in ihnen
sowohl Arrays als auch typisierte Container vorkommen. Da es aber hier im Kapitel u.a. um
Schleifen geht, habe ich diesen Schleifen-Typ hier auch beschrieben – kommen Sie später
nochmal zurück zu diesem Kapitel.
Neuer Schleifentyp für Arrays:
int[] a = new int[]{ 1, 2, 3, 5, 7, 11 };
for (int n : a) {
System.out.print("" + n + ' ');
}
Ausgabe
1 2 3 5 7 11
Neuer Schleifentyp für Container:
ArrayList<String> al = new ArrayList<String>();
al.add("eins");
al.add("zwei");
al.add("drei");
for (String s : al) {
System.out.println("-> " + s);
}
Ausgabe
-> eins
-> zwei
-> drei
7.5 While-Schleife
Syntax
while (boolan-ausdruck)
anweisung
Die While-Schleife wird solange wiederholt, wie der ausdruck true ist.
Beispiel
int i = 0;
while (i<3) {
System.out.print(i + " ");
i++;
}
Ausgabe
0 1 2
Seite 121 / 409
7.6 Do-Schleife
Syntax
do
anweisung
while (boolean-ausdruck);
Die Do-Schleife wird solange wiederholt, wie der Ausdruck true ist.
Beispiel
int i = 0;
do {
i++;
} while (i<3);
Ausgabe
0 1 2
Im Gegensatz zur While-Schleife wird die Do-Schleife immer mindestens einmal durchlaufen.
7.7 Break- und Continue-Anweisung
7.7.1 Break
Das Schlüsselwort „break“ in einer beliebigen Schleife sorgt für einen sofortigen Abbruch der
Schleife.
for (int i=0; i<20; i++) {
if (i>=5) break;
}
System.out.print("Schleifenende");
Ausgabe
0 1 2 3 4 5 Schleifenende
Dies gilt nur für die innerste Schleife, falls Sie mehrere Schleifen ineinander verschachtelt
haben.
for (int i=0; i<2; i++) {
for (int j=0; j<20; j++) {
System.out.print(j + " ");
if (j>=5) break;
}
System.out.print("Ende-von-j-Schleife\n");
}
System.out.print("Schleifenende");
Ausgabe
0 1 2 3 4 5 Ende-von-j-Schleife
0 1 2 3 4 5 Ende-von-j-Schleife
Schleifenende
7.7.2 Continue
Das Schlüsselwort „continue“ in einer Schleife sorgt für einen sofortigen Sprung an den
Schleifen-Kopf – wobei auch bei der Do-Schleife die Test-Bedingung zum Schleifen-Kopf zählt.
Seite 122 / 409
Achtung – continue wirkt bei For-Schleifen anders als bei While- und Do-Schleifen, da sich bei
diesen Schleifen die Wirkung des Schleifenkopfes unterscheidet:
• Bei einer For-Schleife wird die Update-Ausdruck ausgeführt, und dann der Test-Ausdruck
ausgewertet – mit einem möglichem Abbruch der Schleife.
• Bei einer While- oder einer Do-Schleife wird nur der Test-Ausdruck ausgewertet – mit einem
möglichem Abbruch der Schleife.
System.out.println("For");
for (int i = 0; i < 7; i++) {
if (i == 3) {
System.out.print(" ** ");
i += 2;
continue;
}
System.out.print(i + " - ");
}
System.out.println("\nWhile");
int i = 0;
while (i < 7) {
if (i == 3) {
i += 2;
continue;
}
i++;
}
System.out.println("\nDo");
i = 0;
do {
if (i == 3) {
i += 2;
continue;
}
i++;
} while (i < 7);
Ausgabe
For
0 0 - 1 1 - 2 2 - 3
While
0 0 - 1 1 - 2 2 - 3
Do
0 0 - 1 1 - 2 2 - 3
** 6 6 ** 5 5 - 6 6 ** 5 5 - 6 6 -
Hinweis – auch „continue“ wirkt nur für die innerste Schleife. Wollen Sie zum Schleifenkopf
einer äußeren Schleife springen, so müssen Sie eine gelabelte Sprung-Anweisung nutzen –
siehe nächstes Kapitel.
7.8 Gelabelte Sprung-Anweisungen
Gelabelte Sprung-Anweisungen ermöglichen ein break oder continue über mehrere SchleifenEbenen hinweg.
Seite 123 / 409
Syntax
break label;
continue label;
Dazu muß eine Schleife mit einem Label versehen werden – dies geschieht mit dem LabelNamen und einem folgenden Doppelpunkt. Wird jetzt innerhalb einer solchen Schleife eine
gelabelte Sprunganweisung ausgeführt, so bezieht sie sich auf die Schleife mit dem passenden
Label, auch wenn diese nicht die innerste ist.
Beispiel
outerLoop: for (int i=0; i<5; i++) {
for (int j=0; j<3; j++) {
System.out.print(i + " " + j + " / ");
if (i+j > 3) break outerLoop;
}
}
Ausgabe
0 0 / 0 1 / 0 2 / 1 0 / 1 1 / 1 2 / 2 0 / 2 1 / 2 2 /
Hinweis – eine gelabelte Sprunganweisung darf natürlich nur innerhalb einer Schleife mit
einem passenden Label stehen. Man kann mit ihnen also nicht in eine ganz andere Schleife
springen.
7.9 Aufgaben
7.9.1 Aufgabe „Schleifen-Varianten“
Schreiben Sie ein Programm, dass dreimal hintereinander die Zahlen von 1 bis 5 ausgibt. Für
die erste „1..5“ Ausgabe soll eine For-Schleife benutzt werden, für die zweite eine WhileSchleife, und für die dritte eine Do-Schleife. Jede „1..5“ Ausgabe soll in einer eigenen Zeile
stehen, und die Zahlen sollen mit einem Leerzeichen untereinander getrennt sein.
Ausgabe
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
7.9.2 Aufgabe „Teilbar?“
Schreiben Sie ein Programm, dass hintereinander die Zahlen von 1 bis 10 und jeweils eine
Meldung, ob die Zahl durch 2 bzw. durch 3 teilbar ist, ausgibt. Benutzen Sie, um die Zahlen zu
durchlaufen, eine For-Schleife.
Mögliche Ausgabe:
1 nicht-durch-2-teilbar nicht-durch-3-teilbar
2 durch-2-teilbar nicht-durch-3-teilbar
3 nicht-durch-2-teilbar durch-3-teilbar
5 nicht-durch-2-teilbar
...
Seite 124 / 409
nicht-durch-3-teilbar
7.9.3 Aufgabe „Lesbare Zahlen“
Schreiben Sie ein Programm, dass hintereinander die Zahlen von 1 bis 5 als lesbaren Text
ausgibt. Benutzen Sie, um die Zahlen zu durchlaufen, eine For-Schleife. Jede Zahl-Ausgabe
soll in einer eigenen Zeile stehen.
Mögliche Ausgabe:
eins
zwei
drei
vier
fuenf
Vergeichen Sie zu dieser Aufgabe auch die Aufgaben 9.8.4 (Lösung in Kapitel 9.12) und 10.8.1
(Lösung in Kapitel 10.9).
7.9.4 Aufgabe „Zahlen-Liste“
Schreiben Sie ein Programm, dass hintereinander die Zahlen von 1 bis 5 ausgibt. Die Zahlen
sollen dabei durch einen Bindestrich ‚-‚ getrennt werden, und die gesamte Zahlenreihe soll von
runden Klammern umgeben sein. Benutzen Sie, um die Zahlen zu durchlaufen, eine ForSchleife.
Ausgabe:
(1-2-3-4-5)
7.9.5 Aufgabe „Mittelwert und Varianz“
Schreiben Sie ein Programm, das den Mittelwert und die Varianz von Gleitkomma-Zahlen
berechnet. Der Benutzer gibt die Werte auf der Kommandozeile an. Der Mittelwert ist die
Summe der Werte geteilt durch die Anzahl. Die Varianz ist die Summe der Quadrate der Werte
geteilt durch die um eins reduzierte Anzahl. Fangen sie fehlerhafte Eingaben wieder sinnvoll
ab. Denken Sie sich ein sinnvolles Abbruchkriterium aus, d.h. was muss der Benutzer
eingeben, wenn er fertig mit der Eingabe ist.
Um auch dieses Programm erstmal etwas einfacher zu gestalten, könnten Sie – ähnlich zu
Aufgabe 4.8.5 – eine Version schreiben, die die Werte als Kommandozeilen-Argumente
übergeben bekommt statt Sie einzulesen.
Seite 125 / 409
7.9.6 Aufgabe „Multiplikations-Matrix“
Schreiben Sie ein Programm, das zwei positive Integer-Zahlen einliest, und für diese (von bis
inkl.) das Ein-mal-eins als Matrix ausgibt.
Hinweise:
• Fangen Sie fehlerhafte Eingaben ab. Diesen Hinweis gibt es hier jetzt zum letzten Mal,
danach wird er als selbstverständlich vorausgesetzt.
• Wie in Aufgabe 4.8.5 und Aufgabe 7.9.5 ist es für den Einstieg möglich, zuerst eine Version
mit Kommandozeilen-Argumenten zu schreiben.
Beispiel:
Zahl1: 2
Zahl2: 4
| 2 3 4
---+-----------2 | 4 6 8
3 | 6 9 12
4 | 8 12 16
Hinweis – für eine schönere Formatierung fehlt uns leider noch das Wissen.
7.10 Lsg. zu Aufgabe „Schleifen-Varianten“ – Kap. 7.9.1
Diese Aufgabe ist relativ einfach, da sie nur einfach die drei Schleifen-Typen aus den Kapiteln
7.3, 7.5 und 7.6 implementieren müssen. Letzlich ist das ja auch der Sinn der Aufgabe, einmal
mit den drei Schleifen-Typen von Java vertraut zu werden.
Für einen Java Anfänger hat die Aufgabe vielleicht trotzdem zwei kleine Knackpunkte:
• Die Ausgabe der Zahl müssen Sie mit „System.out.print“ machen (z.B. Zeile *), damit kein
Zeilenumbruch erzeugt wird. Hinter jedem Schleifen-Typ muss dann ein Zeilenumbruch
erzeugt werden – z.B. mit „System.out.println()“ (z.B. Zeile **).
• Für alle drei Schleifen wird eine Zählvariable benötigt. Hier müssen Sie mit der Sichtbarkeit
der Variablen (siehe u.a. Kapitel 5.3) aufpassen. Für die While- und die Do-Schleife
benötigen Sie eine Zähl-Variable, die außerhalb der Schleife definiert ist (Zeile ***). Damit ist
klar, dass Sie sie für die jeweilig zweite Schleife nicht mehr definieren müssen, sondern nur
den Start-Wert neu setzen müssen (Zeile ****).
Die For-Schleife ist hier eine Besonderheit. Da der Schleifenkopf zur Sichtbarkeit der
Schleife gehört, können (und sollten Sie im Normalfall auch) Sie die Zähl-Variable dort
definieren. Dann steht sie aber für die anderen beiden Schleifen-Typen nicht mehr zur
Wiederverwendung zur Verfügung. Anders als das Beispiel könnten Sie hier also auch eine
Zähl-Variable wie in Zeile (***) definieren, und sie auch für die For-Schleife
Seite 126 / 409
wiederverwenden.
Etwas anderes passiert, wenn Sie die For-Schleife nicht als ersten, sondern als zweiten oder
dritten Schleifen-Typ verwenden. In diesem Fall können Sie in der For-Schleife keine ZählVariable mehr definieren – zumindest nicht mit dem gleichen Namen – da Java keine
mehrfachen Variablen-Namen innerhalb einer Funktion zuläßt (siehe Kapitel 8.3).
public class Appl {
for (int i=1; i<6; i++) {
}
// (*****)
// (*)
// (**)
int i = 1;
while (i<6) {
System.out.print(i++ + " ");
}
// (***)
i = 1;
do {
System.out.print(i++ + " ");
} while (i<6);
// (****)
}
}
Ausgabe
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
7.11 Lsg. zu Aufgabe „Teilbar?“ – Kap. 7.9.2
Die Aufgabe besteht aus zwei Teilen.
• Zuerst müssen natürlich die Zahlen von 1 bis 10 durchlaufen werden.
• Danach muss für jede Zahl geprüft werden, ob sie durch 2 bzw. 3 teilbar ist, und dann eine
entsprechende Meldung ausgegeben werden.
Teil 1 sollten sie mittlerweile problemlos implementieren können, da sie hierfür nur eine
einfache Zählschleife, also eine For-Schleife benötigen.
for (int i=1; i<=10; i++) {
...
}
Teil 2 setzt die richtige Idee voraus, wie man die Teilbarkeit testen kann. Die Lösung ist hier der
Modulo-Operator „%“ – siehe Kapitel 6. Er gibt den Rest der Integer-Division zurück, und die ist
„0“, wenn der erste Operand durch den zweiten Operanden teilbar ist. Mit einer entsprechenden
Meldung sieht der Test auf Teilbarkeit durch 2 also z.B. so aus:
if (i%2!=0) {
System.out.print("nicht-");
}
System.out.print("durch-2-teilbar");
Seite 127 / 409
Damit ist alles vorhanden – jetzt müssen die Teile nur noch zusammengefügt werden:
• Klasse mit Main-Funktion
• For-Schleife mit Ausgabe
• Test auf Teilbarkeit auf „2“ und „3“
Hier das gesamte Programm:
public class Appl {
for (int i=1; i<=10; i++) {
if (i%2!=0) {
}
System.out.print("durch-2-teilbar
");
if (i%3!=0) {
}
System.out.println("durch-3-teilbar");
}
}
}
Ausgabe:
6 durch-2-teilbar durch-3-teilbar
7.12 Lsg. zu Aufgabe „Lesbare Zahlen“ – Kap. 7.9.3
Klar sollte sein: auch hier wird wieder eine Klasse mit Main-Funktion und einer For-Schleife
benötigt. Bleibt nur die Frage offen: wie unterscheidet man auf die verschiedenen Zahlenwerte?
Die Lösung ist ganz einfach: das Problem ist typisch für eine Switch-Anweisung (siehe Kapitel
7.2), die eine Unterscheidung für integrale Werte darstellt. Damit kann das Programm direkt
hingeschrieben werden:
public class Appl {
for (int i=1; i<=5; i++) {
switch (i) {
case 1:
System.out.println("eins");
break;
case 2:
System.out.println("zwei");
break;
case 3:
System.out.println("drei");
break;
Seite 128 / 409
case 4:
System.out.println("vier");
break;
case 5:
System.out.println("fuenf");
break;
}
}
}
}
Hinweis – noch effizienter läßt sich das Programm mit Containern implementieren, die wir in
Kapitel 9.3 kennen lernen werden. Dort wird sich das Problem auch noch mal als neue Aufgabe
9.8.4 wiederholen – und in Kapitel 9.12 findet sich dann die Lösungen mit Containern.
7.13 Lsg. zu Aufgabe „Zahlen-Liste“ – Kap. 7.9.4
Im ersten Augenblick sieht die Aufgabe ganz einfach aus: eine Klasse mit Main-Funktion und
For-Schleife mit Zahlen-Ausgabe und die Klammern-Ausgabe vor und nach der For-Schleife –
quasi analog zur Aufgabe 7.9.1 mit der Lösung 7.10.
// Achtung – fehlerhafte Loesung
System.out.print('(');
for (int i=1; i<=5; i++) {
System.out.print(i + '-');
}
System.out.println(')');
}
Ausgabe:
(1-2-3-4-5-)
Leider ist diese Lösung falsch, denn hinter der letzten Zahl (hier „5“) folgt noch ein Bindestrich.
Das Problem ist ein ganz typisches Alltags-Problem der Programmierung: beim ersten oder
letzten Durchlauf einer Schleife müssen Dinge anders gehandelt werden. Schauen wir uns die
drei typischen Lösungen an:
• Bedingte Ausführung in der Schleife
• Schleife um einen Durchlauf kürzen
• Schleife mit Abbruch in der Mitte
7.13.1 Lösung 1: Bedingte Ausführung in der Schleife
Der erste Ansatz ist einfach, in der Schleife mit einer If-Anweisung den letzten Durchlauf
gesondert zu behandeln, z.B. so:
for (int i=1; i<=5; i++) {
if (i!=5) {
System.out.print('-');
}
}
Seite 129 / 409
Frage: was gefällt ihnen an diesem Quelltext nicht? Ich hoffe, dass ihnen sofort unangenehm
aufgestoßen ist, dass die Konstante „5“ zweimal im Quelltext auftaucht. Bei Änderungen
müssen also zwei Stellen im Quelltext geändert werden. Nun sind die beiden Änderungen nicht
viel Arbeit – das Problem ist in der Praxis, dass eine Stelle vergessen wird. Ein ganz wichtiger
Grundsatz beim Programmieren ist, dass eine Änderungswunsch an der Software (hier: „Lass
die Liste bis 8 gehen“) nur zu Änderungen an einer Stelle im Code führen sollte. Statt des
Literals „5“ sollte also lieber eine Konstante benutzt werden. Da wir Konstanten noch nicht
kennen, wäre die hier angemessene Lösung eine Variable. Um aus einer Variablen eine
Konstante zu machen, muss man aber nur den Modifier „final“ verwenden (siehe Kapitel 8.3) –
das können wir hier ruhig schon direkt benutzen.
final int limit = 5;
for (int i=1; i<=limit; i++) {
if (i!=limit) {
}
Ansonsten kann man die Lösung gut nutzen, und ist mit Klasse, Main-Funktion und der
Ausgabe der Klammern schnell fertig:
public class Appl {
for (int i=1; i<=limit; i++) {
if (i!=limit) {
}
}
}
}
Nachteil dieser Lösung ist, dass die Schleife durch die If-Anweisung etwas komplizierter und
langsamer ist.
7.13.2 Lösung 2: Schleife um einen Durchlauf kürzen
Da hier die Anzahl an Durchläufen festliegt, kann man die Schleife einfach um einen Durchlauf
kürzen, und die spezielle Behandlung der letzten Zahl hinter der Schleife ganz für sich machen:
public class Appl {
for (int i=1; i<=limit-1; i++) {
System.out.print(i + '-');
}
System.out.print(limit);
// <- hier steht jetzt "limit-1"
}
Seite 130 / 409
}
Der Vorteil der Lösung ist, dass die Schleife ohne If-Anweisung einfacher und performanter ist.
Leider gibt es Situationen, in denen diese Lösung nicht anwendbar ist, z.B. wenn die SchleifenAbbruch-Bedingung erst innerhalb der Schleife berechnet werden kann.
Außerdem ist hier nachteilig, dass wir genau genommen eine Code-Verdopplung haben. Es
fällt in unserem kleinen Beispiel gar nicht so richtig auf, aber die Ausgabe der Zahl findet sich
jetzt in und nach der Schleife. Im Prinzip sieht unser Programm jetzt ja so aus:
Schleife {
tue-a
tue-b
}
tue-a
In einem echten Programm könnte „tue-a“ viel komplizierter Code sein, der dann doppelt
vorhanden wäre. Damit haben wir wieder ein potentielles Problem im Änderungsfall (Fehler,
Wartung, Refactoring, Anforderungen). Also wenn man diese Lösung wäht, dann sollte man
„tue-a“ auf jeden Fall in eine extra Funktion auslagern.
7.13.3 Lösung 3: Schleife mit Abbruch in der Mitte
Eine andere Lösung wäre die Schleife mittendrin zu verlassen:
Schleife {
tue-a
Abbruch-wenn-noetig
tue-b
}
Mit diesem Muster läßt sich die Code-Verdopplung beseitigen, und diese Lösung funktioniert
auch dann wenn die Abbruch-Bedingung erst in der Schleife berechnet werden kann. Leider
enthält auch sie noch die If-Anweisung, und ist daher nicht ganz so einfach und schnell wie die
zweite Lösung.
public class Appl {
for (int i=1; ; i++) {
if (i==limit) {
break;
}
}
}
}
Seite 131 / 409
7.14 Lsg. zu Aufgabe „Mittelwert und Varianz“ – Kap. 7.9.5
Erklärung folgt (hoffentlich) später – todo...
public class Appl {
System.out.println("Keine Werte => keine Berechnungen");
return;
}
try {
double d = Double.parseDouble(args[0]);
System.out.println("Nur ein Wert");
System.out.println("=> Mittelwert: " + d);
System.out.println("=> Varianz: ---");
System.out.println("Fehlerhafter Parameter");
}
return;
}
int count = args.length;
double sum = 0.0;
double squares = 0.0;
for (int i=0; i<count; i++) {
try {
double d = Double.parseDouble(args[i]);
sum += d;
squares += d*d;
System.out.println(i+1 + "-ter Parameter \"" + args[i] +
"\" fehlerhaft");
return;
}
}
System.out.println(count + " Werte");
System.out.println("=> Mittelwert: " + (sum/count));
System.out.println("=> Varianz: " + (squares/(count-1)));
}
}
public class Appl {
int count = 0;
double sum = 0.0;
double squares = 0.0;
while (true) {
try {
System.out.print("Wert: ");
if (in.length()==0) break;
double d = Double.parseDouble(in);
count++;
sum += d;
squares += d*d;
System.out.println("Fehlerhafte Eingabe, bitte wiederholen");
Seite 132 / 409
}
}
if (count==0) {
System.out.println("Keine Werte => keine Berechnungen");
return;
}
if (count==1) {
System.out.println("Nur ein Wert");
System.out.println("=> Mittelwert: " + sum);
System.out.println("=> Varianz: ---");
return;
}
System.out.println(count + " Werte");
System.out.println("=> Mittelwert: " + (sum/count));
System.out.println("=> Varianz: " + (squares/(count-1)));
}
}
7.15 Lsg. zu Aufgabe „Multiplikations-Matrix“ – Kap. 7.9.6
public class Appl {
System.out.println("Das Programm erwartet zwei Int-Argumente");
return;
}
int v1;
try {
v1 = Integer.parseInt(args[0]);
System.out.println("Argument 1 ist kein Int-Wert");
return;
}
int v2;
try {
v2 = Integer.parseInt(args[1]);
System.out.println("Argument 2 ist kein Int-Wert");
return;
}
if (v1>v2) {
int temp = v1;
v1 = v2;
v2 = temp;
}
// Zahlenbereich auf akzeptable Groesse checken
if (v2-v1>=10) {
System.out.println("Zu grosse Matrix");
return;
}
// Und Ausgabe...
System.out.print("
|");
for (int i=v1; i<=v2; i++) {
System.out.print(" " + i);
}
Seite 133 / 409
System.out.print("---+");
for (int i=v1; i<=v2; i++) {
System.out.print("---");;
}
System.out.println('-');
for (int i=v1; i<=v2; i++) {
System.out.print(' ' + i + " |");
for (int j=v1; j<=v2; j++) {
System.out.print(" " + i*j);
}
}
}
}
public class Appl {
int v1;
try {
System.out.print("Untere Grenze: ");
v1 = Integer.parseInt(in);
System.out.println("Fehlerhafte Eingabe");
return;
}
int v2;
try {
System.out.print("Obere Grenze: ");
v2 = Integer.parseInt(in);
System.out.println("Fehlerhafte Eingabe");
return;
}
if (v1>v2) {
int temp = v1;
v1 = v2;
v2 = temp;
}
// Zahlenbereich auf akzeptable Groesse checken
if (v2-v1>=10) {
System.out.println("Zu grosse Matrix");
return;
}
// Und Ausgabe...
System.out.print("
|");
for (int i=v1; i<=v2; i++) {
System.out.print(" " + i);
}
System.out.print("---+");
for (int i=v1; i<=v2; i++) {
System.out.print("---");;
}
System.out.println('-');
Seite 134 / 409
for (int i=v1; i<=v2; i++) {
System.out.print(' ' + i + " |");
for (int j=v1; j<=v2; j++) {
System.out.print(" " + i*j);
}
}
}
}
8 Funktionen
In Java gibt es keine freien (globalen) Funktionen – alle Funktionen sind immer einer Klasse
zugeordnet. Dies gilt auch für die Main-Funktionen.
Syntax:
[Modifizierer] <Rückgabetyp> <Fkt-Name> ( [Parameterliste] ) {
<Implementierung>
}
• Modifizierer – z.B.: public, private, static, final, ...
• Eine Parameterliste ist eine durch Komma getrennte Auflistung von Parametern (sie kann
auch leer sein. Ein Parameter besteht aus Typ und Name.
Bsp:
public static void f() { ... }
protected final int doit(StringBuffer sb) { ... }
private static String calcName(String s, int i) { ... }
Aufruf:
<Fkt-Name>( <Argumentliste> );
Bsp:
f();
calcName("", 1);
Rückgaben können ignoriert werden – siehe Bsp „calcName“.
Bemerkung – fast jeder ausführbare Code steht immer in einer Funktion. Die einzigen
Ausnahmen sind Initialisierungs-Blöcke, die aber im Prinzip auch nur sehr spezielle Funktionen
sind.
Bemerkung – Funktions-Namen werden in Java per Konvention klein begonnen, und dann
kapitalisiert fortgesetzt – vergleiche z.B. den Namen „calcName“. Siehe auch Kapitel 3.2.5.
Seite 135 / 409
8.1 Funktions-Arten
Achtung – in Java gibt es zwei Arten von Funktionen:
• Element-Funktionen
• Klassen-Funktionen
Klassen-Funktionen sind Funktionen, die mit dem Modifizierer „static“ definiert sind – wie z.B.
die Funktion „main“ in unseren Beispielen. Nur Klassen-Funktionen können direkt aufgerufen
werden. Element-Funktion benötigen einen Objekt-Bezug, und werden dann mit dem Objekt
und dem Punkt-Operator „.“ aufgerufen.
Für Objekte z.B. vom Typ „String“ benutzen wir die Element-Funktionen einfach. Im Detail
kennen lernen werden wir sie erst mit der Einführung von Klassen und Objekten in Kapitel todo.
Solange sollten Sie in ihren Beispielen nur Klassen-Funktionen definieren, d.h. jede
selbstgeschriebene Funktion sollte den Modifizierer „static“ bekommen.
public class Appl {
public static void sf() { ... }
public void f() { ... }
sf();
f();
String s = "Hallo";
s.length();
}
// Aufruf geht, da sf static ist
// Compiler-Fehler, da Element-Fkt
// Okay – Aufruf von Element-Fkt
//
mit Objekt-Bezug
}
8.2 Syntaktischer Aufbau
Eine Java Funktion besteht aus einer Folge von Anweisungen. Eine Anweisung ist:
• eine Instruktion (wird durch Semikolon beendet – z.B. Zuweisung, Definition.,
Funktionsaufruf,...),
• eine Kontrollstruktur (if, while, switch,...), oder
• ein Block.
Ein Block ist eine Folge von Anweisungen, die durch die geschweiften Klammern
eingeschlossen sind – ein Block ist immer auch ein Scope, d.h. ein Sichtbarkeitsbereich von
Variablen (siehe Kapitel 8.3).
8.3 Variablen in Funktionen
Variablen können an (fast) jeder beliebigen Stelle in Funktionen definiert werden. Dabei werden
Seite 136 / 409
sogenannte lokale Variablen erzeugt, die lokal zur Funktion sind31.
void fct() {
int var = 23;
System.out.println(var);
}
Ein einmal vergebener Name darf im gleichen Block nicht ein zweites Mal benutzt werden –
ansonsten wäre der Name ja nicht eindeutig.
void fct() {
int var = 23;
int var = 42;
}
// Compiler-Fehler – var schon definiert
Wird eine Variable innerhalb eines Blocks in einer Funktion definiert, so ist sie auch nur
innerhalb dieses Blocks sichtbar. Ein Block bildet also einen Sichtbarkeitsbereich.
void fct() {
while (true) {
int var = 87;
break;
}
}
// Okay – var ist sichtbar
// Compiler-Fehler – var hier nicht sichtbar
Eine Besonderheit sind hierbei Variablen-Definitionen im Initialisierungs-Teil einer For-Schleife.
Obwohl sie nicht in einem speziellen Block definiert sind, sind diese Variablen nur in der
Schleife bekannt – siehe Kapitel 7.3.
Ist eine lokale Variabel sichtbar (d.h. sie befinden sich innerhalb des definierenden Scopes in
der Funktion), so darf auch in verschachtelten Blöcken keine weitere Variable des gleichen
Names definiert werden.32
int n = 4;
{
int n = 3;
}
// Compiler-Fehler – Variable n ist schon definiert.
8.3.1 Modifier „final“ für lokale Variablen
Der einzig erlaubte Modifizierer für Variablen in Funktionen ist der Modifizierer „final“. Wird er
angegeben, so kann die Variable nicht verändert werden.
final int n = 3;
n = 4;
// Compiler-Fehler – Variable darf nicht geaendert werden
final StringBuffer sb = new StringBuffer("StringBuffer");
Genau genommen sind die Variablen nicht nur lokal zur Funktion, sondern sogar lokal zum
Funktions-Aufruf. Lokale Variablen werden für jeden Funktionsaufruf beim Durchlaufen der
Definition neu erzeugt, d.h. lokale Variablen sind wiedereinsprungsfest (reentrant). Wichtig ist
dies für Rekursion (Kapitel 8.7) und Multithreading (nicht Thema des Tutorials).
32 Dies ist in Sprachen wie z.B. C oder C++ anders.
31
Seite 137 / 409
sb = new StringBuffer("Error");
// Compiler-Fehler – Variable ist final
sb.append(" das geht aber");
// Okay, final schuetzt nur die Variable
//
nicht das referenzierte Objekt
Achtung – bei Referenz-Variablen bezieht sich „final“ nur auf die Referenz, nicht auf das
referenzierte Objekt – siehe auch das vorherige Beispiel.
8.4 Funktions-Parameter
Funktions-Parameter sind eigentlich ganz normale lokale Variablen, die beim Funktions-Aufruf
mit den Argumenten des Aufrufers initialisiert werden. Damit unterliegen sie natürlich auch der
Wert- bzw. der Referenz-Semantik (siehe Kapitel 5.4), und das ist für Funktions-Parameter
interessant.
Alle elementaren Datentypen werden per Wert-Semantik, d.h. mit einer echten Kopie,
übergeben. Änderungen innerhalb der Funktion haben nur Einfluss auf die Kopie in der
Funktion, und betreffen das Original beim Aufrufer nicht.
void f1(int n1) {
System.out.println("=>
System.out.println("
n1 += 12;
System.out.println("<=
}
f1");
" + n1);
" + n1);
f1");
int n = 23;
System.out.println(n);
f1(n);
System.out.println(n);
Ausgabe
23
=> f1
23
35
<= f1
23
Anders ist dies dagegen bei Referenz-Variablen, d.h. bei allen Variablen, deren Typen keine
elementaren Datentypen sind. In diesem Fall sind auch Funktions-Parameter ReferenzVariablen, und sie enthalten nur eine Referenz auf das eigentliche Objekt. Eine Funktion kann
also das referenzierte Objekt des Aufrufers verändern!
void f1(StringBuffer sb1)
System.out.println("=>
sb1.append(" Welt");
System.out.println("<=
}
{
f1");
" + sb1);
" + sb1);
f1");
StringBuffer sb = new StringBuffer("Hallo");
System.out.println(sb);
f1(sb);
System.out.println(sb);
Ausgabe
Seite 138 / 409
Hallo
=> f1
Hallo
Hallo Welt
<= f1
Hallo Welt
Achtung – Sie können dieses Verhalten nicht beeinflussen33. Die Übergabe-Semantik des
Funktions-Parameters liegt automatisch mit dem Typ des Parameters fest.
8.5 Funktions-Rückgaben
Hat eine Funktion den Rückgabe-Typ „void“ – siehe auch Kapitel 5.2.1 – so gibt sie nichts
zurück34.
void f() {
}
Soll sie dagegen etwas zurückgeben, so muss der entsprechende Rückgabe-Typ in der
Funktions-Definition angeben werden. Hat eine Funktion einen von „void“ verschiedenen
Rückgabe-Typ, so muss sie mit einer Return-Anweisung beendet werden, die den RückgabeWert definiert. Der Rückgabe-Wert in der Return-Anweisung muss natürlich zum RückgabeTyp der Funktion passen.
int f1() {
return 12;
}
String f2() {
return "Java";
}
StringBuffer f3() {
StringBuffer sb = new StringBuffer("Text");
return sb;
}
List<String> f4() {
return null;
}
Eine Funktion kann beliebig viele Ausgänge haben. Jede Return-Anweisung beendet die
Funktion instantan, und gibt den ausgewerteten Ausdruck der Return-Anweisung zurück.
int sgn(int n) {
if (n<0) {
return –1;
}
return n==0 ? 0 : 1;
}
System.out.println("-6
System.out.println("-1
System.out.println(" 0
33
34
=>
=>
=>
=>
=>
"
"
"
"
"
+
+
+
+
+
sgn(-6));
sgn(-1));
sgn( 0));
sgn( 1));
sgn( 3));
Im Gegensatz zu z.B. C++.
In manchen Sprachen werden solche Funktionen auch Prozeduren genannt.
Seite 139 / 409
Ausgabe
-6 => -1
-1 => -1
0 => 0
1 => 1
3 => 1
Eine Void-Funktion, d.h. eine Funktion ohne Rückgabe, kann jederzeit mit einer leeren ReturnAnweisung beendet werden.
void f(int i) {
if (i<12) {
return;
}
}
// Leere Return-Anweisung
Funktionen können jeden beliebigen Typ zurückgeben, sowohl elementare als auch
benutzerdefinierte Typen. Hierbei unterliegen natürlich auch die Funktions-Rückgaben der
entsprechenden Wert- bzw. Referenz-Semantik.
Funktions-Rückgaben können direkt benutzt werden, d.h. werden Objekte wie z.B. Strings
zurückgegeben, so können für sie direkt Element-Funktionen aufgerufen werden. Man nennt
dies auch Funktions-Verkettung.
String fct() {
return "Java";
}
int len1 = fct().length();
System.out.println(len1);
// Aufruf der Funktion 'length()' fuer den
// zurueckgegebenen String
String s = fct();
int len2 = s.length();
System.out.println(len2);
// So haette man es auch machen koennen
// Mit lokaler Zwischen-Variable 's'
Ausgabe
4
4
8.6 Überladen
Funktionen können überladen werden, d.h. der Funktions-Name darf mehrfach benutzt werden,
solange sich die Funktionen durch ihre Parameter-Typen unterscheiden, d.h. der Compiler den
Aufruf eindeutig zuordnen kann. Möglich ist dabei auch die Variation der Anzahl an Parametern
– auch dort ist die Funktion exakt erkennbar. Der Rückgabetyp trägt nicht zur Unterscheidung
bei.
public class A {
public static void f() {
System.out.println("---");
}
public static void f(int arg) {
System.out.println("int: " + arg);
}
public static void f(String arg) {
Seite 140 / 409
System.out.println("String: " + arg);
}
public static void f(int arg1, String arg2) {
System.out.println("int, String: " + arg1 + ", " + arg2);
}
f();
f(8);
f("Willy");
f("42");
// Ist natuerlich auch ein String, kein 'int'
f(3, "Java");
}
}
Ausgabe
--int: 8
String: Willy
String: 42
int, String: 3, Java
Hinweis – das Feature „Überladen“ funktioniert sowohl mit Klassen-Funktionen (Kapitel
12.4.4), mit Element-Funktionen (Kapitel 11.4.4), als auch mit Konstruktoren (Kapitel 11.4.7).
8.7 Rekursion
Wenn eine Funktion im gleichen Thread mehrfach ineinander (d.h. nicht nacheinander,
sondern gleichzeitig parallel) aufgerufen wird, nennt man das „Rekursion“ bzw. „rekursive
Programmierung“.
Eine Funktion muss sich dabei nicht zwangsläufig selber aufrufen, sondern dies kann auch
über mehrere Zwischenstationen passieren, z.B. „f() => g() => h() => f()“. Solche Fälle sind
häufig gar nicht mehr sofort zu erkennen, von daher passiert dies in der Praxis häufiger, als
man vielleicht im ersten Augenblick denkt.
Es gibt aber auch viele Probleme, die sich rekursiv viel viel leichter programmieren lassen als
ohne Rekursion. Hier ein Beispiel, das man in der Praxis sicher nicht rekursiv lösen würde – die
Summe aller Zahlen von 1 bis n.
public static long sum(long arg) {
if (arg<=1) {
// Operator <= statt == um die Funktion bei
fehlerhaften
return 1;
// Argumenten (arg<1) sauber zu beenden.
}
long erg = arg + sum(arg-1);
return erg;
}
Hierbei wird quasi direkt die mathematische Definition umgesetzt:
sum(1) := 1
sum(n) := n + sum(n-1)
Natürlich läßt sich die Summe der Zahlen von 1 bis n direkt über die Gaußsche-Summen-
Seite 141 / 409
Formel „n*(n+1)/2“ berechnen – was hier auch viel sinnvoller wäre – aber es geht eben auch
rekursiv.
Hinweis – es läßt sich übrigens beweisen, dass jedes Problem was iterativ gelöst werden kann
(d.h. mit einer Schleife) sich auch rekursiv lösen läßt, und umgekehrt.
Praxis – in den aller-meisten Fällen sind die iterativen Lösungen schneller und benötigen
weniger Speicher – sie sind daher vorzuziehen. Ein Schleifen-Durchlauf ist schnell und effizient,
während ein Funktions-Aufruf doch relativ teuer ist (bezogen auf die Performance).
In so manchen Fällen ist die rekursive Lösung aber ein 5-Zeiler, während die iterative Lösung
Tage harter Arbeit sein kann und hinterher aus vielen Quelltext-Zeilen besteht – Beispiele für
Lösungen, die rekursive erstaunlich einfach sind, finden sich z.B. in Kapitel 9.7.1 („Rekursive
Datei-Suche“) und in der Musterlösung 12.9 zur Aufgabe 12.8.1 („Türme von Hanoi“).
In einigen der folgenden Aufgaben werden sowohl iterative als auch rekursive Lösung verlangt.
Die Lösungen bieten also Diskussions-Material für das Thema Performance und
Implementierbarkeit.
8.8 Aufgaben
8.8.1 Aufgabe „Fakultäts Funktion“
Schreiben Sie zwei Versionen der Fakultäts-Funktion. Die Fakultät ist das Produkt der
natürlichen Zahlen von 1 bis n. Mathematisch sieht die Definition folgendermaßen aus:
• fak(0) :== 1
• fak(n) :== n * fak(n-1)
Version 1 soll das Ergebnis iterativ berechnen – d.h. mit einer Schleife.
Version 2 soll das Ergebnis rekursiv berechnen – d.h. durch Aufruf von sich selber.
Welche Version würden Sie in der Praxis warum vorziehen?
Schreiben Sie zusätzlich ein kleines Haupt-Programm, dass beide Funktionen für einige IntWerte benutzt. Achtung – bedenken Sie, dass die Fakultät sehr schnell wächst, und schon
„14!“ nicht mehr in einen vorzeichenbehafteten 32-Bit Integer-Wert paßt, und „21!“ auch eine
Long-Wert sprengt.
8.8.2 Aufgabe „Primzahl?“
Schreiben Sie eine Funktion, die eine positive Integer-Zahl erwartet und zurückgibt ob die Zahl
eine Primzahl ist. Schreiben Sie ein Programm, dass diese Funktion nutzt. Das Programm soll
sowohl mit einem Kommandozeilen-Argument umgehen können, als auch interaktiv mit dem
Benutzer die Zahl einlesen können. Hierbei gilt folgende Strategie:
Seite 142 / 409
• Sind Kommandozeilen Argumente vorhanden, so werden Sie alle für den Primzahl-Check
genommen.
• Ist kein Kommandozeilen Argument vorhanden, so wird eine Zahl interaktiv vom Benutzer
erfragt.
8.8.3 Aufgabe „Schleife rekursiv“
Nachdem Sie nun Funktionen und Rekursion kennen gelernt haben, schreiben Sie die
einfachen Zahlen-Schleife aus Aufgabe 7.9.1 mit einer rekursiven Funktion statt mit einer
Schleife.
Ausgabe
1 2 3 4 5
Lösung siehe Kapitel todo.
8.8.4 Aufgabe „Zahlen-Liste 2“
Und auch die Zahlen-Liste aus Aufgabe 7.9.4 läßt sich nun mit Funktionen und Rekursion neu
schreiben.
Ausgabe:
(1-2-3-4-5)
Lösung siehe Kapitel todo.
8.8.5 Aufgabe „Quadratwurzel“
Schreiben Sie ein Programm, das die Quadratwurzel einer Fließkomma-Zahl größer-gleich 1.0
berechnet. Benutzen Sie hierbei nur die Grundrechenarten und Vergleiche, indem Sie sich der
Lösung durch Intervall-Schachtelung Schritt für Schritt annähern.
Das Konzept der Intervall-Schachtelung arbeitet folgendermaßen:
• Beginnen Sie mit zwei Zahlen, von denen Sie ausgehen können, dass sie kleiner-gleich bzw.
größer-gleich der Quadratwurzel sind.
• Berechnen Sie den Mittelwert der beiden Zahlen, und quadrieren Sie diesen.
• Weicht der quadrierte Mittelwert um weniger als einen Toleranzwert epsilon (z.B. 1.0e-5) von
der Eingabe-Zahl ab, so verwenden Sie den Mittelwert als Ergebnis der Berechnung. D.h.
Sie haben die Quadratwurzel gefunden.
• Ist das Quadrat des Mittelwertes größer als die Eingabe-Zahl, so verwenden Sie das untere
Intervall für die nächste Iteration.
• Ist das Quadrat des Mittelwertes kleiner als die Eingabe-Zahl, so verwenden Sie das obere
Intervall für die nächste Iteration.
• Führen Sie die Iteration so lange durch, bis sich der quadrierte Mittelwert bis auf den
Seite 143 / 409
Toleranzwert epsilon an die Eingabe-Zahl angenähert hat.
Geben Sie am Anfang der Berechnung den Toleranzwert epsilon aus.
Geben Sie vor jeder Iteration die Nummer der Iteration und das aktuelle Intervall aus.
Und geben Sie am Ende natürlich auch die Wurzel aus.
Mögliche Ein- und Ausgabe
Wurzel-Berechnung fuer Zahlen groesser-gleich 1.0
Zahl: 4
Berechne Wurzel aus 4 mit einem Epsilon von 0.0001
- Durchlauf 1: 1 < sqrt(4) < 4
- Durchlauf 2: 1 < sqrt(4) < 2.5
- Durchlauf 3: 1.75 < sqrt(4) < 2.5
- Durchlauf 4: 1.75 < sqrt(4) < 2.125
- Durchlauf 5: 1.9375 < sqrt(4) < 2.125
- Durchlauf 6: 1.9375 < sqrt(4) < 2.03125
- Durchlauf 7: 1.98438 < sqrt(4) < 2.03125
- Durchlauf 8: 1.98438 < sqrt(4) < 2.00781
- Durchlauf 9: 1.99609 < sqrt(4) < 2.00781
- Durchlauf 10: 1.99609 < sqrt(4) < 2.00195
- Durchlauf 11: 1.99902 < sqrt(4) < 2.00195
- Durchlauf 12: 1.99902 < sqrt(4) < 2.00049
- Durchlauf 13: 1.99976 < sqrt(4) < 2.00049
- Durchlauf 14: 1.99976 < sqrt(4) < 2.00012
- Durchlauf 15: 1.99994 < sqrt(4) < 2.00012
- Durchlauf 16: 1.99994 < sqrt(4) < 2.00003
Wurzel: 1.99998
Gibt es mehrere Arten, wie sie diese Funktion implementieren können? Wenn ja, dann machen
Sie das auch.
8.9 Lsg. zu Aufgabe „Fakultäts Funktion“ – Kap. 8.8.1
8.9.1 Iterative Lösung
Die iterative Berechnung der Fakultät, d.h. mit einer Schleife, läß sich im Prinzip direkt runter
implementieren. Man muss ja nur alle Zahlen von „0“ bis „n“ inkl. aufmultiplizieren, und dass
Ergebnis zurückgeben.
public static long facIterative(int n) {
long res = 1;
for (int i=2; i<=n; i++) {
res *= i;
}
return res;
}
Hinweis – da die Fakultät von „0“ und „1“ selber „1“ sind, braucht die Schleife erst ab „2“ los
zulaufen. Falls die Funktion mit dem Argument „0“ oder „1“ aufgerufen wird, ist dies auch kein
Problem, da eine For-Schleife kopfgesteuert ist, d.h. auch kein Mal durchlaufen werden kann.
Hinweis – passen Sie auf, dass Sie die Schleife bis „n“ inkl. laufen lassen, d.h. die AbbruchBedingung ist „i<=n“ mit dem Operator „kleiner-gleich“.
Seite 144 / 409
8.9.2 Rekursive Lösung
Auch die rekusive Berechnung ist nicht weiter schwierig, da man hier quasi direkt die
mathematische Definition abschreiben kann:
• fak(0) :== 1
• fak(1) :== 1
• fak(n) :== n * fak(n-1)
public static long facRecursive(int n) {
if (n<=1) {
return 1;
}
return n * facRecursive (n-1);
}
8.9.3 Main-Funktion
Die Aufgabe fordert auch eine kleine Main-Funktion. Hier eine, die beide Funktionen parallel
nutzt, und den Benutzer ihre Ergebnisse vergleichen läßt.
for (int i=0; i<=20; i++) {
long fi = facIterative(i);
long fr = facRecursive(i);
System.out.println(i + "! => " + fi + "
}
}
" + fr);
Ausgabe
0! => 1 1
1! => 1 1
2! => 2 2
3! => 6 6
4! => 24 24
5! => 120 120
6! => 720 720
7! => 5040 5040
8! => 40320 40320
9! => 362880 362880
10! => 3628800 3628800
11! => 39916800 39916800
12! => 479001600 479001600
13! => 6227020800 6227020800
14! => 87178291200 87178291200
15! => 1307674368000 1307674368000
16! => 20922789888000 20922789888000
17! => 355687428096000 355687428096000
18! => 6402373705728000 6402373705728000
19! => 121645100408832000 121645100408832000
20! => 2432902008176640000 2432902008176640000
Und welche Lösung sollte man in der Praxis benutzen? Hier ist sicher die iterative Lösung
vorzuziehen, die vollkommen unproblematisch zu implementieren ist, und vor allem bzgl.
Performance vorzuziehen ist, da ein Schleifen-Durchlauf im Normall-Fall einiges billiger ist als
ein Funktions-Aufruf.
Achtung – keine der Lösung kümmert sich wirklich gut um das Problem: „Was passiert, wenn
Seite 145 / 409
die Funktion mit einer negativen Zahl aufgerufen wird?“ Beide Lösungen geben dann „1“
zurück, was zwar ein sauber definiertes Verhalten ist, aber auch sicher nicht das richtige
Ergebnis. Die typische Java-Lösung, wie wir sie z.B. schon aus den Kapiteln 3.5, 3.10 oder
3.11 kennen, ist die Benutzung von Exceptions – siehe Kapitel todo. Da wir Exceptions noch
nicht kennen, ignorieren wir dieses Problem hier erstmal (sollten es aber nicht vergessen).
8.9.4 Gesamter Quelltext
Hier noch mal der ganze Quelltext inkl. Klasse.
public class Appl {
public static long facIterative(int n) {
long res = 1;
for (int i=2; i<=n; i++) {
res *= i;
}
return res;
}
public static long facRecursive(int n) {
if (n<=1) {
return 1;
}
return n*facRecursive(n-1);
}
for (int i=0; i<=20; i++) {
long fi = facIterative(i);
long fr = facRecursive(i);
System.out.println(i + "! => " + fi + "
}
}
" + fr);
}
8.10 Lsg. zu Aufgabe „Primzahl?“ – Kap. 8.8.2
public class Appl {
public static boolean prim(int n) {
for (int i=2; i<=Math.sqrt(n); i++) {
if (n%i==0) {
return false;
}
}
return true;
}
public static void check(String s) {
try {
int n = Integer.parseInt(s);
if (n<0) {
System.out.println("Negative Zahl: " + n + " - no check");
} else {
System.out.println(n + " prim? -> " + prim(n));
Seite 146 / 409
}
System.out.println("Keine Zahl: \"" + s + "\" - no check");
}
}
for (int i=0; i<args.length; i++) {
check(args[i]);
}
return;
}
try {
System.out.print("Bitte geben Sie die zu checkende Zahl ein: ");
check(in);
System.out.println("Probleme beim Einlesen");
}
}
}
8.11 Lsg. zu „Aufgabe „Schleife rekursiv“ – Kap. 8.8.3
public class Appl {
public static void loop(int n, int limit) {
System.out.print(n + " ");
if (n == limit) {
return;
}
loop(n + 1, limit);
}
loop(1, 5);
}
}
8.12 Lsg. zu Aufgabe „Zahlen-Liste 2“ – Kap. 8.8.4
public class Appl {
public static void loop(int n, int limit) {
internalLoop(n, limit);
System.out.print(')');
}
public static void internalLoop(int n, int limit) {
if (n == limit) {
System.out.print(n);
return;
}
Seite 147 / 409
System.out.print(n + "-");
internalLoop(n + 1, limit);
}
loop(1, 5);
}
}
8.13 Lsg. zu Aufgabe „Quadratwurzel“ – Kap. 8.8.5
8.13.1 Lösung 1 - Iterativ
Fangen wir mit den einfachen Dingen an:
• Zuerst muss ein String von der Kommando-Zeile eingelesen werden.
• Der muss in eine Fließkomma-Zahl gewandelt werden.
• Diese Fließkomman-Zahl soll größer-gleich 1.0 sein.
• Macht eine dieser Bereiche Probleme, beenden wir das Programm mit einer FehlerMeldung.
• Die eigentliche Wurzel-Berechnung lagern wir in die Funktion „squareRoot“ aus.
try {
System.out.print("Bitte geben Sie eine Zahl >=1 ein: ");
try {
double d = Double.parseDouble(in);
if (d<1.0) {
System.out.println("Zahl: " + d + " zu klein");
} else {
squareRoot(d);
}
System.out.println("Keine Zahl: \"" + s + "\"");
}
}
Ich hoffe, Sie sehen es wie ich: der Code sieht kompliziert aus. Man könnte natürlich die
verschachtelten Try-Catch-Blöcke zu einem zusammenfassen, aber dann würden die FehlerMeldungen nicht mehr dediziert für das Problem sein35. Besser ist, wir trennen den Code durch
Benutzung von Funktionen.
try {
calc(in);
Okay, ich gebe zu: das könnte man hier trotzdem hinbekommen, da unterschiedliche
Exceptions geworfen werden. Aber das lernen wir ja erst viel später in Kapitel todo.
35
Seite 148 / 409
}
}
public static void calc(String s) {
try {
double d = Double.parseDouble(s);
if (d<1.0) {
} else {
squareRoot(d);
}
}
}
Das ganz hat jetzt außerdem den Vorteil, dass wir unser Programm problemlos komfortabler
gestalten können – viel komfortabler als die Aufgabe das von uns erwartet. Aber wir machen ja
gerne Sternchen-Aufgaben, da das mit Java so einfach ist und so viel Spaß macht.
Schön wäre es, dass Programm sowohl mit einem Kommandozeilen-Argument als auch mit
einer interaktiven Eingabe von der Kommandozeile benutzen zu können. Die Idee ist, wenn der
Benutzer ein Kommandozeilen-Argument mitgibt, dann wird von diesem die Wurzel berechnet.
Ansonsten wird die Eingabe interaktiv von der Konsole eingelesen.
Dies ist jetzt einfach zu implementieren, da wir nur die Kommandozeilen-Argumente auswerten
müssen, und im Falle von einem vorhandenen dieses an die Calc-Funktion weiterreichen
müssen36.
calc(args[0]);
return;
}
...
}
Damit bleibt nur noch die eigentliche Funktion „squareRoot“ zur Berechnung der Wurzel zur
Implementierung übrig:
• Zuerst wird ein Toleranzwert epsilon benötigt, der die mindestens notwendige Näherung an
die wahre Lösung beschreibt. Hierfür bietet sich natürlich eine Konstante (siehe Kapitel 8.3)
an. Noch besser wäre sicher eine Klassen-Konstante, aber die lernen wir erst in Kapitel
12.5.2 kennen.
• Und es muss eine Start-Ausgabe geben.
Alles zusammen kann dann z.B. so aussehen:
public static double squareRoot(double v) {
final double epsilon = 0.0001;
System.out.println("Berechne Wurzel aus " + v +
Wenn sie noch mehr an Sternchen-Aufgaben interessiert sind, dann sorgen sie doch einfach
dafür, dass wenn mehrere Kommandozeilen-Argumente übergeben werden, für alle die Wurzel
berechnet wird.
36
Seite 149 / 409
" mit einem Epsilon von " + epsilon);
...
}
Für die Intervallschachtelung benötigen wir zwei Zahlen, bei denen die eine auf jeden Fall
kleiner-gleich der Lösung ist, während die andere größer-gleich der Lösung sein muss. Die
Aufgabe ist zufälligerweise so gestellt, dass der Eingabe-Wert „v“ größer-gleich 1.0 sein muss,
d.h. die Lösung wird immer auch größer-gleich 1.0 sein, und immer kleiner-gleich der EingabeZahl „v“. Als untere und obere Grenze bieten sich also diese Werte an. Die Berechnung des
Mittelwerts „average“ der beiden Grenzwerte, und seine Quadratur „av2“ sind dann kein
Problem mehr.
double
double
double
double
lowerLimit = 1.0;
upper_Limit = v;
average = (lower_limit + upperLimit) / 2;
av2 = average*average;
Die Ausgabe vor jeder Iteration verschieben wir erstmal auf später – wir dürfen sie nur nicht
vergessen.
Wenn der quadrierte Mittelwert „av2“ den Eingabe-Wert bis auf den Toleranzwert epsilon
erreicht hat, dann ist der Mittelwert die Lösung. Ansonsten muss die Iteration fortgesetzt
werden. Dies klingt nach einer Schleife mit entsprechender Abbruch-Bedingung.
Da bleibt höchstens noch die Frage, ob der Mittelwert „average“ bei dem die Eingabe „v“ auf
genau epsilon erreicht wird, auch schon eine Lösung ist oder nicht. Letztlich also die Frage, ob
die Abbruch-Bedingung „>=“ und „<=“ oder nur „>“ und „<“ enthält. Die Aufgaben-Stellung ist
hier nicht ganz exakt, ich habe mir für erstes entschieden. Die Schleife sieht also
folgendermaßen aus.
while ((av2-epsilon>=v) || (av2+epsilon<=v)) {
...
}
Für den Fall, dass die Lösung noch nicht erreicht wurde, muss das Intervall – wie in der
Aufgabe beschrieben – neu gewählt werden
if (v<av2) {
upperLimit = average;
} else {
lowerLimit = average;
}
...
}
Und dann muss für das neu gewählte Intervall der Mittelwert und sein Quadrat neu berechnet
werden.
if (v<av2) {
} else {
Seite 150 / 409
}
average = (lowerLimit+upperLimit)/2;
av2 = average*average;
}
Im Prinzip ist die Aufgabe jetzt schon fertig. Wir sehen hier aber mal wieder eine Verletzung
des DRY-Prinzips37, da die beiden Berechnungen nun zweimal im Quelltext vorkommen: initial
vor der Schleife, und am Ende der Schleife. Dies liegt daran, dass hier wieder mal eine Schleife
mit Ausgang in der Mitte benötigt wird. Also ändern wir dies um.
double lowerLimit = 1.0;
double upper_Limit = v;
double average;
for (int count=0;;) {
average = (lower_limit+upperLimit)/2;
double av2 = average*average;
if ((av2-epsilon<v) && (av2+epsilon>v)) break;
if (v<av2) {
continue;
}
}
Jetzt fehlt nur noch die Ausgabe während jeder Iteration, und am Ende die Ausgabe der
Lösung.
System.out.println("- Durchlauf " + ++count + ": " + lowerLimit +
" < sqrt(" + v + ") < " + upperLimit);
...
}
System.out.println("Wurzel: " + average);
Alles zusammen sieht dann z.B. so aus:
public class Appl {
//-----------------------------------------------------------------------public static void main(String[] args) {
calc(args[0]);
return;
}
try {
calc(in);
}
}
//-----------------------------------------------------------------------public static void calc(String s) {
37
DRY – don’t repeat yourself.
Seite 151 / 409
try {
if (d<1.0) {
} else {
squareRoot(d);
}
}
}
//-----------------------------------------------------------------------public static double squareRoot(double v) {
System.out.println("Berechne Wurzel aus " + v +
" mit einem Epsilon von " + epsilon);
double lowerLimit = 1.0;
double upper_Limit = v;
double average;
System.out.println("- Durchlauf " + ++count + ": " + lowerLimit +
average = (lower_limit+upperLimit)/2;
if ((av2-epsilon<v) && (av2+epsilon>v)) break;
if (v<av2) {
continue;
}
}
System.out.println("Wurzel: " + average);
return average;
}
}
8.13.2 Lösung 2 - Rekursiv
Natürlich läßt sich auch die Quadratwurzel Berechnung mit Intervall-Schachtelung rekursiv
berechnen. Genau genommen zwingt sich der rekursive Algorithmus bei der Überlegung, wie
man die Funktion implementiert, geradezu auf.
Denn was macht man bei der Intervall-Schachtelung? Man teilt das Intervall, in dem sich die
Lösung befinden muss, in zwei gleich große Teile, und untersucht in welchem Teil die Lösung
liegen muss. Für diesen Teil macht man wieder das gleiche, d.h. wendet die IntervallSchachtelung auf diesen Teil an. Usw. Sie sehen, das klingt stark rekursiv.
Und die Abbruch Bedingung ist natürlich, wenn die Lösung bis auf epsilon erreicht wurde.
public class Appl {
//------------------------------------------------------------------------public static void main(String[] args) {
calc(args[0]);
return;
Seite 152 / 409
}
try {
calc(in);
}
}
//------------------------------------------------------------------------public static void calc(String s) {
try {
if (d<1.0) {
System.out.println("Zahl: " + d + " zu kleine - keine Berechnung");
} else {
squareRoot(d);
}
System.out.println("Keine Zahl: \"" + s + "\" - keine Berechnung");
}
}
//------------------------------------------------------------------------public static double squareRoot(double v) {
System.out.println("Berechne Wurzel aus " + v + " mit einem Epsilon von
0.0001");
double sqrt = squareRoot(v, 1.0, v, 1);
System.out.println("Wurzel: " + sqrt);
return sqrt;
}
//------------------------------------------------------------------------public static double squareRoot(
double v, double lowerLimit, double upperLimit, int count) {
System.out.println("- Durchlauf " + count + ": " + lowerLimit +
double average = (lowerLimit+upperLimit)/2;
if ((av2-epsilon<v) && (av2+epsilon>v)) {
return average;
}
if (v<av2) {
return squareRoot(v, lowerLimit, average, count+1);
}
return squareRoot(v, average, upperLimit, count+1);
}
}
9 Ausgewählte Bibliotheks-Klassen
Die Java Bibliothek (JDK 1.8) umfaßt ~217 Packages mit ~4240 Klassen – siehe Kapitel 2. Für
viele Probleme stehen daher fertige Klassen zur Verfügung. Ein paar ganz allgemeine und sehr
zentrale Klassen möchte ich hier ganz kurz vorstellen, damit wir sie in späteren Beispielen bzw.
dem Praktikum benutzen können. Aber machen Sie sich klar, es sind nur ganz wenige aus dem
großen Angebot der Java-Welt.
Seite 153 / 409
9.1 Klasse String
Mit der Klasse String werden konstante Unicode Zeichenketten repräsentiert. Ja, Sie haben
richtig gelesen: „konstante Zeichenketten“. Strings können aus Performance-Gründen nicht
verändert werden. Wollen Sie Zeichenketten modifizieren, so müssen Sie die Klassen
StringBuilder oder StringBuffer (siehe Kapitel 9.2) verwenden.
Hinweise:
• Man nennt Strings, wie auch andere unveränderbare Objekte, auch „immutable“ Objekte.
• Strings können einfach so benutzt werden, und benötigen kein „import“. Sie kommen aus
dem Package „java.lang“, das immer automatisch zur Verfügung steht – Kapitel 13.3.
9.1.1 Initialisierung
Da Zeichenketten in der Praxis sehr häufig vorkommen, sind in der Sprache Java einige
Unterstützungen für Strings integriert, die über eine normale ‚Klasse‘ hinaus gehen.
So können Strings neben dem expliziten Erstellen mit „new“ auch einfach mit Zeichenketten
erzeugt werden38.
public class Kap_09_01_Bsp_01_Strings {
String s1 = new String("Java"); // So muessen in Java eigentlich alle
System.out.println(s1);
// Objekte angelegt werden: mit "new"
String s2 = "Hallo Welt";
// Aber bei Strings geht es auch ohne
// "new" - Nettigkeit der Sprache
s1 = "Viel einfacher so";
// Und das geht auch bei Zuweisungen
s1 = new String("Aufwaendig");
// Die normale Art fuer Nicht-Strings
}
}
Ausgabe
Java
Hallo Welt
Viel einfacher so
Aufwaendig
9.1.2 Operator +
Für die Klasse String ist in der Sprache Java der Operator + definiert. Auf zwei Strings
angewandt ist das Ergebnis ein neuer String, der aus den beiden konkatinierten Operanden
besteht.
public class Kap_09_01_Bsp_02_StringAddition1 {
Im Gegensatz zu Arrays (siehe Kapitel 10.1) geht dies jederzeit, und nicht nur bei der
Variablen-Definitionen.
38
Seite 154 / 409
String s2 = " Welt";
String s = s1 + s2;
System.out.println(s);
}
}
Ausgabe
Hallo Welt
Wie schon kurz in Kapitel 3.4 angesprochen: ist nur einer der Operanden ein String, so wird der
andere implizit in einen String umgewandelt. Wir sehen dies im folgenden Quelltext:
• in der Zeile (*) für einige elementare Datentypen („boolean“, „int“ und „long“),
• in der Zeile (**) nochmal expliziter für ein „int“, und
• in der Zeile (****) für ein AWT-Label. Wir werden GUI-Label noch in Kapitel 20.1 näher
kennen lernen – hier steht es einfach für ein komplexes Objekt. Als Beispiel, dass wirklich
jedes Objekt beim Operator + in einen String gewandelt wird.
import java.awt.Label;
public class Kap_09_01_Bsp_03_StringAddition2 {
String s = "Variablen: ";
boolean b = true;
int i = 12345;
long l = 123456789012345L;
s = s + b + "=" + false + " - i=" + i + " - l=" + l;
int n = 42;
String s1 = "" + n;
String s2 = "" + Integer.toString(n);
Label label = new Label("Beschriftung");
s1 = "" + label;
s2 = label.toString();
// Zeile (*)
// Zeile (**)
// Zeile (***)
// Zeile (****)
// Zeile (*****)
}
}
Ausgabe
Variablen: true=false - i=12345 - l=123456789012345
42
42
java.awt.Label[label0,0,0,0x0,invalid,align=left,text=Beschriftung]
java.awt.Label[label0,0,0,0x0,invalid,align=left,text=Beschriftung]
Alternativ zu den impliziten Wandlungen beim Operator + in z.B. Zeile (**) und (****) sind auch
die mehr expliziten Wandlungen wie hier in den Zeilen (***) und (*****) möglich.
• Für alle elementaren Datentypen existieren Standard-Umwandlungen, die sich auch in den
jeweiligen Wrapper-Klassen wiederfinden – siehe Kapitel 3.11 und 9.4.
• Für alle anderen Typen kann die Elementfunktion „toString()“ benutzt werden, die für alle
Klassen definiert ist – siehe auch Kapitel 14.11.1.
Seite 155 / 409
Bitte beachten Sie: auch wenn im Quelltext des letzten Beispiels „s=...“ steht, so wird nicht der
String verändert. Es ändert sich nur der Wert der Referenz-Variablen „s“, die nach der
Zuweisung auf ein anderes String-Objekt verweist. Das originale String-Objekt mit dem Wert
„Variablen: “ wird nicht verändert, sondern jetzt nur nicht mehr referenziert.
String
String s = "abc"
s = s + "def"
s:
=>
verändert
s:
unverändert
"abc"
String
String
"abc"
"def"
=>
String
"abcdef"
Abb. 9-1 : Ein String-Objekt wird nicht verändert
Hinweis – die Addition von Strings mit dem Plus-Operator ist nicht sehr effizient. Wie Sie an
der obigen Abbildung sehen können, müssen bei dieser Operation neue Objekte angelegt und
die Zeichen kopiert werden – was relativ viel Zeit kostet. Nutzen Sie aufgrund der Performance
Vorteile bei String-Verkettungen die Klassen „StringBuilder“ und „StringBuffer“, siehe Kapitel
9.2.
9.1.3 Referenz-Semantik und Konstante Zeichenketten
Da String eine Klasse und kein elementarer Datentyp ist, unterliegen String-Variablen natürlich
der Referenz-Semantik (siehe Kapitel 5.4.2).
Und die Klasse String repräsentiert konstante Zeichenketten. D.h. es gibt keine Möglichkeit
einen String zu verändern. Alle Operationen auf Strings lassen diese unangetastet, bzw. geben
einen neuen zurück – der Originalstring bleibt immer unverändert, String-Objekte sind
immutable.
Damit entfällt das typische Problem der Referenzsemantik, nämlich dass ein Objekt von
woanders einfach geändert wird. Strings sind dagegen resistent, und darum an vielen Stellen
unproblematischer – vergleiche z.B. Kapitel todo oder auch Kapitel todo.
Achtung – umgekehrt gibt es bei Strings dadurch auch eine Falle: der Vergleichs-Operator
„==“ führt auch bei Strings nur einen Identitäts-Vergleich durch, und keinen Wert-Vergleich.
Leider verhält sich der Operator „==“ bei Strings aber manchmal so, als würde er einen WertVergleich durchführen – siehe auch Kapitel 6.2. Vergleichen Sie Strings immer mit „equals“,
auch wenn der Operator „==“ scheinbar funktioniert.
Seite 156 / 409
9.1.4 Schnittstelle
Die Klasse String ist in java.lang definiert. Sie hat keine public Attribute, aber viele ElementFunktionen – hier eine kleine Auswahl:
String()
Konstruktor: erzeugt einen leeren String.
String(char[ ])
Konstruktor: erzeugt einen String aus einem char-Array.
String(StringBuffer)
Konstruktor: erzeugt einen String aus einem String-Buffer.
boolean equals(String)
Gibt zurück, ob die beiden Strings wert-gleich sind.
boolean equalsIgnoreCase
(String anotherString)
Vergleicht zwei String ohne Berücksichtigung von Groß- und KleinSchreibung.
char charAt(int)
Gibt das Zeichen an der spezifizierten Position zurück.
int length()
Gibt die Anzahl an Zeichen des Strings zurück, d.h. seine Länge.
String trim()
Gibt einen neuen String zurück, der dem alten ohne führende und
folgende Whitespaces (nicht sichtbare Zeichen wie z.B.
Leerzeichen oder Tabulator) entspricht.
boolean startsWith(String)
Gibt zurück, ob der String mit dem übergebenen beginnt.
boolean endsWith(String)
Gibt zurück, ob der String mit dem übergebenen aufhört.
String substring
(int beginIndex, int endIndex)
Gibt eine Teil-String als neuen String zurück. Der Teil-String
beginnt beim Zeichen mit dem Index „beginIndex“ inkl. und endet
beim Zeichen mit dem Index „endIndex“ exkl. Bei fehlerhaften
Indices wird eine Exception geworfen.
Die komplette Schnittstelle der Klasse „String“ finden Sie in der offiziellen Java ReferenzDokumentation, die Sie bei Oracle herunterladen können – siehe Kapitel 4.1.1.
9.2 Klassen StringBuilder & StringBuffer
Die Klassen StringBuilder und StringBuffer repräsentieren Unicode Zeichenketten, die
verändert werden dürfen. Beide Klassen enthalten viele Funktionen zur Modifikation von
Texten, z.B. die Element-Funktion „append“, die einen Text an das bestehende StringBuilderoder StringBuffer-Objekt anfügen.
public class Kap_09_02_Bsp_01_StringBuilderUndBuffer {
StringBuilder sb1 = new StringBuilder("1: Append");
sb1.append(" mit");
sb1.append(" StringBuilder");
System.out.println(sb1);
StringBuffer sb2 = new StringBuffer("2: Append");
sb2.append(" mit");
sb2.append(" StringBuffer");
System.out.println(sb2);
Seite 157 / 409
}
}
Ausgabe
1: Append mit StringBuilder
2: Append mit StringBuffer
Im Gegensatz zur String-Addition wird hierbei wirklich das Objekt verändert und kein Neues
erzeugt. Dafür müssen StringBuilder- und StringBuffer-Objekte ganz normal explizit mit „new“
erzeugt werden.
Abb. 9-2 : Ein StringBuilder-Objekt wird verändert
Die Klasse „StringBuffer“ existiert seit dem JDK 1.0, während die Klasse „StringBuilder“ erst mit
dem JDK 1.5 eingeführt. Beide Klassen haben dieselbe Schnittstelle. Im Gegensatz zu
StringBuffer ist StringBuilder aber nicht multi-threading fest, dafür aber wesentlich schneller.
Sie sollten also in single-threaded Anwendungen, oder in MT-unkritischen Situation (wie z.B.
String-Manipulation innerhalb einer Funktion mit einer lokalen Variable) die Klasse
„StringBuilder“ gegenüber „StringBuffer“ bevorzugen. Benötigen Sie dagegen eine MT feste
Klasse, so führt kein Weg an „StringBuffer“ vorbei – auch wenn dies mit Performance-Einbußen
verbunden ist.
Hinweis – auch die Klassen StringBuilder und StringBuffer können einfach so benutzt werden,
und benötigen kein „import“. Vergleichbar zur Klasse String kommen sie aus dem Package
„java.lang“, das immer automatisch zur Verfügung steht – siehe Kapitel 13.3.
9.3 Container & Iteratoren
Container sind Objekte, die andere Objekte aufnehmen können, diese verwalten, und dabei
automatisch passend wachsen. Es gibt nicht den einen Container, der für alle Zwecke optimal
geeignet ist, sondern jeder Container hat seine Vor- und Nachteile. Je nach Anwendung bzw.
Anforderung ist mal der Eine, mal der Andere besser geeignet. Nähere Informationen hierzu
finden Sie in Kapitel todo, und ausführlicher in vielen Büchern über „Algorithmen und
Datenstrukturen“.
Seit der ersten Java Version (JDK 1.0) sind einige grundlegende Container Bestandteil der
Java Klassen-Bibliothek. Mit der Version Java 2 (JDK 1.2) wurden die Container stark
überarbeitet und erweitert, und dann mit jeder JDK Version weiter verbessert. So ist heute ein
sehr ordentliches Container-Framework Bestandteil der Java Bibliothek.
9.3.1 Einführung in Container & Iteratoren
Ein typischer Container ist die „ArrayList“. Sie wird – wie jedes Objekt in Java – mit „new“
erzeugt und kann dann einfach genutzt werden. In spitzen Klammern geben wir den Typ der
Elemente an, die in der ArrayList gespeichert werden sollen. Mit diesen spitzen Klammern
Seite 158 / 409
nutzen wir die seit JDK 1.5 vorhandenen Generics, um den Container typsicher zu machen.
Im folgenden Beispiel wird eine ArrayList für Strings angelegt und mit 3 Strings gefüllt. Die
aktuelle Anzahl an Elementen im Container kann man dann mit „size()“ abfragen:
import java.util.ArrayList;
public class Kap_09_03_Bsp_01_ContainerEinstieg {
ArrayList<String> al = new ArrayList<String>();
al.add("Hallo");
al.add("Java");
al.add("Kurs");
System.out.println("Array-List enthaelt " + al.size() + " Elemente");
}
}
Ausgabe
Array-List enthaelt 3 Elemente
Die Typisierung mit den spitzen Klammern bewirkt, dass keine Objekte falschen Typs in den
Container eingefügt werden können39.
ArrayList<String> l = new ArrayList<String>();
l.add("Java");
// Okay, "Java" ist ein String
l.add(123);
// Compiler-Fehler, kein String
l.add(new StringBuilder());
// Compiler-Fehler, auch kein String
Seit JDK 1.7 kann man sich die Erzeugung eines typisierten Objektes erleichtern – man
benötigt die Angabe des Element-Typs in den spitzen Klammern nicht mehr, da der Compiler
diesen aus dem Variablen-Typ ermitteln kann.
public class Kap_09_03_Bsp_02_ContainerEinstiegJdk17 {
ArrayList<String> al = new ArrayList<>();
al.add("JDK 1.7");
System.out.println("Array-List enthaelt " + al.size() + " Element");
al = new ArrayList<>();
System.out.println("Array-List enthaelt " + al.size() + " Elemente");
}
}
Ausgabe
Aber wie läuft man jetzt über einen Container und gibt z.B. alle Element im Container aus? Für
eine ArrayList könnte man dies noch mit einer normalen For-Schleife mit Index-Zähler und dem
wahlfreiem Zugriff auf die Array-List (Element-Funktion „get(index)“) umsetzen:
Hier wird das in Java 5 (JDK 1.5) eingeführte Sprachmittel „Generics“ benutzt. Dieses JavaTutorial behandelt Generics leider nicht.
39
Seite 159 / 409
public class Kap_09_03_Bsp_03_ContainerSchleife {
al.add("Hallo");
al.add("Java");
al.add("Interessierte");
// Achtung – so laeuft man eigentlich nie ueber einen Container
for (int i = 0; i < al.size(); i++) {
String s = al.get(i);
System.out.print(s + " ");
}
}
}
Ausgabe
Hallo Java Interessierte
Für das normale Laufen über einen Container sollte man nie den wahlfreien Zugriff mit
„get(index)“ einsetzen, denn:
• Es gibt Container, bei denen der wahlfreie Zugriff sehr langsam ist – z.B. die LinkedList,
siehe Kapitel 9.3.5.
• Es gibt viele Container, die prinzip-bedingt gar keinen wahlfreien Zugriff unterstützen
können, und daher auch nicht enthalten – z.B. eine HashMap, siehe Kapitel 9.3.9.
• Außerdem gibt es für einfachere Lösungen für dieses Problem.
An die Stelle des wahlfreien Zugriffs treten dann die neue For-Schleife oder die Iteratoren40.
Beginnen wir mit der neuen For-Schleife.
Hinweis – die Nutzung des wahlfreien Zugriffs sollte nur dann genutzt werden, wenn man
diesen explizit durch den Algorithmus benötigt. Dann ist er natürlich sehr sinnvoll. Aber Sie
sollten dann auch einen Container wählen, der den wahlfreien Zugriff performant unterstützt,
wie z.B. die ArrayList – siehe Kapitel 9.3.4.
9.3.1.1 Neue For-Schleife für Container
Mit JDK 1.5 (Java 5) wurde ein neuer For-Schleifentyp eingeführt (siehe auch Kapitel 7.4) – der
seit dem die normale Variante ist. Hierbei muß nur noch eine Element-Lauf-Variable mit Typ,
und nach einem Doppelpunkt der Container angegeben werden – den Rest macht der Compiler
automatisch – siehe Beispiel.
public class Kap_09_03_Bsp_04_NeueForSchleife {
ArrayList<String> l = new ArrayList<>();
l.add("Java");
l.add("mit");
l.add("neuer");
l.add("JDK 1.5");
Für eine ausführliche Diskussion von Iteratoren siehe das Buch „Entwurfsmuster“ von u.a.
Erich Gamma.
40
Seite 160 / 409
l.add("For-Schleife");
for (String s : l) {
}
}
}
Ausgabe
Java mit neuer JDK 1.5 For-Schleife
Diese Schleife kann eigentlich nur eins: einfach über den Container laufen – Element für
Element. Mehr nicht, aber auch nicht weniger – und das ist der normale Anwendungsfall für
Container mit Schleifen, der 95 % Fall. Und den beherrscht sie einfach, schnell und zuverlässig.
Und darum nehmen wir diese Schleife auch immer für diesen Use-Case.
Die einzigen zusätzlichen Möglichkeiten der Container-For-Schleife sind die Nutzung der
Sprung-Anweisungen „break“ und „continue“ – siehe Kapitel 7.4 – die die Schleife vorzeitig
verlassen oder direkt zum nächsten Element gehen können. Hier ein Beispiel mit der neuen
For-Schleife mit „break“ und „continue“:
public class Appl {
ArrayList<String> l = new ArrayList<String>();
l.add("a");
l.add("b");
l.add("c");
l.add("d");
l.add("e");
l.add("f");
for (String s : l) {
System.out.print(s);
if (s.equals("b")) {
continue;
}
System.out.print("-");
if (s.equals("e")) {
break;
}
}
// Zeile (*)
// Zeile (**)
}
}
Ausgabe
a-bc-d-e-
Nach der Ausgabe von „b “ wird kein Bindestrich ausgegeben, da das „continue“ in Zeile (*)
zuschlägt, und nach Ausgabe von „e-“ wird die Schleife aufgrund von „break“ in Zeile (**)
abgebrochen.
9.3.1.2 Container & Iteratoren
Ein Iterator ist die Abstraktion eines Objekts mit dem über eine Objekt-Menge gelaufen (iteriert)
Seite 161 / 409
werden kann. Ein Iterator zeigt auf ein Objekt, kann auf das nächste gesetzt werden, und weiß,
ob es noch weitere Objekte in der Menge gibt.
Jeder Java Container hat eine Element-Funktion „iterator()“, die einen Iterator über den
Container zurückgibt. Mit der Element-Funktion „hasNext()“ kann am Iterator abgefragt werden,
ob noch weitere Elemente vorliegen. Die Element-Funktion „next()“ geht vor das nächste
Element und gibt dabei das aktuelle Element zurück:
import java.util.Iterator;
public class Appl {
al.add("Lasst");
al.add("uns");
al.add("Java");
al.add("lernen");
// Iterator mit While-Schleife
Iterator<String> it1 = al.iterator();
while (it1.hasNext()) {
String s = it1.next();
}
// Iterator mit For-Schleife
for (Iterator<String> it2 = al.iterator(); it2.hasNext(); ) {
String s = it2.next();
}
}
}
Ausgabe
Lasst uns Java lernen
Lasst uns Java lernen
In der Praxis trifft man Iteratoren sowohl mit While- als auch mit For-Schleife – darum enthält
das obige Beispiel beide Varianten. Sie sind gleichwertig und es ist daher reine
Geschmackssache, welche Variante Sie bevorzugen.
9.3.2 Untypisierte Container
Alle bisherigen Beispiel arbeiten mit typisierten Containern, d.h. Containern, deren Element-Typ
mit spitzen Klammern angegeben ist41. Diese Typisierung hat zwei Vorteile:
• Sie können nur Elemente passendes Typs in den Container einfügen – Objekte mit falschem
Typ erzeugen einen Compiler-Fehler (siehe Beispiel weiter oben).
• Holen Sie Element aus dem Container, so ist der Typ bekannt und spezielle
Konvertierungen sind nicht notwendig.
Hier wird das in Java 5 (JDK 1.5) eingeführte Sprachmittel „Generics“ benutzt. Dieses JavaTutorial behandelt Generics leider nicht.
41
Seite 162 / 409
In der Praxis begegnet uns noch sehr häufig Code mit untypisierten Containern, da dies über 9
Jahre Stand der Java Technik war:
• Viele Schnittstellen sind in dieser Ära entstanden, setzen daher auf untypisierten Container
auf, und sind noch heute aktuell.
• Auch heute noch viel alter Java Code exisitiert und genutzt wird.
Von daher sollten Sie auch die Verwendung von untypisierten Containern kennen – in neuem
Code sollten Sie aber nur typisierte Container verwenden. Das folgende Beispiel zeigt wieder
die schon bekannte Nutzung der ArrayList, diesmal aber ohne Typisierung:
public class Kap_09_03_Bsp_07_UntypisierteContainer {
ArrayList al = new ArrayList();
al.add("Untypisierter");
al.add("Container");
al.add("-");
al.add("ohne");
al.add("Generics");
Iterator it = al.iterator();
while (it.hasNext()) {
String s = (String) it.next();
}
// (*)
// (**)
// (***)
}
}
Ausgabe
Untypisierter Container - ohne Generics
Bevor wir den obigen Code besprechen, erstmal ein wichtiger Hinweis: der obige Code erzeugt
sowohl im Java-Compiler „javac“ auf der Kommando-Zeile, als auch in den heutigen IDE's wie
der Eclipse Warnungen. Die beiden folgenden Abbildungen zeigen dies:
Abb. 9-3 : Warnungen des Java-Compilers wegen der Nutzung untypisierter Container
Seite 163 / 409
Abb. 9-4 : Warnungen der Eclipse 3.7.2 wegen der Nutzung untypisierter Container
Das freut mich – sowohl der Java-Compiler als auch die Eclipse sind meiner Meinung: Nutzen
Sie keine untypisierten Container.
Wenn Sie untypisierte Container aber doch nutzen müssen, dann unterdrücken Sie diese
Warnungen, damit die interessanten Warnungen nicht verdeckt werden. Dies können Sie z.B.
mit der seit Java 5 (JDK 1.5) vorhandenen Annotation „@SuppressWarnings“ machen42. Die
Eclipse kann sie automatisch als Quick-Fix für Sie einfügen. Der neue Quelltext sieht dann so
aus43:
public class Kap_09_03_Bsp_07_UntypisierteContainer {
Annotations sind ein weiteres neues Sprachmittel von Java 5 (JDK 1.5). Auch dies wird in
diesem Java-Tutorial leider nicht besprochen.
43 So (mit Annotation) finden Sie den Quelltext auch unter den fertigen Code-Beispielen auf
meiner Homepage http://www.wilkening-online.de.
42
Seite 164 / 409
@SuppressWarnings({ "rawtypes", "unchecked" })
al.add("-");
al.add("ohne");
al.add("Generics");
// (*)
}
// (**)
// (***)
}
}
Ausgabe
Untypisierter Container - ohne Generics
Sowohl der Container als auch der Iterator werden hier ohne Element-Typ angegeben – siehe
Zeile (*) und (**). Prinzipiell sieht der Code dadurch einfacher aus, aber er ist nur unsicherer:
• Mit „add“ können jetzt beliebige Objekte dem Container hinzugefügt werden – nicht nur
Strings.
• Und die Iterator-Funktion „next“ (Zeile (***)) gibt das Element jetzt nur als „Object“ (siehe
Kapitel 14.11) zurück – und dies muß nun explizit von uns gecastet werden (Angabe des
Zieltyps in runden Klammern vor dem Funktions-Aufruf). Enthält der Container andere
Elemente, so wird diese Zeile zur Laufzeit schief gehen und eine Class-Cast Exception
werfen.
Das folgende Beispiel zeigt das typische Problem untypisierter Container. Das Problem ist,
dass der Fehler nicht vom Compiler erkannt wird, sondern erst zur Laufzeit auftritt – und wenn
Sie Pech haben, erst beim Kunden.
public class Kap_09_03_Bsp_08_LaufzeitFehler {
@SuppressWarnings({ "rawtypes", "unchecked" })
al.add("-");
al.add(new StringBuilder());
// Achtung - kein String
al.add("Generics");
}
// Laufzeit-Fehler beim
// vierten Durchlauf
}
}
Ausgabe
Untypisierter Container –
Exception in thread "main" java.lang.ClassCastException:
Seite 165 / 409
java.lang.StringBuilder cannot be cast to java.lang.String
at Kap_09_03_Bsp_08_LaufzeitFehler.main
(Kap_09_03_Bsp_08_LaufzeitFehler.java:17)
Hinweis – zur Übung werden alle Container in den folgenden Container-Kapiteln sowohl
typisiert als auch untypisiert vorgestellt – bevorzugen Sie aber, wann immer möglich, die
typisierte Variante. In den restlichen Beispielen und Musterlösungen des Java-Tutorials
kommen daher dann auch nur noch die typisierten Varianten vor.
9.3.3 Container
Alle Container können hier nicht annähernd vorgestellt werden – dazu gibt zuviele in der Java
Bibliothek. Statt dessen beschränken wir uns hier auf die wichtigsten Container:
• java.util.ArrayList – Dynamisches Array (Kapitel 9.3.4)
• java.util.LinkedList – doppelt verkettete Liste (Kapitel 9.3.5)
• java.util.TreeSet – Sortierte Menge (Kapitel 9.3.6)
• java.util.HashSet – Unsortierte gehashte Menge (Kapitel 9.3.7)
• java.util.TreeMap – Sortierter assoziativer Container (Kapitel 9.3.8)
• java.util.HashMap – Unsortierter gehashter assoziativer Container (Kapitel 9.3.9)
Alle Container sind intern typlose Container, d.h. sie können alle Arten von Typen, die nicht
elementar sind, aufnehmen – d.h. alle Objekte. Dies hat manchmal Vorteile, führt aber in der
Praxis häufig zu Typ-Fehlern, die erst zur Laufzeit auffallen (vergleiche vorhergehendes Kapitel
9.3.2). Daher nutzen Sie bitte immer die typisierte Variante. In den folgenden Kapiteln werden
die Container der Vollständigkeit halber aber sowohl typisiert als auch untypisiert vorgestellt44.
Hinweis – um die Klassen ArrayList, TreeMap, Iterator, usw. benutzen zu können, müssen die
entsprechenden „import“ Anweisungen am Anfang des Quelltextes (nach der packageAnweisung und vor der Klassen-Definition) stehen – siehe Beispiele. Weitere Informationen zu
Packages und Imports finden Sie im Kapitel über Packages – siehe Kapitel 13.
Achtung – alle Java Container können nur Objekte aufnehmen, und keine elementaren
Datentypen. Einfache Bool-, Zeichen-, Integer- oder Fließkomma-Werte können Sie also nicht
direkt in Java Containern speichern. Sie müssen solche Werte in spezielle Wrapper-Klassen
einschliessen – siehe Kapitel 9.4. Seit dem JDK 1.5 geschieht dieses Wrappen automatisch,
dieses Java Feature nennt sich „Auto-Boxing“ – siehe Kapitel 9.4.1. Lassen Sie sich aber nicht
täuschen – Java Container können weiterhin keine elementaren Datentypen aufnehmen. Der
Effekt hat nichts an der internen Vorgehensweise und Implementierung geändert.
9.3.4 ArrayList
Die ArrayList ein dynamisches Array, d.h. ein Container bei dem die Elemente direkt
Während das Java-Tutorial genügend Raum für die typisierten Container hat, wird das
Sprachmittel der Generics im Java-Tutorial leider nicht eingeführt.
44
Seite 166 / 409
hintereinander im Speicher liegen und problemlos am Ende angefügt werden können.
Ausserdem ist er ein Beispiel für einen sequentiellen Container. Das ist ein Container, in dem
die Objekte sequentiell hintereinander liegen (z.B. in der Reihenfolge des Einfügens) und der
Container hierbei keinerlei Einfluss auf die Reihenfolge der Objekte nimmt.
todo
public class Appl {
al.add("Hallo");
al.add("wunderbarer");
al.add("Java");
al.add("Kurs");
System.out.println("Der Container enthaelt " + al.size() + " Objekte");
// Neue JDK 1.5 For-Schleife
for (String s : al) {
}
// Iterator-Loesung mit For-Schleife
for (Iterator<String> it = al.iterator(); it.hasNext();) {
String s = it.next();
}
// Iterator-Loesung mit While-Schleife
Iterator<String> it = al.iterator();
}
}
}
Ausgabe
Der Container enthaelt
Hallo wunderbarer Java
4 Objekte
Kurs
Kurs
Kurs
public class Appl {
@SuppressWarnings({ "unchecked", "rawtypes" })
al.add("Hallo");
al.add("wunderbarer");
al.add("Java");
al.add("Kurs");
System.out.println("Der Container enthaelt " + al.size() + " Objekte");
Seite 167 / 409
for (Object o : al) {
String s = (String) o;
}
for (Iterator it = al.iterator(); it.hasNext();) {
}
}
}
}
Ausgabe
4 Objekte
Kurs
Kurs
Kurs
9.3.5 LinkedList
todo
import java.util.LinkedList;
public class Appl {
LinkedList<String> ll = new LinkedList<>();
ll.add("Hallo");
ll.add("wunderbarer");
ll.add("Java");
ll.add("Kurs");
System.out.println("Der Container enthaelt " + ll.size() + " Objekte");
for (String s : ll) {
}
for (Iterator<String> it = ll.iterator(); it.hasNext();) {
}
Iterator<String> it = ll.iterator();
}
}
Seite 168 / 409
}
Ausgabe
4 Objekte
Kurs
Kurs
Kurs
import java.util.LinkedList;
public class Appl {
LinkedList ll = new LinkedList();
ll.add("Hallo");
ll.add("wunderbarer");
ll.add("Java");
ll.add("Kurs");
System.out.println("Der Container enthaelt " + ll.size() + " Objekte");
for (Object o : ll) {
}
for (Iterator it = ll.iterator(); it.hasNext();) {
}
Iterator it = ll.iterator();
}
}
}
Ausgabe
4 Objekte
Kurs
Kurs
Kurs
9.3.6 TreeSet
todo
import java.util.TreeSet;
public class Appl {
TreeSet<String> ts = new TreeSet< >();
ts.add("Detlef");
ts.add("Edgar");
Seite 169 / 409
ts.add("Silke");
ts.add("Martina");
ts.add("Aaron");
System.out.println("Der Container enthaelt " + ts.size() + " Objekte");
boolean exists = ts.contains("Detlef");
System.out.println("Detlef ist im TreeSet vorhanden: " + exists);
exists = ts.contains("Hans");
System.out.println("Hans ist im TreeSet vorhanden: " + exists);
for (String s : ts) {
}
for (Iterator<String> it = ts.iterator(); it.hasNext();) {
}
Iterator<String> it = ts.iterator();
}
}
}
Ausgabe
Der Container enthaelt 5 Objekte
Detlef ist im TreeSet vorhanden: true
Hans ist im TreeSet vorhanden: false
Aaron Detlef Edgar Martina Silke
public class Appl {
TreeSet ts = new TreeSet();
ts.add("Detlef");
ts.add("Edgar");
ts.add("Silke");
ts.add("Martina");
ts.add("Aaron");
System.out.println("Der Container enthaelt " + ts.size() + " Objekte");
boolean exists = ts.contains("Detlef");
System.out.println("Detlef ist im TreeSet vorhanden: " + exists);
exists = ts.contains("Hans");
System.out.println("Hans ist im TreeSet vorhanden: " + exists);
for (Object o : ts) {
}
Seite 170 / 409
for (Iterator it = ts.iterator(); it.hasNext();) {
}
Iterator it = ts.iterator();
}
}
}
Ausgabe
Detlef ist im TreeSet vorhanden: true
Hans ist im TreeSet vorhanden: false
9.3.7 HashSet
todo
import java.util.HashSet;
public class Appl {
HashSet<String> hs = new HashSet<>();
hs.add("Detlef");
hs.add("Edgar");
hs.add("Silke");
hs.add("Martina");
hs.add("Aaron");
System.out.println("Der Container enthaelt " + hs.size() + " Objekte");
boolean exists = hs.contains("Detlef");
System.out.println("Detlef ist im HashSet vorhanden: " + exists);
exists = hs.contains("Hans");
System.out.println("Hans ist im HashSet vorhanden: " + exists);
for (String s : hs) {
}
for (Iterator<String> it = hs.iterator(); it.hasNext();) {
}
Iterator<String> it = hs.iterator();
Seite 171 / 409
}
}
}
Mögliche Ausgabe (Die Reihenfolge im Hash-Container ist undefiniert)
Detlef ist im HashSet vorhanden: true
Hans ist im HashSet vorhanden: false
Aaron Martina Edgar Silke Detlef
import java.util.HashSet;
public class Appl {
HashSet hs = new HashSet();
hs.add("Detlef");
hs.add("Edgar");
hs.add("Silke");
hs.add("Martina");
hs.add("Aaron");
System.out.println("Der Container enthaelt " + hs.size() + " Objekte");
boolean exists = hs.contains("Detlef");
System.out.println("Detlef ist im HashSet vorhanden: " + exists);
exists = hs.contains("Hans");
System.out.println("Hans ist im HashSet vorhanden: " + exists);
for (Object o : hs) {
}
for (Iterator it = hs.iterator(); it.hasNext();) {
}
Iterator it = hs.iterator();
}
}
}
Detlef ist im HashSet vorhanden: true
Hans ist im HashSet vorhanden: false
Seite 172 / 409
9.3.8 TreeMap
todo
Bei einem assoziativen Container werden Schlüssel/Wert Paare gespeichert, d.h. dass
eigentliche Objekt wird über einen Schlüssel referenziert. Ein Beispiel dafür ist der
ausgewogene binäre rot-schwarz Baum „TreeMap“, der außerdem noch implizit die Werte nach
dem Schlüssel sortiert.
import java.util.Map.Entry;
import java.util.TreeMap;
public class Appl {
TreeMap<String, String> tm = new TreeMap<>();
tm.put("Detlef", "1234");
tm.put("Edgar", "5678");
tm.put("Silke", "248");
tm.put("Martina", "999");
tm.put("Aaron", "646");
System.out.println("Der Container enthaelt " + tm.size() + " Objekte");
String s = tm.get("Edgar");
if (s != null)
System.out.println("Edgar hat die Nummer: " + s);
else
System.out.println("Edgar ist nicht in der TreeMap");
s = tm.get("Hans");
if (s != null)
System.out.println("Hans hat die Nummer: " + s);
else
System.out.println("Hans ist nicht in der TreeMap");
for (Entry<String, String> e : tm.entrySet()) {
String key = e.getKey();
String val = e.getValue();
System.out.print(key + " => " + val + ", ");
}
for (Iterator<Entry<String, String>> it = tm.entrySet().iterator();
it.hasNext();) {
Entry<String, String> e = it.next();
}
Iterator<Entry<String, String>> it = tm.entrySet().iterator();
}
}
}
Seite 173 / 409
Ausgabe
Edgar hat die Nummer: 5678
Hans ist nicht in der TreeMap
Aaron => 646, Detlef => 1234, Edgar => 5678, Martina => 999, Silke => 248,
public class Appl {
TreeMap tm = new TreeMap();
tm.put("Detlef", "1234");
tm.put("Edgar", "5678");
tm.put("Silke", "248");
tm.put("Martina", "999");
tm.put("Aaron", "646");
System.out.println("Der Container enthaelt " + tm.size() + " Objekte");
String s = (String) tm.get("Edgar");
if (s != null)
else
System.out.println("Edgar ist nicht in der TreeMap");
s = (String) tm.get("Hans");
if (s != null)
else
System.out.println("Hans ist nicht in der TreeMap");
for (Object o : tm.entrySet()) {
Entry<String, String> e = (Entry<String, String>) o;
}
for (Iterator it = tm.entrySet().iterator(); it.hasNext();) {
Entry<String, String> e = (Entry<String, String>) it.next();
}
Iterator<Entry<String, String>> it = tm.entrySet().iterator();
}
}
}
Ausgabe
Hans ist
Aaron =>
Aaron =>
Aaron =>
Seite 174 / 409
nicht in der TreeMap
646, Detlef => 1234, Edgar => 5678, Martina => 999, Silke => 248,
9.3.9 HashMap
todo
import java.util.HashMap;
public class Appl {
HashMap<String, String> hm = new HashMap<>();
hm.put("Detlef", "1234");
hm.put("Edgar", "5678");
hm.put("Silke", "248");
hm.put("Martina", "999");
hm.put("Aaron", "646");
System.out.println("Der Container enthaelt " + hm.size() + " Objekte");
String s = hm.get("Edgar");
if (s != null)
else
System.out.println("Edgar ist nicht in der HashMap");
s = hm.get("Hans");
if (s != null)
else
System.out.println("Hans ist nicht in der HashMap");
for (Entry<String, String> e : hm.entrySet()) {
}
for (Iterator<Entry<String, String>> it = hm.entrySet().iterator();
it.hasNext();) {
}
Iterator<Entry<String, String>> it = hm.entrySet().iterator();
}
}
}
Seite 175 / 409
Hans ist nicht in der HashMap
Aaron => 646, Martina => 999, Edgar => 5678, Silke => 248, Detlef => 1234,
public class Appl {
HashMap hm = new HashMap();
hm.put("Detlef", "1234");
hm.put("Edgar", "5678");
hm.put("Silke", "248");
hm.put("Martina", "999");
hm.put("Aaron", "646");
System.out.println("Der Container enthaelt " + hm.size() + " Objekte");
String s = (String) hm.get("Edgar");
if (s != null)
else
System.out.println("Edgar ist nicht in der HashMap");
s = (String) hm.get("Hans");
if (s != null)
else
System.out.println("Hans ist nicht in der HashMap");
for (Object o : hm.entrySet()) {
Entry<String, String> e = (Entry<String, String>) o;
}
for (Iterator it = hm.entrySet().iterator(); it.hasNext();) {
}
Iterator it = hm.entrySet().iterator();
}
}
}
Hans ist nicht in der HashMap
Seite 176 / 409
9.3.10 Container-Vergleich
todo
9.4 Wrapper Klassen
In Java gibt es für alle elementaren Datentypen (inkl. „void“) sogenannte Wrapper-Klassen. Sie
haben drei Aufgaben:
• Sie dienen als Wrapper-Klassen für z.B. das Container-Framework – siehe Kapitel 9.3.3 und
das folgende Kapitel 9.4.1. Hinweis – die Wrapper-Objekte sind wie Strings unveränderbar
(„immutable“), d.h. die Werte in den Objekten lassen sich nicht ändern.
• Sie sammeln zu dem Typ gehörige allgemeine Funktionen in Form von Klassen-Funktionen.
Z.B. die Funktionen zum Konvertieren, wie „parseInt“ – siehe Kapitel 3.11.
• Sie werden bei Reflexion als Meta-Klassen eingesetzt – siehe Kapitel 24. Dies erklärt auch
die Wrapper-Klasse „Void“, die sonst keinen Sinn machen würde.
Elementarer Datentyp
boolean
char
byte
short
int
long
float
double
void
Wrapper-Klasse
Boolean
Character
Byte
Short
Integer
Long
Float
Double
Void
Bis auf die Wrapper-Klassen für „char“ und „int“ haben sie den gleichen Namen wie der
jeweilige elementare Datentyp den sie kapseln, beginnen aber groß45.
9.4.1 Auto-Boxing
In Kapitel 9.3.3 habe ich geschrieben, dass die Container-Klassen keine elementaren DatenTypen aufnehmen können, sondern nur Objekte. Das läßt uns keine Ruhe, und darum stellen
wir diese Aussage hier auf die Probe:
public class Kap_09_04_Bsp_01_AutoBoxing {
Warum heissen die Wrapper Klassen für „char“ und „int“ nicht wie die elementaren
Datentypen, sondern anders? Ich weiß es nicht, vermute aber historische Gründe.
45
Seite 177 / 409
al.add(1);
// "1" ist ein "int"
al.add(6);
al.add(23);
al.add(42);
System.out.println("Die Liste enthaelt " + al.size() + " ints");
int n = (int) it.next();
}
// Cast in "int"
}
}
Ausgabe
Die Liste enthaelt 4 ints
1 6 23 42
Funktioniert doch! Was erzählt der denn da? Nun, wenn Sie Kapitel 9.3.3 vollständig in Ruhe
lesen, dann finden Sie noch eine weitere Aussage: „Elementare Datentypen müssen in
speziellen Wrapper-Klassen (siehe Kapitel 9.4) gewrappt werden. Seit dem JDK 1.5 kann
dieses Wrappen implizit geschehen (Auto-Boxing) – dies hat aber nichts an der internen
Vorgehensweise und Implementierung geändert“.
Hinweis – das Beispiel arbeitet mit einem untypisierten Container, da eine Typisierung auf „int“
zu einem Compiler-Fehler geführt hätte, und wir mit der korrekten Typisierung auf „Integer“ die
„Überraschung“ viel kleiner gewesen wäre.
Intern passiert also das im folgenden Beispiel explizit programmierte – nur das Sie es seit dem
JDK 1.5 nicht sehen, da der Compiler es automatisch für Sie macht. Aber Sie dürfen es
natürlich immer noch selber machen, bzw. bei einem älteren JDK (vor 1.5) müssen Sie es
sogar.
public class Appl {
ArrayList<Integer> al = new ArrayList<>();
al.add(Integer.valueOf(1));
System.out.println("Die Liste enthaelt " + al.size() + " Integer");
Iterator<Integer> it = al.iterator();
Integer i = (Integer) it.next();
int n = i.intValue();
}
}
}
Seite 178 / 409
Ausgabe
Die Liste enthaelt 4 ints
1 6 23 42
• Beim Einfügen in den Container wird der elementare Datentyp (hier „int“) in eine WrapperKlasse (hier „Integer“) gewrappt („geboxt“). Beim Auto-Boxing geschieht dies automatisch.
• Möglicherweise haben Sie beim Einfügen „new Integer(x)“ statt „Integer.valueOf(x)“ erwartet
– immerhin müssen alle Objekte mit „new“ erzeugt werden. Im Prinzip würde „new
Integer(x)“ hier auch funktionieren, aber die Klassen-Funktion „valueOf“ gibt auch ein
entsprechendes Java Integer-Objekt zurück – kann aber schneller sein. Für genaue Details
schauen Sie bitte in die Java Referenz-Dokumentation.
• Beim Wandeln des Integer-Objekts in einen „int“ muß die Element-Funktion „intValue"
genutzt werden. Beim Auto-Boxing geschieht auch dies automatisch.
• Die ArrayList ist in diesem Beispiel auf „Integer“ typisiert – das ist die passende Typisierung
um via Auto-Boxing „int“s aufzunehmen.
Intern bleibt es aber so, dass Java Container keine elementaren Datentypen aufnehmen
können. Aber seit dem JDK 1.5 hilft uns die Sprache hier ganz automatisch.
9.4.2 Hierarchie
Alle numerischen Wrapper Klassen sind von der Klasse „java.lang.Number“ abgeleitet.
Abb. 9-5 : Vererbungs-Hierarchie der Wrapper-Klassen
9.5 Zufalls-Zahlen
Um Zufalls-Zahlen zu erzeugen gibt es im Package „java.util“ die Klasse „Random“. Man
erzeugt sich ein Objekt der Klasse „Random“ und kann sich von diesem Objekt Zufalls-Zahlen
erzeugen lassen. Es existieren Element-Funktionen zur Erzeugung von Zufalls-Zahlen für die
wichtigsten Typen („boolean“, „int“, „long“, „float“ und „double“) und einige weitere
Anwendungsfälle wie z.B. Byte-Arrays.
Die einfachste Element-Funktion ist „nextInt“, die einen Int-Paramter bekommt und dann
Zufalls-Zahlen zwischen „0“ (inkl.) und dem übergebenden Argument (exkl.) erzeugt. Im
folgenden Beispiel also Zahlen von „0-9“.
import java.util.Random;
public class Kap_09_05_Bsp_01_ZufallsZahlen {
Random rnd = new Random();
for (int i=0; i<20; i++) {
System.out.print(rnd.nextInt(10) + " ");
}
}
}
Seite 179 / 409
mögliche Ausgabe
2 2 5 3 7 0 3 6 4 5 0 7 4 0 3 8 8 7 6 8
Hinweis – vergessen Sie nicht den notwendigen Import von „java.util.Random“.
Benötigen Sie Zufalls-Zahlen in einem anderen Bereich (d.h. nicht von „0“ (inkl.) und dem
übergebenden Argument (exkl.)), dann verschieben Sie die Zahlen einfach durch eine Addition
oder Subtraktion. Um z.B. einen Würfel mit den Zahlen von „1-6“ zu simulieren, benötigen Sie
Zahlen von „0-5“ die Sie durch eine Addition mit „1“ in den gewünschten Bereich verschieben.
public class Kap_09_05_Bsp_02_Wuerfel {
for (int i = 0; i < 10; i++) {
System.out.print(rnd.nextInt(6) + 1 + " ");
}
}
}
mögliche Ausgabe
3 4 1 6 5 3 3 2 6 2
Hinweise:
• Benötigt man reproduzierbare Zufalls-Zahlen, so kann man ein Random-Objekt auch mit
einem Seed-Parameter konstruieren, oder bei einem vorhandenen Random-Objekt den
Seed mit der Funktion „setSeed“ setzen.
• Double-Zufalls-Zahlen kann man sich auch mit der Klassen-Funktion „random“ der Klasse
„java.lang.Math“ erzeugen lassen. Die genauen Unterschiede zwischen dieser Funktion und
„nextDouble“ aus „Random“ finden Sie in der Java Referenz-Dokumentation.
9.6 Datum und Uhrzeit
Für Datum und Uhrzeit Funktionen stehen u.a. folgende Klassen zur Verfügung:
• java.util.Date
• java.util.Calendar
• java.text.DateFormat
• java.text.SimpleDateFormat
Wird einfach ein Date Objekt erzeugt ("new Date()“), so enthält dieses Objekt das aktuelle
Datum und die aktuelle Zeit. Die Klassen „DateFormat“ und „SimpleDateFormat“ bieten
Methoden zur Formatierung der Wandlung des Datums in einen String.
import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class Kap_09_06_Bsp_01_Datum {
Date now = new Date();
Seite 180 / 409
DateFormat df = DateFormat.getDateInstance();
System.out.println(df.format(now));
df = DateFormat.getDateInstance(DateFormat.FULL);
df = DateFormat.getTimeInstance();
df = DateFormat.getTimeInstance(DateFormat.FULL);
df = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
df = new SimpleDateFormat("d.M.yyyy");
}
}
mögliche Ausgabe
06.05.2012
Sonntag, 6. Mai 2012
01:05:39
01:05 Uhr MESZ
Sonntag, 6. Mai 2012 01:05 Uhr MESZ
6.5.2012
• Die Definition eines Ausgabe-Formats mit „DateFormat“ arbeitet defaultmäßig mit der
aktuellen Länderkennung - dies läßt sich natürlich ändern.
• „DateFormat“ kann auch Strings parsen – Element-Funktion „parse“.
• Mit der Klasse „Calendar“ kann Datums- und Uhrzeit-Arithmetik mit Date-Objekten
durchgeführt werden, und es können viele weitere Informationen gewonnen werden.
• Achtung – viele Funktion in „Date“ sind „deprecated“ und durch Funktionen der Klasse
„Calendar“ ersetzt worden46.
Hinweis – mit dem JDK 1.8 ist eine neue Date-Time Bibliothek in Java eingeführt worden.
Diese ist viel durchdachter und leistungsfähiger als die alte hier kurz angesprochene Bibliothek.
In realen Projekten sollten Sie besser diese nutzen.
9.7 Datei- und Verzeichnis-Handling
Die Klasse „java.io.File“ repräsentiert eine Datei oder ein Verzeichnis, und sie bietet viele
Funktionen um Dateien und Verzeichnisse zu manipulieren oder Informationen über sie zu
erlangen. Hier ein kleiner Auszug aus der Schnittstelle der Klasse „File“:
File(String fullName)
Erzeugt ein File Objekt für das Element des Datei-Systems mit
dem entsprechenden Namen. Der Name ist vollständig inkl.
Pfad.
Deprecated Klassen oder Funktionen sind veraltet bzw. weisen Probleme auf, und sollten
daher nicht mehr benutzt werden. Normalerweise bietet Java in diesen Fällen neue und
bessere Elemente an.
46
File(String path, String name)
Seite 181 / 409
Erzeugt ein File Objekt für das Element des Datei-Systems mit
dem entsprechenden Namen. Der Name wird hierbei getrennt in
Pfad und eigentlichem Namen übergeben.
Der Vorteil ist hier, dass der Benutzer sich nicht um den Trenner
im String kümmern muß, der ja plattform-spezifisch ist.
boolean exists()
Gibt zurück, ob die Datei oder das Verzeichnis existiert.
String getAbsolutePath()
Gibt den Namen (inkl. vollständigem absolutem Pfad) des
Verzeichnisses oder der Datei zurück.
boolean isDirectory()
Gibt zurück, ob das File-Objekt ein Verzeichnis referenziert.
boolean isFile()
Gibt zurück, ob das File-Objekt eine Datei referenziert.
long length()
Gibt bei einer Datei die Größe der referenzierten Datei zurück.
String[ ] list()
Gibt bei einem Verzeichnis die Namen der Elemente im
Verzeichnis (Verzeichnisse und Dateien) als Array von Strings
zurück.
Als erstes Beispiel ein kleines Programm, dass überprüft ob der auf der Kommandozeile
übergebene Name im Datei-System existiert, und ob es eine Datei oder ein Verzeichnis ist.
Wenn es eine Datei ist, so wird noch die Größe der Datei ausgegeben.
import java.io.File;
public class Kap_09_07_Bsp_01_File {
System.out.println("Fehler - es wird ein Datei-Name erwartet");
return;
}
String name = args[0];
File file = new File(name);
if (!file.exists()) {
System.out.println("Element \"" + name + "\" existiert nicht");
return;
}
if (file.isFile()) {
String len = "" + file.length();
System.out.println("\"" + name + "\" hat " + len + " Bytes");
return;
}
if (file.isDirectory()) {
System.out.println("\"" + name + "\" ist ein Verzeichnis");
return;
}
System.out.println("Element \"" + name + "\" -> unbekannten Typ");
}
}
Mögliche Ausgabe
>java Appl
Fehler - es wird ein Datei-Name erwartet
Seite 182 / 409
Mögliche Ausgabe
>java Appl java
Element "java" existiert nicht
Mögliche Ausgabe
>java Appl Kap_09_07_Bsp_01_File.class
"Kap_09_07_Bsp_01_File.class" hat 1414 Bytes
Mögliche Ausgabe
>java Appl .
"." ist ein Verzeichnis
Hinweise
• Für die Verwendung von plattform-unabhängigen Datei-Namen wird in Java die URI
Konvention gewählt, für die es eine eigene Klasse „java.net.URI“ gibt.
• Lesen und Schreiben von Dateien geschieht in Java mit Streams, die mit einem File-Objekt
verbunden sind – siehe Kapitel 23.
9.7.1 Rekursive Datei-Suche
Ein typisches Problem, dass wir nun lösen können, ist die tiefe Suche im Dateisystem z.B. nach
einer Datei mit einem bestimmten Namen. Bevor Sie sich an dieses Unternehmen wagen,
empfehle ich Ihnen, sich sinnvolle Testdaten zu erzeugen – sprich eine kleine Beispiel
Verzeichnis-Struktur. Ich habe es leider erlebt, dass Anfänger ihr Programm zum Test auf ihr
Root-Dateisystem wie z.B. „C:\“ losgelassen haben, und sich dann gewundert haben dass ihr
Programm ewig läuft, Fehler meldet oder scheinbar einfach nur den Rechner lahm legt. Ist
doch auch kein Wunder, oder? Bei unseren heutigen Plattengrößen gibt es da ziemlich viele
Verzeichnisse zu durchsuchen und Datei-Namen zu vergleichen, dass der Rechner gut belastet
ist. Und mit ziemlicher Sicherheit trifft das Programm unterwegs auf Verzeichnisse, für die es
keine Rechte hat – und schon regnet es Exceptions, und damit können wir noch gar nicht gut
umgehen (das lernen wir ja erst in Kapitel 22).
Lange Rede, kurzer Sinn – machen Sie sich eine kleine Test-Daten-Struktur auf Ihrer Platte.
Ich habe das gemacht, unter „C:\JavaDateiSystemBeispiele“ – und so sieht sie bei mir aus.
Suchen wollen wir später die drei Dateien mit dem Namen „find.txt“.
Test-Verzeichnis-Struktur
C:\
└
JavaDateiSystemBeispiele
└
verzeichnis1
│ └
verzeichnis3
│ │ └
verzeichnis4
│ │ │ └
find.txt
│ │ │ └
search.dat
│ │ │ └
test.txt
│ │ └
test.txt
│ └
verzeichnis5
│ │ └
find.txt
│ │ └
test.txt
│ └
daten.dat
│ └
test.txt
└
verzeichnis2
Seite 183 / 409
│ └
find.txt
│ └
test.txt
└
search.dat
└
test.txt
Hinweis – bitte ignorieren Sie im Augenblick die blau markierten Dateien „search.dat“ und
„daten.dat“ – wir benötigen Sie später in den Aufgaben 9.8.7 und 9.8.8.
Damit können wir nun loslegen. Der erste Schritt ist einfach. Wir laufen einfach über das SuchVerzeichnis und geben alles aus, was wir finden – getrennt nach Verzeichnissen und Dateien.
Einzige Besonderheit: wir geben den Namen vollständig aus, und setzen ihn nicht selber
zusammen, sondern lassen ihn uns vom File-Objekt geben – Zeile (*). Hintergrund hierfür sind
die unterschiedlichen Datei-Trenner unter z.B. Windows (Backslash „\“) und Linux (Slash „/“),
um die wir uns sonst selbst kümmern müßten.
public class Kap_09_07_Bsp_02_FileSucheRekursivStep1 {
File path = new File("C:\\JavaDateiSystemBeispiele");
String[] filenames = path.list();
for (String filename : filenames) {
File file = new File(path, filename);
String fullfilename = file.getAbsolutePath();
System.out.println("Verz.: " + fullfilename);
} else if (file.isFile()) {
System.out.println("Datei: " + fullfilename);
}
}
}
// (*)
}
Mögliche Ausgabe (andere Reihenfolge möglich – ist nicht definiert)
Datei: C:\JavaDateiSystemBeispiele\search.dat
Datei: C:\JavaDateiSystemBeispiele\test.txt
Verz.: C:\JavaDateiSystemBeispiele\verzeichnis1
Verz.: C:\JavaDateiSystemBeispiele\verzeichnis2
Der nächste Schritt ist minimal – wir vergleichen den gefundenen Datei-Namen mit dem
Namen, den wir suchen – und damit wir was finden, suchen wir erstmal nach „test.txt“. Wenn
die Datei stimmt, dann geben wir sie mit komplettem Pfad aus. Und bei Verzeichnissen machen
wir erstmal nix.
String searchfile = "test.txt";
File path = new File("C:\\JavaDateiSystemBeispiele");
// Im Augenblick machen wir hier noch nichts
if (file.getName().equals(searchfile)) {
System.out.println("-> " + fullfilename);
Seite 184 / 409
}
}
}
}
}
Ausgabe
-> C:\JavaDateiSystemBeispiele\test.txt
Kommen wir nun zum Fall, dass das Verzeichnis selber wieder ein Verzeichnis enthält. In
diesem Fall müssen wir nur für dieses Verzeichnis das Gleiche machen: alle Elemente
durchlaufen, Dateien vergleichen, bei Verzeichnissen wieder das Gleiche. Das klingt nach
Rekursion, wie wir sie in Kapitel 8.7 kennen gelernt haben. Wichtig – dazu müssen wir die
Funktionalität in eine Funktion auslagern – sonst können wir sie nicht rekursiv aufrufen. Und
mehr machen wir in diesem Schritt auch nicht.
String searchpath = "C:\\JavaDateiSystemBeispiele";
String searchfile = "test.txt";
searchFile(searchpath, searchfile);
}
public static void searchFile(String searchpath, String searchfile) {
File path = new File(searchpath);
// Im Augenblick machen wir hier noch nichts
}
}
}
}
}
Ausgabe
-> C:\JavaDateiSystemBeispiele\test.txt
Nachdem unsere Verzeichnis-Durchforste-Funktionalität nun in einer Funktion ist, können wir
sie jetzt auch aufrufen – und diesmal auch mit dem richtigen Datei-Namen.
String searchfile = "find.txt";
}
Seite 185 / 409
searchFile(fullfilename, searchfile);
}
}
}
}
}
-> C:\JavaDateiSystemBeispiele\verzeichnis1\verzeichnis3\verzeichnis4\find.txt
-> C:\JavaDateiSystemBeispiele\verzeichnis1\verzeichnis5\find.txt
-> C:\JavaDateiSystemBeispiele\verzeichnis2\find.txt
Wow – alles funktioniert. So einfach und elegant ist Rekursion. Damit unser Quelltext noch
etwas mehr nach richtigem Programm aussieht, integrieren wir noch ein paar Dinge:
• Programm-Name
• Rückmeldung, wo gesucht wird
• Rückmeldung, wonach gesucht wird
• Und eine Sicherheits-Abfrage, falls jemand „searchFile“ nicht mit einem Verzeichnis als
ersten Parameter aufruft.
public class Kap_09_07_Bsp_06_FileSucheRekursiv {
System.out.println("Rekursive Datei-Suche mit java.io.File");
System.out.println("Suche in: " + searchpath);
System.out.println("Nach: " + searchfile);
}
if (!path.isDirectory()) {
System.out.println("Fehler - kein Verzeichnis");
return;
}
File file = new File(searchpath, filename);
searchFile(fullfilename, searchfile);
if (searchfile.equals(filename)) {
}
}
}
}
}
Rekursive Datei-Suche mit java.io.File
Seite 186 / 409
Suche in: c:\aaa
Nach: find.txt
-> C:\\JavaDateiSystemBeispiele\verzeichnis1\verzeichnis5\find.txt
Hinweise:
• In den Aufgaben 9.8.7 und 9.8.8 werden wir dieses Programm zur rekursiven Datei-Suche
um weitere Fähigkeiten ergänzen.
• Im nächsten Kapitel wird die rekursive Datei-Suche mit dem JDK 1.7 Package „java.nio.file“
implementiert.
9.7.2 Rekursive Datei-Suche mit „java.nio.file“
Seit dem JDK 1.4 gibt es das Package New-IO „java.nio“ in Java. In Java 7 wurde es um das
Unter-Package „java.nio.file“ ergänzt. Hierdrin sind viele Klassen mit stark erweiterten
Möglichkeiten gegenüber „java.io.file“ enthalten – über Kopieren von Dateien und
Verzeichnissen bis hin zu Themen wie User-Rechte auf Datei-Systeme. So leistungsfähig das
neue „java.nio.file“ Package auch ist – die Nutzung ist für Einsteiger oft schwer und komplex.
Von daher nutzen wir hier im Java-Tutorial nur die File-Klasse – später sollten Sie sich aber
ruhig mal an „java.nio.file“ erinnern, falls Sie aufwändigere Aufgaben im Kontext Datei-System
lösen müssen.
Als Beispiel, aber ohne jede Erklärung, nochmal die rekursive Datei-Suche – nun aber mit
„java.nio.file“.
import
import
import
import
import
import
java.io.File;
java.io.IOException;
java.nio.file.DirectoryStream;
java.nio.file.Files;
java.nio.file.Path;
java.nio.file.Paths;
public class Kap_09_07_Bsp_03_FileSucheRekursivMitNiofile {
System.out.println("Rekursive Datei-Suche mit java.nio.file");
System.out.println("Suche in: " + searchpath);
System.out.println("Nach: " + searchfile);
try {
Path path = Paths.get(searchpath);
searchFile(path, searchfile);
} catch (IOException e) {
System.out.println("Fehler: " + e.getMessage());
}
}
public static void searchFile(Path path, String searchfile)
throws IOException {
DirectoryStream<Path> dirStream = Files.newDirectoryStream(path);
for (Path entry : dirStream) {
File file = entry.toFile();
searchFile(entry, searchfile);
Seite 187 / 409
System.out.println("-> " + file.getAbsolutePath());
}
}
}
}
}
Ausgabe (unter Annahme der obigen Datei-Struktur)
Rekursive Datei-Suche mit java.nio.file
Suche in: c:\aaa
Nach: find.txt
9.8 Aufgaben
9.8.1 Aufgabe „String-Analyse“
Schreiben Sie ein Programm das eine Zeile einliest, und ausgibt wie oft welches Zeichen in der
Zeile vorkommt. Erzeugen Sie eine Ausgabe der Zeichen in der Reihenfolge ihres ersten
Vorkommens im Eingabetext – weitere Vorkommen der Zeichen werden bei der Ausgabe
ignoriert.
Mögliche Ein- und Ausgabe:
Eingabe: Hallo Welt: 123332
'H': 1
'a': 1
'l': 3
'o': 1
' ': 2
'W': 1
'e': 1
't': 1
':': 1
'1': 1
'2': 2
'3': 3
Implementieren Sie zwei Lösungen:
• Die erste Lösung soll ohne Container auskommen und nur mit den Klassen String,
StringBuffer und/oder StringBuilder implementiert werden.
• Im Gegensatz zur ersten Lösung sollen Sie hier Container nutzen – und erreichen damit
(hoffentlich) eine viel einfachere Lösung.
9.8.2 Aufgabe „Hallo <Person>“
Schreiben Sie ein Programm, dass einen kompletten Namen einliest, und diesen Namen mit
Sternchen und Leerzeichen umrandet als Anrede ausgibt. Bsp: der eingebene Name ist „Detlef
Wilkening“, dann soll folgende Ausgabe erzeugt werden:
Seite 188 / 409
Name: Detlef Wilkening
***************************
*
*
* Hallo Detlef Wilkening! *
*
*
***************************
9.8.3 Aufgabe „Hallo <Personen>“
Schreiben Sie ein Programm ähnlich Aufgabe 9.8.2, dass hier aber beliebig viele komplette
Namen einliest. Wird eine leere Eingabe gemacht, so gelten damit alle Namen als eingegeben.
Danach sollen alles diese Namen mit Anrede und umrandet mit Sternchen und Leerzeichen
ausgegeben werden – die Reihenfolge soll hierbei der Eingabe entsprechen. Die Umrandung
soll sich am längsten Namen orientieren. Bsp: die eingegebenen Namen seien „Max“,
„Johannes Wolfgang“ und „Werner“, dann soll folgende Ausgabe erzeugt werden:
Name: Max
Name: Johannes Wolfgang
Name: Werner
Name:
****************************
*
*
* Hallo Max!
*
* Hallo Johannes Wolfgang! *
* Hallo Werner!
*
*
*
****************************
9.8.4 Aufgabe „Lesbare Zahlen 2“
Eine ähnliche Aufgabe wie 7.9.3: schreiben Sie ein Programm, dass Benutzer-Eingaben von
Ziffern von 1 bis 9 als lesbaren Text ausgibt. Die Eingabe einer beliebigen anderen Zahl oder
von etwas anderem sollen das Programm beenden.
Bitte geben Sie eine Ziffer ein: 2
-> zwei
Bitte geben Sie eine Ziffer ein: 7
-> sieben
Bitte geben Sie eine Ziffer ein: x
Ende
Als Unterschied zu Aufgabe 7.9.3 sollen Sie hier keine Kontrollstruktur (switch oder if) zur
Abbildung der Zahlen auf Texte verwenden, sondern einen Container. Machen Sie sich klar,
dass diese Lösung kürzer, performanter, und auch noch besser lesbar ist.
Die gleiche Aufgabe finden Sie noch mal in Kap. 10.8.1 – dort soll sie mit Arrays gelöst werden,
was in diesem Fall noch ein bisschen effizienter ist.
Seite 189 / 409
9.8.5 Aufgabe „Lottozahlen“
Schreiben Sie ein Lotto-Programm, d.h. ein Programm dass sechs Zufallszahlen zwischen 1
und 49 inkl. sortiert ausgibt. Aber Achtung – keine Zufallszahl darf mehrfach vorkommen.
9.8.6 Aufgabe „Telefonbuch“
Schreiben Sie ein erstes ganz ganz einfaches Telefonbuch47.
Das Telefonbuch soll Namen und Telefonnummern speichern – am Anfang begnügen wir uns
mit einer Nummer pro Name, und es soll keine Name doppelt vorkommen (d.h. jeder Name im
Telefonbuch ist ein Unikat). Die Telefon-Nummern sind keine Zahlen, sondern Texte, damit z.B.
Leerzeichen oder ein Slash „/“ für eine lesbarere Formatierung möglich sind.
Die Einträge im Telefonbuch sollen im Augenblick noch fest im Programm stehen, d.h. es
können im Augenblick keine Einträge hinzugefügt, gelöscht, oder editiert werden.
Der Benutzer kann entweder einen der Befehle „end“ bzw. „list“ oder einen Namen eingeben.
• Bei „end“ soll das Programm beendet werden.
• Bei „list“ sollen alle Einträge im Telefonbuch (zuerst Name, dann Nummer, eine Zeile pro
Eintrag – sortiert nach Namen (nicht lexikalisch sortiert, sondern nach Zeichenkodierung)
ausgegeben werden.
• Alle anderen Benutzer-Eingaben werden als Namen interpretiert, und im Telefonbuch
gesucht. Wird der Name gefunden, so wird die Nummer ausgegeben. Wird der Name nicht
gefunden, so wird eine entsprechende Meldung ausgegeben. Achtung – der Name muss
exakt übereinstimmen, und es werden auch Groß- und Klein-Schreibung unterschieden.
Nach der Bearbeitung des Befehls „list“ oder eines Namens kann der Benutzer die nächste
Eingabe machen.
Telefonbuch
Eingabe: list
6
-
Eintraege:
Bernd => 0555 / 55 55 55
Detlef => 0123 / 12 21 1
Dietmar => 0321 / 888 222 99
Edgar => 0111 / 11 11 1
Edmund => 0222 / 33 22 11
Karl => 0111 / 11 22 33
Wir werden dieses Telefonbuch in weiteren Aufgaben mit mehr Wissen zu einer kleinen
Kontaktdaten Verwaltung ausbauen, aber hier und jetzt fangen wir erstmal klein an. Für später
siehe die Aufgaben 11.7, 11.8, 14.19, 14.16.4, todo oder todo.
47
Seite 190 / 409
Eingabe: Max
Name "Max" ist nicht im Telefonbuch vorhanden.
Eingabe: Detlef
Detlef => 0123 / 12 21 1
Eingabe: end
Programmende
9.8.7 Aufgabe „Platten-Platz Verbrauch“
In Kapitel 9.7.1 haben wir eine einfache Form der rekursiven Datei-Suche kennengelernt. Nun
sollen Sie das Programm etwas erweitern.
• Ihr Programm soll berechnen, wieviel Platten-Platz alle Dateien eines Typs (einer Extension)
innerhalb eines Verzeichnisses verbrauchen.
• Zusätzlich soll der Benutzer das Verzeichnis und die Such-Extension (ohne „.“) auf der
Kommando-Zeile eingeben können.
• Die Verzeichnis-Eingabe soll sich so oft wiederholen, bis der Benutzer ein gültiges
Verzeichnis eingegeben hat.
• Wird keine Extension eingegeben, wird der Platten-Platz Verbrauch aller Dateien im
Verzeichnis berechnet.
• Vergleichbar zur rekursiven Datei-Suche in Kapitel 9.7.1 ignorieren wir Probleme, die sich
aus User-Rechten und fehlenden Zugriffs-Rechten resultieren.
Beispiele, unter der Berücksichtigung der Datei-System-Struktur aus Kapitel 9.7.1, und
entsprechender Datei-Größen:
Platten-Platz Verbrauch
Geben Sie bitte das Verzeichnis ein: C:\JavaDateiSystemBeispiele
Geben Sie bitte die Extension ein: dat
Gesamtverbrauch: 3472 Bytes
Geben Sie bitte die Extension ein: txt
Geben Sie bitte die Extension ein:
Seite 191 / 409
Geben Sie bitte das Verzeichnis ein: kein-verzeichnis
"kein-verzeichnis" ist kein Verzeichnis
Geben Sie bitte das Verzeichnis ein: immer noch nicht
"immer noch nicht" ist kein Verzeichnis
Geben Sie bitte die Extension ein: dat
9.8.8 Aufgabe „Datei-Suche“
Die nächste Aufgabe erweitert die einfache Datei-Suche aus Kapitel 9.7.1.
• Ihr Programm soll alle Dateien innerhalb eines Verzeichnisses suchen, die einem von
mehreren Namen entsprechen.
• Der Benutzer soll das Such-Verzeichnis und die Such-Datei-Namen auf der KommandoZeile eingeben können.
• Die Such-Verzeichnis-Eingabe soll sich so oft wiederholen, bis der Benutzer ein gültiges
Verzeichnis eingegeben hat.
• Die Such-Datei-Namen-Eingabe soll sich so oft wiederholen, bis der Benutzer einen
Leerstring eingibt. Alle Namen bis dahin gelten als zu Suchen.
• Die gefundenen Dateien mit ihren Pfaden sollen sortiert nach den Datei-Namen ausgeben
werden. Jeder Ausgabe-Block soll mit dem Datei-Namen beginnen, und danach eine
eingerückte Aufzählung der Verzeichnisse (inkl. Datei-Namen).
• Wurde keine Datei zu einem Datei-Such-Namen gefunden, so wird nur der Datei-SuchName ausgegeben.
• Vergleichbar zur rekursiven Datei-Suche in Kapitel 9.7.1 ignorieren wir Probleme, die sich
aus User-Rechten und fehlenden Zugriffs-Rechten resultieren.
Beispiele, unter der Berücksichtigung der Datei-System-Struktur aus Kapitel 9.7.1:
Datei-Suche
----------Geben
Geben
Geben
Geben
Sie
Sie
Sie
Sie
bitte
bitte
bitte
bitte
das
die
die
die
Such-Verzeichnis ein: C:\JavaDateiSystemBeispiele
Such-Namen ein: find.txt
Such-Namen ein: search.dat
Such-Namen ein:
find.txt
search.dat
-> C:\JavaDateiSystemBeispiele\search.dat
-> C:\JavaDateiSystemBeispiele\verzeichnis1\verzeichnis3\verzeichnis4\search.dat
Datei-Suche
Seite 192 / 409
----------Geben Sie bitte das Such-Verzeichnis ein: kein Verzeichnis
"kein Verzeichnis" ist kein Verzeichnis
Geben
Geben
Geben
Geben
Geben
Sie
Sie
Sie
Sie
Sie
bitte
bitte
bitte
bitte
bitte
das
die
die
die
die
Such-Verzeichnis ein: C:\JavaDateiSystemBeispiele
Such-Namen ein: search.dat
Such-Namen ein: search.txt
Such-Namen ein: search.png
Such-Namen ein:
search.dat
-> C:\JavaDateiSystemBeispiele\search.dat
-> C:\JavaDateiSystemBeispiele\verzeichnis1\verzeichnis3\verzeichnis4\search.dat
search.png
search.txt
9.9 Lsg. zu Aufgabe „String-Analyse“ – Kap. 9.8.1
9.9.1 Erste Lösung mit String, StringBuffer bzw. StringBuilder
Als erstes müssen wir einen String von der Kommandozeile einlesen. Da dies – dank Reader
und Exceptions – kein Einzeiler ist, lagern wir dies in eine Funktion aus. Im Fehlerfall gibt die
Funktion einen Leerstring zurück – damit können wir im Augenblick gut leben. So könnte die
Funktion aussehen48.
public static String readLine() {
String in = "";
try {
in = reader.readLine();
}
return in;
}
Dann kommt die eigentlich Analyse des Strings. Dazu müssen wir über den String laufen, und
jeden Buchstaben auf die Anzahl der Vorkommen überprüfen – der Pseudocode sieht im ersten
Schritt also so aus. Achtung, dieser Algorithmus ist noch fehlerhaft.
// Vorsicht - noch fehlerhafter Algorithmus
for-each zeichen in string
laufe ueber string und zaehle anzahl dieses zeichens
zeichen und anzahl ausgeben
In Java-Code könnte das so aussehen:
// Vorsicht - noch fehlerhafter Algorithmus
for (int i=0; i<in.length(); i++) {
char c = in.charAt(i);
int count = 0;
Die Funktion ist übrigens so gut, daß wir sie in den nächsten Aufgaben auch immer wieder
ohne lange Erklärung wiederbenutzen werden.
48
Seite 193 / 409
for (int j=0; j<in.length(); j++) {
if (in.charAt(j)==c) {
count++;
}
}
System.out.println("'" + c + "': " + count);
}
Ausgabe bei in = "aba"
'a': 2
'b': 1
'a': 2
Das Problem ist, dass wir jetzt die mehrfach vorkommenden Zeichen auch mehrfach zählen
und ausgeben – und das ist nicht gewollt.
Wir müssen also die Zeichen markieren, die wir schon gezählt haben. Da wir diese Lösung
ohne Container implementieren wollen, müssen wir im String vermerken, wann ein Zeichen
schon behandelt worden ist. Dazu brauchen wir ein Zeichen, dass im String nicht auftauchen
kann – also als eindeutiges „Schon-Behandelt-Zeichen“ dienen kann.
Im Rahmen unserer Aufgabe gibt es ein solches Zeichen: der Zeilenumbruch ‚\n‘. Dieses
Zeichen kann nicht im String vorhanden sein, da wir den String von der Tastatur einlesen, und
die Return-Taste die Eingabe abschliesst.
Damit wir auf dieses Marker-Zeichen gut lesbar im Code einsetzen können, benutzen wir es
nicht direkt im Quelltext, sondern nutzen eine lokale Konstante, d.h. eine lokale Variable mit
dem Modifier „final“ – siehe Kapitel 8.3 und auch Kapitel 7.13.1. Damit wird aus unserem Code
von oben:
final char ok = '\n';
if (c==ok) continue;
// (*)
int count = 0;
for (int j=0; j<in.length(); j++) {
count++;
in.setCharAt(j, ok);
// (**)
}
}
}
Neben der lokalen Konstanten hat sich der Code an zwei Stellen geändert:
• Ist das zu analysierende Zeichen unser Marker-Zeichen, so dürfen wir nicht analysieren, und
setzen die Schleife direkt fort – Zeile (*).
• Finden wir während der Analyse im String das zu suchende Zeichen, dann müssen wir es
durch das Marker-Zeichen ersetzen – Zeile (**).
Damit funktioniert unser Programm, und wir könnten uns zufrieden der nächsten Aufgabe
widmen. Aber so ganz optimal ist unser Programm noch nicht. Sobald wir ein neu zu zählendes
Zeichen finden, wissen wir ja, dass es im String vorher nicht vorhanden sein kann – ansonsten
hätten wir es ja schon gezählt. Also brauchen wir den Anfang des Strings für das Zählen nicht
Seite 194 / 409
zu berücksichtigen. Wenn wir mit dem Zählwert „count=1“ starten, brauchen wir erst mit dem
Zeichen „j+1“ für das Zählen zu starten. Da eine For-Schleife kopfgesteuert ist, und daher auch
0-mal durchlaufen werden kann (siehe Kapitel 7.3), funktioniert dies auch problemlos für das
letzte Zeichen der Schleife.
int count = 1;
for (int j=i+1; j<in.length(); j++) {
count++;
}
}
}
Aber seien Sie sich darüber im klaren – auch mit unserer Optimierung ist dies kein schneller
Algorithmus. Im Prinzip muss für jedes Zeichen im String der String einmal vollständig
durchlaufen werden. Man nennt dies einen quadratischen Algorithmus, da er eine quadratische
Zeit-Komplexität hat. Eine Verdopplung der String-Länge führt zu einer Vervierfachung der
notwendigen Zeit, eine Verdreifachung der String-Länge zu einer Verneunfachung der
notwendigen Zeit. Besser wird die Lösung mit Container im nächsten Kapitel sein.
Mit Klasse und Main-Funktion ergibt das alles zusammen folgenden Code:
public class Appl {
String in = "";
try {
}
return in;
}
System.out.print("Eingabe: ");
StringBuilder in = new StringBuilder(readLine());
int count = 1;
for (int j=i+1; j<in.length(); j++) {
count++;
}
}
}
}
Seite 195 / 409
}
Ausgabe
Eingabe: Hallo Waldilal
'H': 1
'a': 3
'l': 5
'o': 1
' ': 1
'W': 1
'd': 1
'i': 1
9.9.2 Zweite Lösung mit Container
import
import
import
import
import
java.io.BufferedReader;
java.io.InputStreamReader;
java.util.ArrayList;
java.util.Iterator;
java.util.TreeMap;
public class Appl {
String in = "";
try {
}
return in;
}
System.out.print("Eingabe: ");
String in = readLine();
ArrayList<Character> order = new ArrayList<>();
TreeMap<Character, Integer> map = new TreeMap<>();
for (int i = 0; i < in.length(); i++) {
Integer count = map.get(c);
if (count == null) {
map.put(c, 1);
order.add(c);
} else {
map.put(c, ++count);
}
}
for (char c : order) {
int count = map.get(c);
}
}
}
Ausgabe
Eingabe: Hallo Waldilal
'H': 1
'a': 3
'l': 5
'o':
' ':
'W':
'd':
'i':
Seite 196 / 409
1
1
1
1
1
9.10 Lsg. zu Aufgabe „Hallo <Person>“ – Kap. 9.8.2
public class Appl {
String in = "";
try {
}
return in;
}
public static String string(int n, char c) {
StringBuilder erg = new StringBuilder(n);
for (int i=0; i<n; i++) {
erg.append(c);
}
return erg.toString();
}
System.out.print("Bitte geben Sie Ihren Namen ein: ");
String name = readLine();
int len = name.length() + 11;
System.out.println(string(len, '*'));
System.out.println('*' + string(len-2, ' ') + '*');
System.out.println("* Hallo " + name + "! *");
System.out.println('*' + string(len-2, ' ') + '*');
System.out.println(string(len, '*'));
}
}
Ausgabe
Bitte geben Sie Ihren Namen ein: Detlef Wilkening
***************************
*
*
* Hallo Detlef Wilkening! *
*
*
***************************
9.11 Lsg. zu Aufgabe „Hallo <Personen>“ – Kap. 9.8.3
Seite 197 / 409
public class Appl {
String in = "";
try {
}
return in;
}
public static String string(int n, char c) {
StringBuilder erg = new StringBuilder(n);
for (int i=0; i<n; i++) {
erg.append(c);
}
return erg.toString();
}
ArrayList<String> list = new ArrayList<>();
int maxLen = 0;
while (true) {
System.out.print("Bitte geben Sie die Namen ein: ");
String name = readLine();
if (name.length()==0) break;
list.add(name);
if (name.length()>maxLen) {
maxLen = name.length();
}
}
int len = maxLen + 11;
String stars = string(len, '*');
String spaces = string(len - 2, ' ');
System.out.println(stars);
System.out.println('*' + spaces + '*');
for (String s : list) {
int slen = s.length();
String rest = string(maxLen - slen + 1, ' ');
System.out.println("* Hallo " + s + '!' + rest + '*');
}
System.out.println('*' + spaces + '*');
System.out.println(stars);
}
}
Ausgabe
Bitte geben Sie die Namen
***********************
*
*
* Hallo Max!
*
* Hallo Wolf-Guenter! *
* Hallo Tassilo!
*
*
*
***********************
ein: Max
ein: Wolf-Guenter
ein: Tassilo
ein:
Seite 198 / 409
9.12 Lsg. zu Aufgabe „Lesbare Zahlen 2“ – Kap. 9.8.4
9.12.1 Lösung 1: Doch mit Switch-Anweisung
public class Appl {
String in = "";
try {
}
return in;
}
while (true) {
System.out.print("Bitte geben Sie eine Ziffer ein: ");
int number;
try {
number = Integer.parseInt(in);
if (number<1 || number>9) break;
break;
}
switch (number) {
case 1:
System.out.println("->
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
}
eins");
zwei");
drei");
vier");
fuenf");
sechs");
sieben");
acht");
neun");
}
System.out.println("Ende");
}
Seite 199 / 409
}
9.12.2 Lösung 2: Mit TreeMap
public class Appl {
String in = "";
try {
}
return in;
}
// HashMap ist sehr gut, aber nicht optimal – noch besser ist Loesung 3
HashMap<Integer, String> numbers = new HashMap<>();
numbers.put(0, "null");
numbers.put(1, "eins");
numbers.put(2, "zwei");
numbers.put(3, "drei");
numbers.put(4, "vier");
numbers.put(5, "fuenf");
numbers.put(6, "sechs");
numbers.put(7, "sieben");
numbers.put(8, "acht");
numbers.put(9, "neun");
while (true) {
int number;
try {
if (number < 1 || number > 9) {
break;
}
break;
}
System.out.println(numbers.get(number));
}
}
}
9.12.3 Lösung 3: Mit ArrayList
Seite 200 / 409
public class Appl {
String in = "";
try {
}
return in;
}
final ArrayList<String> numbers = new ArrayList<>();
numbers.add("null");
numbers.add("eins");
numbers.add("zwei");
numbers.add("drei");
numbers.add("vier");
numbers.add("fuenf");
numbers.add("sechs");
numbers.add("sieben");
numbers.add("acht");
numbers.add("neun");
while (true) {
int number;
try {
if (number < 0 || number > 9) {
break;
}
break;
}
System.out.println(numbers.get(number));
}
}
}
9.13 Lsg. zu Aufgabe „Lottozahlen“ – Kap. 9.8.5
public class Appl {
TreeSet<Integer> numbers = new TreeSet<>();
while (numbers.size() < 6) {
numbers.add(rnd.nextInt(49) + 1);
}
for (Integer i : numbers) {
}
}
Seite 201 / 409
}
Mögliche Ausgabe
7 13 28 33 34 44
Sehr sehr wichtiger Hinweis – wenn Sie mit den Zahlen dieses Programms Lotto spielen und
gewinnen, dann müssen Sie mich mit 40% am Gewinn beteiligen. Benachrichtigen Sie mich
bitte per Mail „[email protected]“.
9.14 Lsg. zu Aufgabe „Telefonbuch“ – Kap. 9.8.6
import
import
import
import
java.util.Map.Entry;
java.util.TreeMap;
public class Appl {
String in = "";
try {
}
return in;
}
System.out.println("Telefonbuch");
TreeMap<String, String> items = new TreeMap<>();
items.put("Detlef", "0123 / 12 21 1");
items.put("Edgar", "0111 / 11 11 1");
items.put("Bernd", "0555 / 55 55 55");
items.put("Edmund", "0222 / 33 22 11");
items.put("Karl", "0111 / 11 22 33");
items.put("Dietmar", "0321 / 888 222 99");
while (true) {
System.out.print("\nEingabe: ");
if (in.equals("end"))
break;
if (in.equals("list")) {
System.out.println(items.size() + " Eintraege:");
for (Entry<String, String> e : items.entrySet()) {
System.out.println("- " + e.getKey() + " : " + e.getValue());
}
continue;
}
String number = items.get(in);
if (number == null) {
System.out.println(
"Name \"" + in + "\" ist nicht im Telefonbuch vorhanden.");
continue;
}
Seite 202 / 409
System.out.println(in + " => " + number);
}
System.out.println("Programmende");
}
}
9.15 Lsg. zu Aufgabe „Platten-Platz Verbrauch“ – Kap. 9.8.7
public class Kap_09_15_Lsg_PlattenPlatzVerbrauch {
System.out.println("Platten-Platz Verbrauch\n");
File dir = readDirectory();
String ext = readSearchExtension();
long size = calcFileSizes(dir, ext);
System.out.println("\nGesamtverbrauch: " + size + " Bytes");
}
String in = "";
try {
}
return in;
}
public static File readDirectory() {
while (true) {
System.out.print("Geben Sie bitte das Verzeichnis ein: ");
File dir = new File(in);
if (dir.isDirectory()) {
return dir;
}
System.out.println("\"" + dir + "\" ist kein Verzeichnis\n");
}
}
public static String readSearchExtension() {
System.out.print("Geben Sie bitte die Extension ein: ");
if (in.isEmpty()) {
return in;
}
return "." + in;
}
public static long calcFileSizes(File dir, String extension) {
long res = 0;
String[] filenames = dir.list();
File file = new File(dir, filename);
res += calcFileSizes(file, extension);
Seite 203 / 409
if (file.getName().endsWith(extension)) {
res += file.length();
}
}
}
return res;
}
}
9.16 Lsg. zu Aufgabe „Datei-Suche“ – Kap. 9.8.8
import
import
import
import
import
import
java.io.File;
java.util.Map.Entry;
java.util.TreeMap;
public class Kap_09_16_Lsg_DateiSuche {
System.out.println("Datei-Suche\n-----------\n");
File dir = readDirectory();
TreeMap<String, ArrayList<String>> files = readSearchFileNames();
searchFile(dir, files);
for (Entry<String, ArrayList<String>> entry : files.entrySet()) {
System.out.println(entry.getKey());
for (String ffn : entry.getValue()) {
System.out.println("-> " + ffn);
}
}
}
String in = "";
try {
}
return in;
}
public static File readDirectory() {
while (true) {
System.out.print("Geben Sie bitte das Such-Verzeichnis ein: ");
File dir = new File(in);
if (dir.isDirectory()) {
return dir;
}
System.out.println("\"" + dir + "\" ist kein Verzeichnis\n");
}
}
public static TreeMap<String, ArrayList<String>> readSearchFileNames() {
TreeMap<String, ArrayList<String>> res = new TreeMap<>();
while (true) {
System.out.print("Geben Sie bitte die Such-Namen ein: ");
if (in.isEmpty()) {
Seite 204 / 409
return res;
}
res.put(in, new ArrayList<String>());
}
}
public static void
searchFile(File dir, TreeMap<String, ArrayList<String>> files) {
String[] filenames = dir.list();
File file = new File(dir, filename);
searchFile(file, files);
findFile(file, files);
}
}
}
public static void
findFile(File file, TreeMap<String, ArrayList<String>> files) {
for (Entry<String, ArrayList<String>> entry : files.entrySet()) {
if (file.getName().equals(entry.getKey())) {
entry.getValue().add(file.getAbsolutePath());
}
}
}
}
10 Arrays
Arrays sind schon kurz in Kapitel 3.5 eingeführt worden. Hier wollen wir sie jetzt detailierter
besprechen.
•
•
•
•
•
•
•
Arrays sind in Java Objekte, d.h. sie stellen keinen „elementaren“ Daten-Typ dar.
Array-Variablen sind Referenz-Variablen (siehe 5.4.2).
Auf die Array-Elemente kann sowohl lesend als auch schreibend mit dem Operator [int]
zugegriffen werden.
Array-Zugriffe mit dem Operator [int] sind 0-basiert.
Zugriffe auf nicht existente Elemente lösen die Exception „IndexOutOfBoundsException“ aus
– siehe Kapitel 10.6.
Arrays haben ein Attribut „length”, dass die Anzahl an Elementen im Array enthält.
Arrays sind von der Klasse „Object“ abgeleitet – siehe Kapitel 14.11.
10.1 Deklaration
Arrays können in Java auf zwei Arten deklariert werden: Die eckigen Klammern, die ein Array
als solches identifizieren, können sowohl am Typ als als auch am Bezeichner stehen. Die
typische Syntax in Java ist die erste Variante.
int[] a1;
int a2[];
// Typische Java Syntax
// Auch moeglich, sieht man aber selten
Initialisierung
Seite 205 / 409
Es gibt zwei Arten, Arrays zu initialisieren:
1. Literale Initailisierung
Bei der literalen Initialisierung wird hinter der Deklaration in geschweiften Klammern eine Liste
der Initialwerte aufgeführt. Der Compiler erzeugt implizit ein Array entsprechender Größe und
weist die Werte dem Array zu.
Es darf dabei keine Größe in den eckigen Klammern der Variablen-Deklaration angegeben
werden, auch nicht die Richtige.
int[] a = { 1, 2, 3, 4 };
boolean[] b = { true, false, true };
double[2] d = { 1.4, 3.1 };
// Compiler-Error – Groessenangabe nicht
erlaubt
Das Array a bekommt hier automatisch die Größe 4, das Array b die Größe 3 zugewiesen.
Ausserdem werden die Arrays mit den aufgeführten Werten initialisiert.
Die literale Initialisierung darf nur bei der Deklaration einer Array-Variablen benutzt werden. Für
spätere Neubesetzung muss die dynamische Initialisierung benutzt werden.
int[] a = { 1, 2, 3, 4 };
...
a = { 1, 2, 6, 8 };
// Compiler-Error
// Hier ist nur die dynamische Initialisierung
erlaubt
2. Dynamische Initialisierung
Bei der dynamischen Initialisierung legt man selber das Array mit new, Typname und
gewünschter Größe in eckigen Klammern an – das Array wird dabei mit den Defaultwerten des
Typ‘s initialisiert.
int[] a = new int[6];
boolean[] b = new boolean[2];
Hierbei wird mit new ein entsprechender Speicherplatz reserviert (a - Größe 6 / b - Größe 2)
und die Array-Elemente werden mit den Default-Werten der jeweiligen Datentypen gefüllt.
Auch bei der dynamischen Initialisierung können die Initialisierungswerte in Form einer Liste
angegeben werden. Dabei darf keine Größenangabe in den eckigen Klammern stehen und die
Liste muss direkt hinter den eckigen Klammern folgen. Die Größe des Arrays bestimmt der
Compiler implizit aus der Anzahl an Werten in der Liste.
int[] a = new int[] { 2, 5, 9 };
boolean[] b = new boolean[2] { true, false }; // Compiler-Error - wegen
Groessenangabe
10.2 Arrays haben ein Attribut: length
Array-Objekte haben keine Funktion und genau ein Attribut, das nur lesenden Zugriff erlaubt:
‚length‘ liefert die Anzahl an Elementen im Array zurück.
Seite 206 / 409
int[] a = { 1, 2, 3, 4 };
System.out.println(a.length);
Ausgabe
4
10.3 Arrays durchlaufen
Seit Java 5 (JDK 1.5) gibt es einen neuen Schleifen-Typ für Container und Arrays, der schon in
Kapitel 7.4 kurz vorgestellt wurde. Wollen Sie einfach nur über das gesamte Array laufen, dann
nutzen Sie diesen Typ. Alternativ können Sie natürlich ein normale For-Schleife mit SchleifenZähler nutzen.
int[] a = { 1, 2, 3, 4 };
System.out.println("Neue Schleife: ");
for (int n : a) {
}
System.out.println("Alte Schleife: ");
for (int i=0; i<a.length; i++) {
System.out.print(a[i] + " ");
}
Ausgabe
Neue Schleife: 1 2 3 4
Alte Schleife: 1 2 3 4
10.4 Arrays sind Referenzen
Auch Arrays sind keine elementaren Datentypen, d.h. unterliegen auch Array-Variablen der
Referenz-Semantik.
int[] a = { 1, 2, 3, 4 };
int[] b = a;
a[2] = 42;
for (int i : a) {
System.out.print(i + "
}
for (int i : b) {
System.out.print(i + "
}
Ausgabe
1 2 42
1 2 42
");
");
4
4
Im Beispiel zeigen beide Array-Variablen auf das gleiche Array. Der schreibende Zugriff auf das
dritte Element von a (a[2] = 42;) ändert damit auch das Array b.
Seite 207 / 409
1.
Array int[]
a:
=>
b:
=>
1
2.
2
3
4
Array int[]
a:
=>
b:
=>
1
2
42
4
Abb. 10-1 : Referenz-Semantik bei Arrays
10.5 Arrays können mehrdimensional sein
Natürlich können Arrays auch mehrdimensional sein. Sie sind kein spezieller Datentyp, sondern
werden als Array-von-Arrays implementiert. Die Deklaration der Variablen enthält dann für jede
Dimension ein Klammen-Paar, die Initialisierungsliste besteht dann aus einer Liste von Listen.
Der Zugriff erfolgt über eine entsprechende Anzahl von Index-Operatoren [].
int[][] a = { {1,2}, {3, 4}, {5,6} };
for (int[] aa : a) {
for (int i : aa) {
}
}
Ausgabe
1 2
3 4
5 6
Achtung – seien Sie sich darüber im klaren, dass Java die Elemente eines mehrdimensionales
Arrays nicht bündig in einem Block im Speicher ablegt, sondern es ein echtes Array-aus-Arrays
ist.
Array: int[][]
4
Array: int[]
3
>
2
Array: int[]
Array: int[]
1
>
=>
>
a:
5
6
Abb. 10-2 : Speicher-Layout eines mehrdimensionalen Arrays
Arrays müssen nicht unbedingt rechteckig sein
Seite 208 / 409
Aus dem oben gesagten folgt natürlich auch, dass Arrays nicht unbedingt rechteckig sein
müssen.
int[][] a = { {1}, {2, 3}, {4, 5, 6, 7} };
for (int[] aa : a) {
for (int i : aa) {
}
}
Ausgabe
1
2 3
4 5 6 7
Array: int[][]
3
Array: int[]
2
>
Array: int[]
Array: int[]
1
>
=>
>
a:
4
5
6
7
Abb. 10-3 : Speicher-Layout eines nicht-rechteckigen Arrays
10.6 Fehlerhafter Index
Der Zugriff auf ein nicht existentes Objekt führt java-typisch zu einer Exception
(„java.lang.IndexOutOfBoundsException“). Zugriffe mit fehlerhaftem Index führen also nicht zu
potentiellen Problemen wie in manchen anderen Programmier-Sprachen49, sondern werden
sauber gemeldet.
int[] array = { 1, 2 };
array[0] = 0;
// Okay
array[1] = 0;
// Okay
array[2] = 0;
// Laufzeit-Fehler => wirft Exception
array[-1] = 0;
// Laufzeit-Fehler => wirft Exception
10.7 Vergleiche
Werden zwei Arrays mit dem Operator „==“ verglichen, so wird nur die Identität verglichen, da
es sich um Referenz-Objekte handelt – siehe Kapitel 5.4.2. Auch die Benutzung der von
„Object“ geerbten Element-Funktion „equals“ ändert daran nichts, da das Default-Verhalten der
Vergleich auf Identität ist – siehe Kapitel todo – und die Elementfunktion für Arrays nicht
überschrieben worden ist.
49
Wie z.B. C oder C++.
Seite 209 / 409
Für Werte-Vergleiche auf Arrays muss die Funktion „java.util.Arrays.equals“ benutzt werden.
10.8 Aufgaben
10.8.1 Aufgabe „Lesbare Zahlen 3“
Die gleiche Aufgabe wie 9.8.4: schreiben Sie ein Programm, dass Benutzer-Eingaben von
Zahlen von 1 bis 9 als lesbaren Text ausgibt. Die Eingabe einer beliebigen anderen Zahl oder
eine Fehleingabe soll das Programm beenden.
Bitte geben Sie eine Zahl ein: 2
-> zwei
Bitte geben Sie eine Zahl ein: 7
-> sieben
Bitte geben Sie eine Zahl ein: x
-> Ende
Als Unterschied zu Aufgabe 9.8.4 sollen Sie hier keinen Container, sondern ein Array
verwenden. Machen Sie sich klar, dass diese Lösung vielleicht noch effizienter ist.
10.9 Lsg. zu Aufgabe „Lesbare Zahlen 3“ – Kap. 10.8.1
public class Appl {
String in = "";
try {
}
catch (Exception x) {
}
return in;
}
final String[] numbers = {
"eins", "zwei", "drei", "vier", "fuenf",
"sechs", "sieben", "acht", "neun"
};
while (true) {
System.out.print("Bitte geben Sie eine Zahl ein: ");
int number;
try {
if (number<1 || number>9) break;
Seite 210 / 409
break;
}
System.out.println("-> " + numbers[number-1]);
}
System.out.print("-> Ende");
}
}
11 Klassen
11.1 Motivation
Um nicht-triviale Probleme in den Griff zu bekommen, muss man die Probleme in kleine
überschaubare Einheiten zerlegen (Stichwort „teile und herrsche“), die möglichst unabhängig
von einander sein sollten (Stichwort „Entkopplung“). Das heißt, man muss in seinem Programm
Abstraktionen einziehen, die Komplexität verbergen (am besten so kapseln, dass gar keine
Zugriff auf die Interna möglich ist – Stichwort „Information-Hiding“) und auf eine einfache Art
Funktionalität zur Verfügung stellen. Ein Beispiel dafür sind z.B. die Container-Klassen von
Java, die die gesamten für die Speicherung und Verwaltung von Objekten notwendigen Daten,
Techniken und Mechanismen verbergen.
In unserem normalen Leben arbeiten wir doch auch so. Wenn sie z.B. ein Haus bauen, dann
werden weder sie, noch der Architekt, und wohl auch nicht der Maurer hierbei die
Eigenschaften von Elementarteilchen wie Quarks oder Bosonen berücksichtigen. Jeder arbeitet
mit den Abstraktions-Ebenen, die für sein Problem angepaßt sind. Der eine denkt halt in
Elementarteilchen, dem nächsten passen Atom-Kerne und Elekronenhüllen. Wieder andere
denken in Molekülen, noch andere z.B. in Werkstoffeigenschaften. Ein Ingenieur wechselt dann
sich in die Sichtweise von – tief unten – Schrauben und Zahnrädern. Weiter oben wird dann
z.B. in Getriebe oder Motoren gedacht. Usw, usw. . Jeder arbeitet halt mit den AbstraktionsEbenen, die für sein Problem angepaßt sind. Und alles darunter interessiert ihn nicht, bzw. wird
aktiv versucht auszublenden, damit das Problem überschaubar bleibt.
Abb. 11-1 : Das Schlüsselwort heißt „Abstraktion“
Einer der Hauptgedanken der Objekt-Orientierung ist daher die Idee, abgeschlossene
gekapselte Einheiten programmieren und anbieten zu können, bei denen der Benutzer sich
keine Gedanken mehr über das Innenleben machen muss, sondern sie einfach über ihre
Schnittstelle benutzt.
Abb. 11-2 : Objekt-Kapselung und Benutzung über die Schnittstelle
Damit ist das Ziel klar – es muß möglich sein:
• abgeschlossene gekapselte Einheiten zu definieren,
Seite 211 / 409
• diesen Einheiten eine Schnittstelle zu geben,
• sie sollte einfach zu implementieren sein, und
• einfach zu benutzen sein.
Dies wird in Java – wie in allen OO Sprachen – über Klassen und Objekte erreicht. Hierbei sind
• Klassen eine allgemeine Beschreibung einer bestimmten Art Objekte. Eine Klasse Auto
beschreibt ganz allgemein alle Autos, sowohl meine alte Karre, einen neues Familienauto,
als auch das Cabrio meines Kollegen. Allen diesen Autos ist gemein, dass sie Autos sind,
und sich durch gemeinsame Fähigkeiten und Merkmale wie Grösse, Leistung, Verbrauch,
Farbe, usw. auszeichnen.
• Objekte dagegen sind ein konkretes Exemplar (Instanz) einer Klasse. Daher meine alte
Karre ist ein konkretes Exemplar der Klasse Auto.
Abb. 11-3 : Klassen und Objekte am Beispiel von Autos
11.2 Klassen-Entwurf
Bevor sie eine eigene Klasse entwerfen, sollten sie sich immer einige Gedanken über den Sinn,
die Repräsentation und die Implementation der Klasse machen.
1. Überlegung - Art der Objekte:
• Was für Objekte soll die Klasse repräsentieren?
2. Überlegung - Schnittstelle:
• Was soll mit den Objekten der Klasse machbar sein?
• Wie sollen sich die Objekte verhalten?
• Welche Schnittstelle benötigt die Klasse dafür?
3. Überlegung - Vererbung:
• Gibt es Klassen, die eine vergleichbare Schnittstelle haben?
• Gibt es Klassen, die ähnliche Funktionalität aufweist?
• Gibt es Klassen, die diese Objekte in allgemeinerer Form repräsentieren?
• Kann eine abstrakte Schnittstelle konkrete Klassen verbergen?
Diese Frage können wir uns erst stellen, wenn wir Vererbung kennen – siehe Kapitel todo. Ich
habe sie hier aber aufgeführt, damit sie hier alle relevanten Fragen auf einen Schlag sehen.
4. Überlegung - Implementierung:
• Wie implementiere ich diese Funktionalitäten?
• Welchen inneren Aufbau wähle ich dafür?
Bemerkung – die zweite und vierte Überlegung beruhen auf den gleichen Fragen, aber einmal
aus der Sicht eines Benutzers der Klassen, und das andere Mal aus der Sicht des
Seite 212 / 409
Implementierers gestellt.
Bemerkung – in einem größeren Kontext betrachtet würde man die Überlegungen 1 bis 3 als
Analyse und die Überlegungen 2 bis 4 als Design betrachten.
11.3 Beispiel
11.3.1 Wurm-Programm
Vielleicht kennen sie kleine Gimmick-Programme, die z.B. gerne als Bildschirmschoner
eingesetzt werden. Hier konkret geht es um ein Programm, dass einen Wurm über den
Bildschirm krabbeln läßt. Dabei soll der Wurm, der den Bildschirm rechts verläßt links wieder
hinein krabbeln, und umgekehrt. Verläßt der Wurm den Bildschirm oben, so soll er unten
wieder hinein krabbeln, und umgekehrt. Für den Wurm bildet der Bildschirm also eine
unendliche Fläche, bei der die jeweils gegenüberliegenden Ränder aufeinander abgebildet
werden.
Da wir zur Zeit noch kein GUI programmieren können, und auch sonst noch ziemlich viel JavaWerkzeug fehlt, beschränken wir uns hier mit einem ganz kleinen und sehr stark abgespeckten
Wurm Programm:
• Statt mit einem GUI Fenster arbeiten wir nur mit der Konsole.
• Statt eines Wurms wird hier nur ein Zeichen gezeichnet – der Stern ‚*‘.
• Statt der Bildschirmbreite setzen wir eine feste Breite von 40 Zeichen an.
• Statt mit einer x/y-Koordinate wird hier nur x variiert.
• Statt den alten Wurm zu löschen, geben wir eine neue Zeile aus.
Übrig bleibt also nur ein Programm mit ungefähr folgender Ausgabe:
*
*
*
*
...
*
*
*
*
*
...
Alles in allem ist das neue Programm nicht mehr sehr eindrucksvoll, aber es hat noch
genügend Probleme für den Anfang:
• Um die Ausgabe einzurücken, definieren wir eine Hilfs-Funktion „spaces“, die einen
StringBuffer der entsprechenden Größe zurückgibt. Die Funktion ist mit ihrer Schleife nicht
besonders elegant, aber manchmal muss man so programmieren.
• Damit die Ausgabe nicht nur so dahin-fliegt, müssen wir das Programm verlangsamen. Nach
jeder Ausgabe legen wir es daher für 30 ms schlafen. Auch hierfür gibt es eine extra
Funktion „sleep“, die für uns den „Thread.sleep“ Aufruf kapselt, und den notwendigen
try/catch-Block übernimmt.
Seite 213 / 409
• Statt einem festen Programm-Ende oder z.B. einer Tastatur-Abfrage aufs Programm-Ende
arbeiten wir mit einer Endlos-Schleife. Das Programm muss daher auf der Konsole mit
„Strg+C“ oder in der IDE abgebrochen werden.
public class Appl {
public static StringBuffer spaces(int len) {
StringBuffer sb = new StringBuffer(len);
for (int i=0; i<len; i++) {
sb.append(' ');
}
return sb;
}
public static void sleep() {
try {
Thread.sleep(30);
}
}
System.out.println("Ein Stern laeuft ueber den Bildschirm");
int pos = 0;
while (true) {
System.out.println(spaces(pos) + "*");
sleep();
++pos;
if (pos>40) {
pos=0;
}
}
}
}
Das eigentliche Programm reduziert sich so auf eine Initalisierung und eine Endlos-Schleife mit
6 Zeilen:
int pos = 0;
while (true) {
System.out.println(spaces(pos)+"*");
sleep();
++pos;
if (pos>40) {
pos=0;
}
}
// (*)
// (**)
// (***)
An welcher Stelle könnte dieses Programm durch eine weitere Abstraktion vereinfacht werden?
Immerhin die Hälfte des Programms beschäftigt sich mit dem Positions-Zähler „pos“. Statt
eines „int“ Elements wird hier ja ein sogenannter Ring-Zähler benötigt, und der größte Teil der
Programmlogik beschäftigt sich jetzt mit dem Problem einen Ring-Zähler zu simulieren.
Ausserdem ist nicht schön, dass sich die zwei wichtigsten Parameter des Ring-Zählers an
mehreren Stellen wiederfinden: Start- und End-Wert (*), (**) und (***).
11.3.2 Überlegung 1
Damit ist Überlegung 1 „Art der Objekte“ beantwortet: wir wollen einen Ring-Zähler
Seite 214 / 409
implementieren, d.h. eine Art Integer-Variable die bei Erreichen eines bestimmten Wertes
wieder auf einen Startwert springt.
Bemerkung – mancher wird nun denken: „Was soll das?“ Die Schleife ist doch übersichtlich,
das Problem klar, die Lösung einfach – wozu hier Aufwand investieren? Aber diese Einstellung
greift zu kurz, denn:
• Nicht immer sind alle Code-Vorkommen eines Ring-Zählers so klar und nah beieinander
lokalisiert. Nicht selten finden sich diese Stellen in realen Programmen verteilt in mehreren
Stellen wieder. Und in solchen Fällen ist dem Leser nicht immer klar, warum hier solcher
Code steht. Wir haben es hier halt mit einem sehr einfachen Beispiel-Programm zu tun.
• Und selbst wenn der Code und die Lösung einfach sind: man kann auch einfache Sachen
vergessen oder falsch machen.
• Ein fertiger Ring-Zähler – wir reden hier jetzt von der zweiten Verwendung der Klasse, nicht
von ihrer ersten – ist ein fertiger Ring-Zähler. Er ist getestet und im Einsatz und läuft – es ist
ein fertiger Ring-Zähler. Man kann ihn nehmen und benutzen. Das nennt man
Wiederverwendung und sollte ein Ziel jeder Software-Entwicklung sein.
• Und warum müssen Abstraktions-Ebenen einen großen Abstand haben, und die Einheiten
dazwischen kompliziert damit sie sich lohnen? Sind sie groß und kompliziert, so sind sie
wahrscheinlich auch fehlerhaft. Sind sie groß und kompliziert, so passen sie sicher nicht
beim nächsten Problem.
• Und bedenken sie – es ist unser erstes Beispiel. Das ändert nichts daran, dass ein RingZähler als wiederverwendbare Einheit (Klasse) Sinn macht. Aber es gibt sicher auch noch
komplexere Klassen.
Die Überlegung 2 zielt dann auf die Schnittstelle der Klasse:
• Welche Schnittstelle benötigt die Klasse dafür?
Hier ist die Lösung einfach:
• Bei der Erzeugung des Ring-Zählers müssen Start- und Grenzwert definiert werden können.
• Der aktuelle Wert muss abfragbar sein.
• Der Wert muss incrementiert werden können, wobei eine Überschreitung des Grenzwerts
implizit wieder zum Startwert führen muss.
Programm-technisch könnte dies aus der Sicht des Benutzers so aussehen:
RingCounter rc = new RingCounter(0, 40);
while (true) {
System.out.println(spaces(rc.get()) + "*");
sleep();
rc.add();
}
6 Zeilen statt 9, und außerdem noch der Vorteil eine if-Anweisung los geworden zu sein. Und
Seite 215 / 409
jede Kontrollstruktur bringt halt Komplexität und potentielle Fehlerquellen mit sich.
Da wir noch keine Vererbung kennen, ist diese Überlegung zur Zeit noch nicht relevant.
So bleibt noch die Frage nach der Implementierung, d.h. wie implementiere ich das?
11.4 Klassen-Implementierung
11.4.1 Definition
Zuerst muss eine Klasse definiert werden.
Syntax Kassen-Definition
[Modifizierer] class klassenname {
...
}
Achtung – eine Klassen-Definition hat immer ihre eigene Datei, die genauso wie die Klasse mit
der Extension ‘java’ heissen muss. Dies ist ein gern gemachter Anfänger-Fehler. Wenn sich
ihre Klasse also nicht compilieren lässt - überprüfen sie erstmal die Namen.
Die für Klassen möglichen Modifizierer werden später aufgeführt und erklärt. Im Augenblick
sollten sie hier immer nur ‘public’ verwenden.
Beispiele:
public class RingCounter {
...
}
public class Person {
...
}
Innerhalb einer Klasse können Konstruktoren, Element-Funktionen, Klassen-Funktionen,
Attribute, innere Klassen, und einige weitere Elemente vorhanden sein. Eine Klasse kann aber
auch einfach leer sein.
11.4.2 Benutzung
Ist eine Klasse definiert, so kann sie im gleichen Package einfach unter ihrem Typ-Namen
benutzt werden. Achtung – Variablen der Klasse sind immer Referenz-Variablen. Und erzeugt
werden Objekte der Klasse mit dem „new“ Operator.
Seite 216 / 409
public class A {
}
public class Appl {
A a = new A();
f(a);
a = g();
}
public static void f(A a) {
}
public static A g() {
return new A();
}
}
11.4.3 Garbage Collector
Erzeugte Objekte müssen nicht explizit gelöscht werden. Dies macht die JVM automatisch.
Dafür gibt es im System den sogenannten Garbage-Collector, der automatisch im Hintergrund
alle nicht mehr referenzierten Objekte löscht. Den Vorgang des Einsammelns nicht mehr
benötigter Objekte nennt man Garbage-Collection. Je nach Implementierung in der JVM wird
diese von Zeit zu Zeit aufgerufen, oder läuft kontinuierlich im Hintergrund. Außerdem läßt sich
die GC auch aus dem Programm heraus mit „System.gc()“ aufrufen – angewendet wird dies in
Aufgabe 12.8.1.
11.4.4 Element-Funktionen
Leere Klassen sind meist ziemlich sinnlos. Um mit den Objekten der Klasse agieren zu können,
sollten diese Element-Funktionen haben.
Syntax Funktions-Definition
[Modifizierer] rueckgabetyp funktionsname(parameterliste) {
// Funktions-Rumpf
}
Gegenüber den bisher verwendeten Klassen-Funktionen unterscheiden sich ElementFunktionen durch den fehlenden Modifier „static“, und dass sie nur mit Objekt-Bezug
aufgerufen werden können.
public class A {
}
public void g() {
}
f();
g();
// Okay, da Klassen-Funktion
// Compiler-Fehler, da Element-Funktion -> Objekt-Bezug
Seite 217 / 409
noetig
A a = new A();
a.g();
// Okay, g() wird fuer das Objekt a aufgerufen
}
}
Die für Funktionen möglichen Modifizierer werden später aufgeführt und erklärt. Im Augenblick
sollten sie bei Element-Funktionen immer nur ‘public’ verwenden, bei Klassen-Funktionen
„public“ und „static“.
Und wie sieht unser Ring-Zähler jetzt aus?
public void add() {
...
}
// Die Implementierung ist noch offen
public int get() {
...
}
// Die Implementierung ist noch offen
}
11.4.5 Warum Element-Funktionen?
Weshalb gibt es überhaupt Element-Funktionen? Warum nimmt man nicht einfach KlassenFunktionen, und spart sich den Aufwand mit den Objekten?
Man kann beliebig viele Objekte einer Klasse erzeugen kann, die alle voneinander abhängig
sind. Element-Funktionen beziehen sich jeweils nur auf das Objekt, für das sie aufgerufen
werden, d.h. jedes Objekt kann (und hat) seinen eigenen von allen anderen unabhängigen
Status. Klassen-Funktionen beziehen sich auf die Klasse, für die es nur einen Status gibt. Ohne
Objekte und Element-Funktionen wäre sowas nicht möglich.
StringBuilder s1 = new StringBuilder("Hallo Welt");
StringBuilder s2 = new StringBuilder("Java");
System.out.println("Die Laenge von \"" + s1 + "\" ist " + s1.length());
System.out.println("Die Laenge von \"" + s2 + "\" ist " + s2.length());
„s1“ und „s2“ sind zwei unabhängige Objekte, die unterschiedliche Strings repräsentieren. Nur
Funktionen mit Objekt-Bezug können wissen, welches Objekt sie denn nun bearbeiten sollen.
Abb. 11-4 : Funktionen ohne bzw. mit Objekt-Bezug
11.4.6 Attribute
Natürlich hält ein Objekt Daten. Der Ring-Zähler z.B. muss sowohl seinen Start- und Endwert
kennen, als auch seinen aktuellen Wert. Objekt-spezifische Daten – d.h. Variablen in Objekten
– werden Attribute genannt. Element-Funktionen können einfach unter Verwendung des
Attribut-Namens auf die Attribute zugreifen und sie benutzen.
Seite 218 / 409
Achtung – in Java wird auch gerne der historisch begründetet Name „Feld“ statt „Attribute“
verwandt.
Syntax Attribut-Definitionen
[Modifizierer] typ name;
Beispiel
public class A {
private int i;
private String s;
public void set(int arg1, String arg2) {
i = arg1;
s = arg2;
}
public void print() {
System.out.println(i + " => " + s);
}
}
public class Appl {
A a1 = new A();
A a2 = new A();
a1.set(1, "Hallo");
a2.set(2, "Java");
a1.print();
a2.print();
}
}
Ausgabe
1 => Hallo
2 => Java
Die für Attribute möglichen Modifizierer werden später aufgeführt und erklärt. Im Augenblick
sollten sie bei Attributen immer nur ‘private’ verwenden.
private int start;
private int limit;
private int value;
public void add() {
if (++value>limit) {
value=start;
}
}
public int get() {
return value;
Seite 219 / 409
}
}
Jetzt bleibt nur noch die Frage offen, wie denn die Attribute sinnvoll initalisiert werden, d.h. mit
den gewünschten Start- und End-Werten? Zur Zeit werden sie als „int“s alle mit „0“ initialisiert.
Hinweis – Attribute werden auch oft Member, Attributes, Element-Variablen, Objekt-Variablen
oder (speziell in Java) auch Felder genannt.
11.4.7 Konstruktoren
Um ein Objekt bei der Erzeugung sauber zu initialisieren, gibt es spezielle Methoden - die
Konstruktoren. Sie haben keinen Rückgabetyp und heissen immer wie die Klasse. Sie werden
automatisch immer beim Erzeugen eines neuen Objektes aufgerufen.
private String forename;
private String surename;
private int age;
public Person(String fn, String sn, int a) {
forename = fn;
surename = sn;
age = a;
}
System.out.println("Name: " + forename + " " + surename);
System.out.println("Alter: " + age);
}
}
Person p = new Person("Detlef", "Wilkening", 16);
p.print();
// Das Alter stimmt nicht
Ausgabe
Name: Detlef Wilkening
Alter: 16
Nur wenn sie keinen Konstruktor definieren, erzeugt der Compiler automatisch einen
sogenannten Standard-Konstruktor, der ohne Argumente aufgerufen werden kann. Der
Konstruktor wird entsprechend denen bei new angegebenen Argumenten ausgewählt.
public class A {
}
Person p = new Person();
nicht
A a = new A();
Konstruktor
// Compiler-Fehler, dieser Konstruktor existiert hier
// Klasse A hat einen automatisch erzeugten Standard-
Beispiele etwas aufbohren – todo…
Seite 220 / 409
private int start;
private int limit;
private int value;
public RingCounter(int s, int l) {
start = s;
limit = l;
value = s;
}
public void add() {
if (++value>limit) {
value=start;
}
}
public int get() {
return value;
}
}
Nun ist die Klasse vollständig und unser Beispiel funktioniert.
Bemerkung – die Ring-Zähler Klasse ist in diesem Zustand natürlich nicht wirklich in einem
produktiven Zustand. Z.B. kann man sie mit einem End-Wert, der kleiner als der Start-Wert ist,
problemlos aushebeln.
11.5 Aufgaben
11.5.1 Aufgabe „Ringzähler“
Schreiben Sie einen Ringzähler. Ein Ringzähler ist ein Zähler, der von einem Startwert an hoch
(oder runter) zählt (Delta muss nicht 1 sein) und nach Überschreiten des Endwertes wieder
beim Startwert anfängt. Ein solcher Zähler wird in der Praxis häufig gebraucht, z.B. als Index in
ein Array, als Verweis auf ein Spielfeld, usw. Wie gehen Sie mit widersprüchlichen Eingaben
um?
Beim Erzeugen eines Ringzählers sollte der Nutzer folgende Möglichkeiten haben:
• Angabe nur vom End-Wert => Start-Wert ist 0, Delta ist 1
• Angabe von Start- und End-Wert => Delta ist 1
• Angabe von Start- und End-Wert und Delta
Der Ringzähler sollte z.B. mit folgenden Dingen umgehen können – denken Sie sich eine gute
Fehlerbehandlung im Rahmen ihrer Möglichkeiten für problematische Fälle aus:
• End-Wert vor Start-Wert, Delta positiv
• End-Wert nach Start-Wert, Delta negativ
• Delta ist 0
Seite 221 / 409
11.5.2 Aufgabe „Kontaktdaten 1“
Schreiben Sie eine kleine Kontaktdaten-Verwaltung. Folgende Fähigkeiten soll das Programm
in der ersten Version haben:
• Menü für folgende Aufgaben:
- Eingabe neuer Personen
- Ausgabe aller Personen – unsortiert
- Ausgabe aller Personen, deren Vor- oder Nach-Name mit einem bestimmten StringMuster anfängt (Groß- und Kleinschreibung wird nicht unterschieden).
• Das Menü soll der Benutzer durch die Eingabe einzelner Buchstaben (mit Return) anwählen
können.
Personen bestehen aus:
• Vorname
• Nachname
• Telefon (als String)
Bitte
- l :
- n :
- s :
- e :
> l
5
-
waehlen Sie eine Aktion aus
Liste
Neu
Suchen
Ende
Kontakte:
Detlef Wilkening - Tel: 1234
Dieter Schmidt
Dietmar Mueller - Tel: 456
Edgar Wilkens
Ralf Eberleh - Tel: 555 444
Bitte
- l :
- n :
- s :
- e :
> n
Liste
Neu
Suchen
Ende
Geben Sie eine neue Person ein
Vorname: Martina
Nachname: Winkens
Telefon: 98 76 54
Bitte
- l :
- n :
- s :
- e :
> l
6
-
Liste
Neu
Suchen
Ende
Kontakte:
Detlef Wilkening - Tel: 1234
Dieter Schmidt
Dietmar Mueller - Tel: 456
Edgar Wilkens
Ralf Eberleh - Tel: 555 444
Martina Winkens - Tel: 98 76 54
Bitte waehlen Sie eine Aktion aus
- l : Liste
>
Seite 222 / 409
n : Neu
s : Suchen
e : Ende
s
Geben Sie einen Suchstring ein: e
- Edgar Wilkens
- Ralf Eberleh - Tel: 555 444
Bitte
- l :
- n :
- s :
- e :
> s
Liste
Neu
Suchen
Ende
Geben Sie einen Suchstring ein: de
- Detlef Wilkening - Tel: 1234
Bitte
- l :
- n :
- s :
- e :
> s
Liste
Neu
Suchen
Ende
Geben Sie einen Suchstring ein: x
- keinen passenden Eintrag gefunden
Bitte
- l :
- n :
- s :
- e :
> e
Liste
Neu
Suchen
Ende
Ende
Schauen Sie sich bei der Lösung ruhig noch mal Aufgabe „Telefonbuch“ (Kapitel 9.8.6) an.
Aber Achtung – viele Dinge sind hier anders:
• Es gibt ein Menü
• Die Liste aller Personen ist hier unsortiert
• Personen können eingegeben werden
• Das Suchen funktioniert auch mit Anfangs-Mustern ohne Berücksichtigung von Groß- und
Klein-Schreibung.
• Und vor allem: jetzt kennen sie Klassen. Und da Sie ja wissen, dass wir die Kontaktdaten
Verwaltung später noch aufbohren wollen – sollten Sie sie sauber strukturieren.
Und damit wir gleich sehen, ob Sie Ihr Programm sauber strukturiert haben, bohren wir es
direkt auf: Eine Person soll neben Vor-, Nachname und Telefon auch noch eine Beschreibung
(String) enthalten.
Bitte waehlen Sie eine Aktion aus
>
l
n
s
e
n
:
:
:
:
Seite 223 / 409
Liste
Neu
Suchen
Ende
Vorname: Detlef
Nachname: Wilkening
Telefon: 1234
Beschreibung: Java Dozent
Bitte
- l :
- n :
- s :
- e :
> n
Liste
Neu
Suchen
Ende
Vorname: Bernd
Nachname: Mustermann
Telefon:
Beschreibung:
Bitte
- l :
- n :
- s :
- e :
> l
Liste
Neu
Suchen
Ende
2 Kontakte:
- Detlef Wilkening - Tel: 1234 => Java Dozent
- Bernd Mustermann
Bitte
- l :
- n :
- s :
- e :
> e
Liste
Neu
Suchen
Ende
Ende
Wenn Sie ihr Programm gut designt haben, dann sollte dies mit sehr wenig Änderungen am
Code machbar sein. Und die Änderungen sollten auch nur sehr lokal sein.
11.6 Lsg. zu Aufgabe „Ringzähler“ – Kap. 11.5.1
Achtung – ich benutze hier schon das Sprachmittel „this“ aus dem Kapitel 12.4.3.
private
private
private
private
int
int
int
int
start;
limit;
delta;
value;
public RingCounter(int limit) {
Seite 224 / 409
this(0, limit, 1);
}
public RingCounter(int start, int limit) {
this(start, limit, 1);
}
public RingCounter(int start, int limit, int delta) {
if (delta==0) {
delta = 1;
} else if (delta<0) {
delta = -delta;
}
this.start = start;
this.limit = limit;
this.delta = start<=limit ? delta : -delta;
this.value = start;
}
public int next() {
value += delta;
if ((value>limit && delta>0) || (value<limit && delta<0)) {
value = start;
}
return value;
}
public int get() {
return value;
}
}
public class Appl {
System.out.println("RingCounter: 0..4 / 1");
RingCounter rc = new RingCounter(4);
System.out.print(rc.get() + " ");
for (int i=0; i<20; i++) {
System.out.print(rc.next() + " ");
}
System.out.println('\n');
rc = new RingCounter(2, 6);
for (int i=0; i<20; i++) {
}
System.out.println("RingCounter: 2..-2 / 1");
rc = new RingCounter(2, -2);
for (int i=0; i<20; i++) {
}
rc = new RingCounter(1, 9, 0);
for (int i=0; i<20; i++) {
}
rc = new RingCounter(4, 40, 7);
Seite 225 / 409
for (int i=0; i<20; i++) {
}
System.out.println("RingCounter: 20..-5 / 3");
rc = new RingCounter(20, -5, 3);
for (int i=0; i<20; i++) {
}
System.out.println("RingCounter: 0..100 / -18");
rc = new RingCounter(0, 100, -18);
for (int i=0; i<20; i++) {
}
}
}
Ausgabe
RingCounter: 0..4 / 1
0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0
2 3 4 5 6 2 3 4 5 6 2 3 4 5 6 2 3 4 5 6 2
RingCounter: 2..-2 / 1
2 1 0 -1 -2 2 1 0 -1 -2 2 1 0 -1 -2 2 1 0 -1 -2 2
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3
4 11 18 25 32 39 4 11 18 25 32 39 4 11 18 25 32 39 4 11 18
RingCounter: 20..-5 / 3
20 17 14 11 8 5 2 -1 -4 20 17 14 11 8 5 2 -1 -4 20 17 14
RingCounter: 0..100 / -18
0 18 36 54 72 90 0 18 36 54 72 90 0 18 36 54 72 90 0 18 36
11.7 Lsg. zu Aufgabe „Kontaktdaten 1“ – Kap. 11.5.2
Achtung – ich benutze hier schon das Sprachmittel „Klassen-Funktionen“ in einer Form, wie wir
sie hier noch nicht kennen (siehe Kapitel 12.4.4) und auch die direkte Attribut-Initialisierung, wie
sie erst in Kapitel 12.2.1 vorgestellt wird.
public class Keyboard {
private static InputStreamReader isr = new InputStreamReader(System.in);
private static BufferedReader reader = new BufferedReader(isr);
public static String readString() {
try {
return reader.readLine();
Seite 226 / 409
}
return "";
}
}
private String forename = "";
private String surename = "";
private String phone = "";
public boolean find(String pattern) {
int len = pattern.length();
if (forename.length()>=len) {
String begin = forename.substring(0, len);
if (begin.equalsIgnoreCase(pattern)) {
return true;
}
}
if (surename.length()>=len) {
String begin = surename.substring(0, len);
return true;
}
}
return false;
}
public void input() {
System.out.print("Vorname: ");
forename = Keyboard.readString();
System.out.print("Nachname: ");
surename = Keyboard.readString();
System.out.print("Telefon: ");
phone = Keyboard.readString();
}
System.out.print("- " + forename + " " + surename);
if (phone.length()!=0) {
System.out.print(" - Tel: " + phone);
}
}
}
public class Contacts {
private ArrayList<Person> contacts = new ArrayList<>();
public int size() {
return contacts.size();
}
public void add(Person p) {
contacts.add(p);
}
public int find(String pattern) {
int count = 0;
Iterator<Person> i = contacts.iterator();
Seite 227 / 409
while (i.hasNext()) {
Person p = i.next();
if (p.find(pattern)) {
p.print();
count++;
}
}
return count;
}
Iterator<Person> i = contacts.iterator();
i.next().print();
}
}
}
public class Appl {
private Contacts cts = new Contacts();
public void run() {
while (true) {
System.out.println("Bitte waehlen Sie eine Aktion aus");
System.out.println("- l : Liste");
System.out.println("- n : Neu");
System.out.println("- s : Suchen");
System.out.println("- e : Ende");
String in = Keyboard.readString();
if (in.equalsIgnoreCase("l")) {
print();
} else if (in.equalsIgnoreCase("n")) {
insert();
} else if (in.equalsIgnoreCase("s")) {
find();
} else if (in.equalsIgnoreCase("e")) {
System.out.println("Ende");
return;
}
}
}
private void print() {
System.out.println(cts.size() + " Kontakte:");
cts.print();
}
private void insert() {
System.out.println("Geben Sie eine neue Person ein");
Person p = new Person();
p.input();
cts.add(p);
}
private void find() {
System.out.print("Geben Sie einen Suchstring ein: ");
String pattern = Keyboard.readString();
int count = cts.find(pattern);
if (count==0) {
System.out.println("- keinen passenden Eintrag gefunden");
}
}
Appl appl = new Appl();
appl.run();
Seite 228 / 409
}
}
Die neue Kontaktdaten-Verwaltung unterscheidet sich durch die alte nur durch ein weiters
Merkmal der zu verwaltenen Personen. Da alle personen-relevanten Elemente in der PersonenKlasse gekapselt sind, ist nur diese Klasse betroffen. Das komplette restliche Programm ist von
der Änderung nicht betroffen. Daher wird hier auch nur die neue Personen-Klasse besprochen
und gelistet.
Was muß an der Personen-Klasse geändert werden?
• Sie benötigt ein weiteres String-Attribut für die Beschreibung.
• Die Beschreibung muss bei der Personen-Eingabe mit von der Tastatur gelesen werden –
siehe Element-Funktion „input“.
• Und die Beschreibung muß – wenn vorhanden – mit ausgegeben werden – siehe ElementFunktion „print“.
• Das Suchen wird von der Beschreibung nicht beeinflußt – also muß die Element-Funktion
„find“ nicht angepaßt zu werden.
Fertig – das war’s.
private
private
private
private
String
String
String
String
forename = "";
surename = "";
phone = "";
description = "";
int len = pattern.length();
if (forename.length()>=len) {
String begin = forename.substring(0, len);
return true;
}
}
if (surename.length()>=len) {
String begin = surename.substring(0, len);
return true;
}
}
return false;
}
System.out.print("Beschreibung: ");
Seite 229 / 409
description = Keyboard.readString();
}
System.out.print("- " + forename + " " + surename);
}
if (description.length()!=0) {
System.out.print(" => " + description);
}
}
}
12 Klassen-Details
12.1 Zugriffsbereiche
Java kennt 4 Zugriffs-Modifizierer. Für alle Elemente in einer Klasse haben sie folgende
Bedeutung:
• public
Auf diese Elemente darf jeder von überall her zugreifen.
• protected
Auf diese Elemente darf von innerhalb des gleichen Package und von den abgeleiteten
Klassen her zugegriffen werden. Packages werden in Kapitel 13 eingeführt, Vererbung in
Kapitel 14. D.h. ist dieser Modifizierer für uns zur Zeit ohne Bedeutung.
• --- (kein Zugriffs-Modifizierer entspricht einer Package Sichtbarkeit)
Auf diese Elemente darf von innerhalb des gleichen Package her zugegriffen werden.
Packages werden in Kapitel 13 eingeführt. D.h. ist dieser Modifizierer für uns zur Zeit noch
ohne Bedeutung.
• private
Auf diese Elemente darf nur von innerhalb der Klasse zugegriffen werden (und von inneren
Klassen – siehe Kapitel 15).
public class A {
private void f();
public void g() {
f();
}
// Kein Problem, da innerhalb der Klasse
}
public class B {
public void f(A a) {
a.f();
a.g();
}
// Compiler-Fehler, da private
// Okay, da public
}
Wichtige Bemerkung – es ist sehr sehr sehr empfehlenswert alle Attribute private zu machen,
Seite 230 / 409
und einen Zugriff von außen – wenn er denn überhaupt notwendig ist – über Funktionen zu
regeln. Dies ist einer der wichtigsten Grundprinzipien jeglicher Software-Entwicklung und der
Objektorientierung: „Information-Hiding“:
• Die interne Implementierung ist vollständig vor dem Benutzer versteckt.
• Die interne Implementierung läßt sich jederzeit ändern.
• Von außen können keine inkonsistenten Objekt-Zustände erzeugt werden.
12.2 Konstruktoren
12.2.1 Initialisierung
Wird ein Objekt erzeugt, so gibt es mehrere Möglichkeiten die Attribute zu initialisieren.
• Man macht nichts: in diesem Fall werden die entsprechenden Attribute entsprechend ihrem
Typ initialisiert.
• Man kann den gewünschten Wert direkt bei der Attribut-Definition angeben.
• Eine Klasse kann Initialisierungs-Blöcke enthalten – dies wird in der Vorlesung nicht
besprochen.
• Oder das Attribut wird im Konstruktor initialisiert.
public class A {
private int i1;
private int i2 = 42;
private int i3;
Ko.
private
private
fuer s2
private
private
Ko.
// Default-Wert 0
// Initial-Wert bei der Attribut-Definition
// Sieht nach Default-Wert aus, Initialisierung dann im
String s1;
// Default-Wert null
// Initial-Wert String "Hallo"
String s3 = new String("Hallo");
String s4;
// Langfassung von s2
// Sieht nach null aus, aber dann
public A(int arg1, String arg2) {
i3 = arg1;
s4 = arg2;
}
}
• Direkte Initialisierungen der Attribute ist vor allem dann sinnvoll, wenn eine Klasse mehrere
Konstuktoren hat, und die Attribute in allen Konstruktoren die gleichen Werte bekommen.
• Das Initialisieren der Attribute in den Konstruktoren ist vor allem dann sinnvoll, wenn die
gesetzten Werte konstruktor-spezifisch sind, d.h. z.B. von den Konstruktor-Parametern
abhängen.
• Das Initialisieren der Attribute in den Initialisierungs-Blöcken – was hier nicht besprochen
wird – ist vor allem dann sinnvoll, wenn das Setzen in allen Konstruktoren identisch, aber zu
komplex für eine direkte Initialisierung ist.
Seite 231 / 409
12.2.2 Konstruktor-Verkettung
Wenn eine Klasse mehrere Konstruktoren hat, so können diese oft aufeinander zurückgeführt
werden, um das Programmieren zu vereinfachen.
private String forename;
private String surname;
private int age;
public Person(String fn, String sn) {
forename = fn;
surname = sn;
}
public Person(String fn, String sn, int a) {
this(fn, sn);
age = a;
}
}
Der Aufruf eines anderen Konstruktors der gleichen Klasse geschieht über den „this“ Zeiger mit
den entsprechenden Parametern und muss in der ersten Zeile des Konstruktors stehen.
12.3 finalize
Analog zu den Konstruktoren gibt es in Java auch eine Klassen-Methode, die beim Zerstören
eines Objektes aufgerufen wird - sie heisst finalize
public class A {
protected void finalize() {
}
}
Achtung – es ist vollkommen undefiniert wann die Funktion „finalize“ aufgerufen wird. Es kann
sogar passieren, dass sie gar nicht aufgerufen wird:
• Zwischen „nicht-mehr-referenziert-werden“ und dem Ende des Programms wird keine GC
mehr ausgelöst.
• Die Verkettung in der Vererbungs-Hierarchie ist unterbrochen – siehe Kapitel todo.
U.a. deshalb wird in der Praxis von der Verwendung der Finalize-Funktion abgeraten. Statt
dessen sollen lieber Weak- oder Phantom-Referenzen benutzt werden – die zu besprechen
sprengt aber mal wieder den Zeit-Rahmen der Vorlesung.
Mit einem kleinen Beispiel-Programm kann man den Aufruf der Funktion gut nachverfolgen:
public class Test {
public Test() {
System.out.println("- Konstruktor");
}
System.out.println("- finalize");
Seite 232 / 409
}
}
System.out.println("Objekt wird erzeugt");
Test t = new Test();
System.out.println("Referenz auf das Objekt wird freigeben");
t = null;
System.out.println("GC wird ausgeloest");
System.gc();
System.gc();
Mögliche Ausgabe
Objekt wird erzeugt
- Konstruktor
Referenz auf das Objekt wird freigeben
GC wird ausgeloest
- finalize
GC wird ausgeloest
GC wird ausgeloest
Die Ausgabe kann bei jeder virtuellen Java-Maschine anders aussehen, da das genaue
Verhalten bei einer GC der JVM freigestellt ist. Manche Implementierungen z.B. geben ein nicht
mehr referenziertes Objekt erst nach der zweiten GC frei, während sie die erste GC nur als
Markierungsphase benutzen.
12.4 Funktionen
12.4.1 Parameter und Rückgaben
Die integrierten Datentypen wie int, double, char,... werden per Wert übergeben („call-by-value“
– cbv) – sie stellen also eine Kopie da - Änderungen in der Funktion verändern den Wert in der
aufrufenden Funktion nicht.
Bei allen anderen Parametern, die ja alle Referenz-Typen sind, werden die Argumente per
Referenz übergeben („call-by-reference“ – cbr). Bei diesen referenzieren die Parameter das
gleiche Objekt wie in der aufrufenden Funktion – d.h. es kann in der Funktion das OriginalObjekt verändert werden.
public class A {
private static void f(int i, StringBuilder s) {
System.out.println("> f(" + i + ", " + s + ")");
i = 12;
s.append(" Welt");
System.out.println("> i: " + i);
System.out.println("> s: " + s);
}
int i = 42;
StringBuilder s = new StringBuilder("Hallo");
f(i, s);
System.out.println("# i: " + i);
System.out.println("# s: " + s);
}
Seite 233 / 409
}
Ausgabe
> f(42, Hallo)
> i: 12
> s: Hallo Welt
# i: 42
# s: Hallo Welt
Der Rückgabe-Typ void bei Funktionen gibt an, dass die Funktion nichts zurückgibt.
12.4.2 return
Ist eine Funktion nicht vom Typ void, so muss sie einen zu dem Typ passenden Wert
zurückgeben. Dies geschieht mit der return Anweisung. Die Funktion wird instantan beendet.
public class Person
{
private int age;
public int getAge() {
return alter;
}
}
• In einer Funktion können beliebig viele return Anweisungen vorkommen.
• Der Rückgabewert kann beim Funktions-Aufruf ignoriert werden, d.h. er muss nicht
verwendet oder ausgewertet werden.
12.4.3 this
Innerhalb jeder Element-Funktion ist automatisch das Schlüsselwort „this“ definiert, das eine
Referenz auf das aktuelle Objekt ist, d.h. das für das die Element-Funktion aufgerufen wurde.
Eine Referenz auf das aktuelle Objekt – aus Sicht der Element-Funktion auf sich selber – wird
in der Praxis häufig benötigt, z.B. um „sich-selber“ an andere Element-Funktionen zu
übergeben. Aber auch für profanere Aufgaben wie z.B. zur Aufruf-Verkettung (siehe Beispiel)
wird „this“ eingesetzt.
public class A {
public A myself() {
return this;
}
public void f() {
}
}
A a = new A();
a.myself().f();
Seite 234 / 409
Ein ganz typischer Anwendungsfall in Java für „this“ ist die Verwendung gleicher Namen für
Attribute (d.h. Variablen im Objekt) und Parameter. In einem solchen Fall verdecken die
Parameter die Attribute, da sie im Scope der Funktion liegen, während die Attribute zum Scope
der Klasse gehören. Über das Schlüsselwort „this“ – d.h. über das aktuelle Objekt – können die
Attribute trotz gleich-namiger lokaler Variablen angesprochen werden.
private
private
private
private
int
int
int
int
start;
limit;
delta;
value;
public RingCounter(int start, int limit, int delta) {
this.start = start;
this.limit = limit;
this.delta = delta;
this.value = start;
}
}
Achtung – in Klassen-Funktionen, d.h. Funktionen mit dem Modifierer static, ist „this“ nicht
definiert, da Klassen-Funktionen keinen Objekt-Bezug haben.
12.4.4 Klassen-Funktionen
Klassen-Funktionen – d.h. Funktionen mit dem Modifier „static“ – werden ohne Objekt-Bezug
aufgerufen. Klassen-Funktionen von fremden Klassen müssen mit dem Klassen-Namen
referenziert werden.
public class A {
System.out.println("A.f");
}
}
public class B {
System.out.println("B.f");
}
f();
B.f();
A.f();
}
}
Ausgabe
B.f
B.f
A.f
Im Gegensatz zu einer Element-Funktion ist eine Klassen-Funktion nicht einem Objekt,
sondern einer Klasse zugeordnet. Daher können Klassen-Funktionen natürlich nicht auf
Attribute zugreifen, sondern nur auf Klassen-Variablen – siehe Kapitel 12.5.1.
Seite 235 / 409
12.5 Attribute
12.5.1 Klassen-Variablen
So wie es Element- und Klassen-Funktionen gibt, so gibt es auch Element- und KlassenVariablen. Gegenüber Attributen haben Klassen-Variablen zusätzlich den Modifier „static“.
public class A {
private static int i;
private static String s = "Hallo";
}
Im Gegensatz zu einem Attribut ist eine Klassen-Variable nicht einem Objekt, sondern einer
Klasse zugeordnet. Klassen-Variablen können von Element- und von Klassen-Funktionen
genutzt werden.
Klassen-Variablen werden initialisiert, wenn die Klasse in die JVM geladen wird. Für die
Definition der Initialisierung gibt es drei Arten:
• Man macht nichts: in diesem Fall werden die entsprechenden Klassen-Variablen
entsprechend ihrem Typ initialisiert.
• Man kann den gewünschten Wert direkt bei der Klassen-Variablen -Definition angeben.
• Eine Klasse kann statische Initialisierungs-Blöcke enthalten – dies wird in der Vorlesung
nicht besprochen.
12.5.2 Klassen-Konstanten
An vielen Stellen sind beim Programmieren Konstanten – gerade Integer Konstanten – sehr
hilfreich. Eine Konstante ermöglicht es ihnen statt eines Literals50 einen sprechenden Namen zu
benutzen, und den Wert der Konstanten an einer einzigen Stelle zu definieren, egal wie oft und
wo sie die Konstante benutzen.
// Bsp ohne Konstante
double bruttoPrice = 1.19 * nettoPrice;
// (*)
...
System.out.println(value/1.19);
// (**)
// Bsp mit Konstante – Achtung, nur Pseudocode
MWST = 1.19
double bruttoPrice = MWST * nettoPrice;
...
System.out.println(value/ MWST);
50
Literal – siehe auch Kapitel todo.
Seite 236 / 409
Während in Zeile (*) noch recht offensichtlich ist, dass das Literal wohl die Mehrwert- oder
Umsatz-Steuer meint, ist dies in Zeile (**) nur noch durch den Kontext erkennbar. Statt dessen
ist dies im Beispiel mit Konstante in beiden Fällen sofort klar.
Ändert sich die Umsatz-Steuer, so müssen Sie im ersten Beispiel alle Stellen im
Programmcode finden, die ein Literal enthalten, und sie ändern. Und hoffentlich vergessen sie
keine Stelle bzw. ändern keine „19“ um, die nichts mit der Umsatz-Steuer zutun hat. Im zweiten
Beispiel müssen Sie nur die eine Konstanten-Definition ändern, was viel weniger Arbeit ist und
auch weniger fehlerträchtig.
Ein Konstante ist in Java eine normale Element- oder Klassen-Variable, die den Modifier „final“
bekommt. Damit läßt sich die entsprechende Variable nicht mehr ändern – siehe auch Kapitel
8.3.1.
public class A {
public static final int CONST_VAR = 42;
}
Bemerkung – Konstanten sind in Java typischerweise Klassen-Konstanten, d.h. konstante
Klassen-Variablen, da die Konstante normalerweise ja für alle Objekte gleich ist. Also mit
Modifier „static“.
Bemerkung – Klassen-Konstanten sind, obwohl Variablen, häufig „public“ oder „protected“, da
sie meist von überall genutzt werden können sollen. Da sie konstant sind, d.h. nicht geändert
werden können, ist der unbeschränkte Zugriff ja auch kein Problem.
Bemerkung – der Modifier „final“ wirkt bei Referenz-Variablen nur auf die Variable, und nicht
auf das referenzierte Objekt.
Bemerkung – Klassen-Konstanten werden in Java per Konvention in Großbuchstaben
geschrieben, und die einzelnen Wörter durch Underscores getrennt – siehe auch Kapitel 3.2.5.
12.6 Aufzählungen
Aufzählungen werden benötigt, wenn eine Variable nur wenige feste Werte annehmen kann,
die alle zur Entwicklungs-Zeit schon feststehen. Beispiele hierfür sind:
• Ausrichtung von Text in einem Absatz:
- Linksbündig, zentriert, rechtsbündig, blocksatz
• Spielfarben in einem Kartenspiel:
- Karo, Herz, Pik, Kreuz
• Belegung eines Feldes beim Tic-Tac-Toe:
- Unbelegt, weiß, schwarz
• Auflistung der 16 HTML Grund-Farben:
-
Seite 237 / 409
Schwarz, weiß, rot, grün,…
In einem solchen Fall wünscht man sich als Programmierer einen speziellen Typ, der nur die
jeweiligen festen Werte aufnehmen kann – eine Aufzählung oder Enumeration, die es seit dem
JDK 1.5 in Java gibt.
• Intern werden Enums in Java mit Klassen definiert, d.h. Enums sind eigentlich nur Klassen.
Daher bestimmt wie bei Klassen auch der Enum-Name den Datei-Namen, und in der Datei
steht nur die Enumeration.
• Die Enumeration wird mit dem Schlüsselwort „enum“ eingeleitet, und ist meistens „public“.
• Im einfachsten Fall besteht der Enum nur aus den Aufzählungs-Konstanten, die vergleichbar
zu Klassen-Konstanten sind. Als solche werden sie natürlich groß geschrieben.
• Der Enum (im Beispiel „Color“) kann wie eine Klasse genutzt werden – d.h. z.B. für
Variablen-Definitionen oder in Funktions-Schnittstellen – natürlich mit Referenz-Semantik.
• Java sorgt dafür, dass nur die Aufzählungs-Konstanten in der Enum-Definition existieren.
Man kann im Programm keine weiteren Aufzählungs-Konstanten anlegen. Daher funktioniert
der Vergleich mit „==“ (Identität), und man muß nicht „equals“ benutzen.
public enum Color {
RED,
GREEN,
BLUE
}
public class A {
public static void checkColor(Color c) {
if (c == Color.RED) {
System.out.println("Farbe ist rot");
} else {
System.out.println("Farbe ist nicht rot");
}
}
Color co = Color.GREEN;
checkColor(co);
checkColor(Color.RED);
}
}
Ausgabe
Farbe ist nicht rot
Farbe ist rot
Ein typisches Einsatzgebiet von Enums sind Switch-Anweisungen, in denen sie genutzt werden
können (siehe auch Kapitel 7.2).
Color c = Color.GREEN;
switch (c) {
case RED:
System.out.println("Farbe ist rot");
break;
case GREEN:
System.out.println("Farbe ist gruen");
break;
case BLUE:
System.out.println("Farbe ist blau");
break;
}
Seite 238 / 409
Ausgabe
Farbe ist gruen
12.6.1 Enums in Klassen
Selbst wenn wir innere Klassen noch nicht kennen (siehe Kapitel 15) – Enums können auch
innerhalb von Klassen als eine Art klassenbezogene Aufzählung definiert werden. Das
Schlüsselwort „static“ ist hierbei optional.
public class A {
public static enum Color1 { RED, GREEN, BLUE };
public enum Color2 { RED, GREEN, BLUE };
}
12.6.2 Enums sind Klassen
Enums sind in Wirklichkeit echte Klassen, und können als solche auch definiert und genutzt
werden. Daher man kann die Enum-Konstanten mit weiteren Informationen (Attributen) und
Element-Funktionen anreichern:
public enum Color {
RED(255,0,0), GREEN(0,255,0), BLUE(0,0,255);
private int r,g,b;
private Color(int r, int g, int b) {
this.r = r;
this.g = g;
this.b = b;
}
public int getRedValue() {
return r;
}
}
Achtung – Konstruktoren von Enumerationen müssen „private“ sein, da nur die Klasse die
Enumerations-Konstanten erzeugen darf.
12.6.3 Weiteres
• Im JDK wurden außerdem noch statische Imports eingeführt, die man u.a. mit Enums nutzen
kann. Aus Zeitmangel werden wir keine statischen Imports besprechen.
• Enums bringen von sich aus einige Funktionen mit sich, wie z.B. die Klassen-Funktionen:
- „values“, die ein Array aller Enum-Konstanten zurückgibt.
- „valueOf“, die die Enum Konstante zum übergebenen String zurückgibt.
for (Color c : Color.values()) {
System.out.println(c);
}
Color c = Color.valueOf("RED");
System.out.println("-> " + c);
Seite 239 / 409
Ausgabe
RED
GREEN
BLUE
-> RED
12.6.4 Historie
Erst mit Java 5.0 (JDK 1.5) sind Aufzählungs-Typen in Java eingeführt worden. Bis dahin
wurden meist Integer-Konstanten für Aufzählungen verwandt, typischerweise so:
public class Text {
public
public
public
public
static
static
static
static
final
final
final
final
int
int
int
int
LEFT = 1;
CENTER = 2;
RIGHT = 3;
BLOCK = 4;
public void setAlignment(int arg) {
...
}
}
Obwohl diese Lösung mit Integer-Konstanten alles andere als gut ist (fehlende Typsicherheit),
sollten Sie sie kennen, denn sie findet sich in vielen altem Code und vor allem auch in den
Schnittstellen der Java Bibliothek, denn diese wurde zum größten Teil schon in den JDKs 1.0
bis 1.4 definiert.
Eine etwas bessere Lösung für Aufzählungs-Typen statt Integern ist ihre Simulation über
spezielle Klassen. Dieses Verfahren ist in vielen Büchern51 und Artikeln (auch bei Oracle selber)
beschrieben – sprengt aber leider den Rahmen des Tutorials. Seit dem JDK 1.5 ist dies eh
nicht mehr notwendig, da jetzt ja echte Aufzählungs-Typen in Java zur Verfügung stehen.
12.7 Top-Level-Klassen
Klassen (und auch Interfaces), die direkt in ein Package eingebettet sind, nennt man auch TopLevel-Klassen (bzw. Top-Level-Interfaces). Von daher sind alle Klassen, die wir bisher kenenn
gelernt haben Top-Level-Klassen.
12.8 Aufgaben
12.8.1 Aufgabe „Türme von Hanoi“
Simulieren Sie die „Türme von Hanoi“.
51
Z.B. in „Effektiv Java“ von todo.
Seite 240 / 409
Abb. 12-1 : Türme von Hanoi
Die „Türme von Hanoi“ ist ein Spiel, bei dem am Anfang alle Scheiben auf einem Stab liegen,
und dann zu einem anderen Stab transportiert werden sollen. Für den Transport gelten zwei
Regeln:
• Es darf immer nur eine Scheibe bewegt werden.
• Es darf immer nur eine kleinere Scheibe auf einer größeren liegen, nie umgekehrt.
Schreiben Sie ein Programm, dass am Anfang die Anzahl an Scheiben einliest, mit denen die
Türme von Hanoi gespielt werden sollen. Danach soll das Spiel mit entsprechender Ausgabe
simuliert werden.
Anzahl Scheiben: 3
1.
-||
|
--|-|
|
---|--|
|
*************************
2.
|
|
|
--|-|
|
---|--|
-|*************************
3.
|
|
|
|
|
|
---|--- --|--|*************************
4.
|
|
|
|
-||
---|--- --|-|
*************************
5.
|
|
|
|
-||
|
--|-- ---|--*************************
6.
|
|
-|-
|
|
--|--
|
|
---|---
Seite 241 / 409
*************************
7.
|
|
|
|
|
--|--||
---|--*************************
8.
|
|
-||
|
--|-|
|
---|--*************************
12.8.2 Aufgabe „Gerüchteküche“
Kleine Dörfer sind Gerüchteküchen erster Klasse. Jeder kennt jeden, und jeder redet über
jeden, bzw. schweigt wissend. All das wollen wir in einem kleinen Programm nachbilden.
Simulieren Sie ein Dorf mit n Einwohnern. Am Anfang kennt nur ein beliebiger Einwohner
(nehmen Sie einfach den ersten) das Gerücht.
Danach simulieren Sie das Geschehen, indem Sie maximal m Durchläufe starten. In jedem
Durchlauf treffen sich zwei zufällige Einwohner des Dorfes und reden miteinander. Was hierbei
passiert, ist davon abhängig, welchen Status bzgl. des Gerüchts die beiden Einwohner haben.
Einwohner 1
unwissend
unwissend
unwissend
erzählend
erzählend
erzählend
schweigsam
schweigsam
schweigsam
Einwohner 2
unwissend
erzählend
schweigsam
unwissend
erzählend
schweigsam
unwissend
erzählend
schweigsam
=>
Einwohner 1
unwissend
erzählend
unwissend
erzählend
schweigsam
schweigsam
schweigsam
schweigsam
schweigsam
Einwohner 2
unwissend
erzählend
schweigsam
erzählend
schweigsam
schweigsam
unwissend
schweigsam
schweigsam
Änderung
+
+
+
+
+
-
Das Programm ist damit im Prinzip beschrieben. Hier noch einige Hinweise:
• Der Benutzer soll am Anfang eingeben, wieviele Bewohner das Dorf hat, und wieviele
Durchläufe maximal gewünscht sind.
• Gibt es stabile Zustände? D.h. Zustände, bei denen es keine Änderung der Stati der
Einwohner mehr gibt? Wenn ja, welche? Erreicht das Programm einen solchen stabilen
Zustand, soll die Simulation mit einer entsprechenden Meldung beendet werden.
• Wird das Programm durch die max. Anzahl an Durchläufen beendet, soll die Simulation
auch hier mit einer entsprechenden Meldung beendet werden.
• Das Programm soll nach einer Status-Änderung folgende Informationen in einer Zeile
Seite 242 / 409
ausgeben52:
- Nummer des Durchlaufs (n-stellig in Abhängigkeit der max. Durchläufe, rechtsbündig,
führende Leerzeichen)
- Anzahl an unwissenden Einwohnern in der Form „U(_x)“ (n-stellig in Abhängigkeit der
max. Durchläufe, rechtsbündig, führende Underscores)
- Anzahl an erzählenden Einwohnern – Form anlog zu den Unwissenden
- Anzahl an schweigsamen Einwohnern – Form anlog zu den Unwissenden
- Ein Zeichen für jeden Einwohner:
o Unwissend => „_“
o Erzählend => „|“
o Schweigsam => „*“
Eine Simulation könnte also folgendermaßen aussehen:
Geruechtekueche
- Anzahl Personen: 30
- Max Durchlaeufe: 400
0:
3:
5:
6:
8:
9:
19:
26:
36:
41:
45:
47:
62:
109:
116:
136:
139:
159:
182:
U(29)
U(28)
U(27)
U(26)
U(26)
U(25)
U(25)
U(24)
U(23)
U(22)
U(22)
U(22)
U(21)
U(21)
U(21)
U(20)
U(19)
U(19)
U(19)
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
E(
1)
2)
3)
4)
2)
3)
2)
3)
4)
5)
4)
2)
3)
2)
1)
2)
3)
1)
0)
S( 0)
S( 0)
S( 0)
S( 0)
S( 2)
S( 2)
S( 3)
S( 3)
S( 3)
S( 3)
S( 4)
S( 6)
S( 6)
S( 7)
S( 8)
S( 8)
S( 8)
S(10)
S(11)
|_____________________________
|___________________|_________
|___________________|__|______
|_________|_________|__|______
|_________*_________|__*______
|_____|___*_________|__*______
|_____*___*_________|__*______
|_____*___*__|______|__*______
|_____*__|*__|______|__*______
|__|__*__|*__|______|__*______
*__|__*__|*__|______|__*______
*__|__*__|*__*______*__*______
*__|__*__|*__*______*__*___|__
*__|__*__**__*______*__*___|__
*__|__*__**__*______*__*___*__
*__|__*__**__*____|_*__*___*__
*__|__*__**__*___||_*__*___*__
*__|__*__**__*___**_*__*___*__
*__*__*__**__*___**_*__*___*__
Ende wegen stabilem Zustand
12.8.3 Aufgabe „Tic-Tac-Toe 1“
Schreiben Sie ein einfaches Tic-Tac-Toe.
Tic-Tac-Toe ist ein einfaches Spiel, das auf einem 3x3 Brett gespielt wird. Es wird abwechselnd
gezogen – jedesmal legt ein Spieler einen seiner Spielsteine auf ein Brett. Gewonnen hat, wer
zuerst 3 eigene Steine in einer Reihe hat (vertikal, horinzontal bzw. diogonal). Nach spätestens
neun Zügen ist das Spiel vorbei – hat dann keiner der Spieler eine vollständige Reihe geschafft,
ist das Spiel unentschieden.
Hinweis – wird das Spiel von einem Spieler optimal gespielt, kann er nicht verlieren. D.h.
52
Achtung – das Programm ändert nicht nach jedem Durchlauf seinen Status.
Seite 243 / 409
spielen beide Spieler optimal, so wird es immer unentschieden ausgehen.
Fangen Sie das Programm einfach und klein an, und gehen Sie im ersten Schritt sehr
pragmatisch vor. D.h. versuchen Sie das Programm erstmal vollständig (im Sinne von „man
kann spielen“) zum Laufen zu bringen:
• Machen Sie eine einfache pragmatische Eingabe, z.B. indem die Felder von 1..9
durchnummeriert sind, und Sie einfach nur die Feld-Nummer von der Tastatur abholen.
• Machen Sie nach jedem Zug eine einfache Ausgabe in die Konsole, z.B. indem ein Feld mit
„_“ (unbelegt), „X“ (Spieler 1) und „O“ (Spieler 2) ausgegeben wird.
• Legen Sie einfach fest, dass z.B. immer der Mensch anfängt und der Computer der zweite
Spieler ist.
• Während des Spiels ist kein Abbruch möglich.
• Und vor allen Dingen verwenden Sie erstmal nicht zuviel Arbeit auf einen guten
Computerspieler (zum einen würden Sie dann nicht mehr gewinnen können, zum anderen ist
dies eher ein algorithmisches und nicht ein Java Problem). Im einfachsten Fall
programmieren Sie einfach einen Computerspieler, der das erste leere Feld besetzt. Wenn
dann irgendwann alles gut, stabil, schön usw. läuft, dann sollten Sie sich aber ruhig noch an
dieses Problem heranwagen und einen optimalen Computerspieler implementieren.
___
___
___
Bitte machen sie ihren Zug (1..9): 1
Mensch zieht 1 - Feld 1/1
O__
___
___
Computer (naechstes freies Feld) zieht 2 - Feld 1/2
OX_
___
___
OX_
O__
___
Computer (naechstes freies Feld) zieht 3 - Feld 1/3
OXX
O__
___
OXX
O__
O__
Seite 244 / 409
Mensch hat gewonnen
Hinweise:
• Lassen Sie sich nicht von dem scheinbar großen Problem einschüchtern. Programmieren
heißt immer auch – egal ob prozedural, funktional, objekt-orientiert,.. – ein Problem in
kleinere Teilprobleme zu zerlegen, bis man diese lösen kann.
• Fangen Sie auch nicht einfach blind an zu Implementieren – dazu ist diese Aufgabe
wahrscheinlich schon zu groß. Setzen Sie sich hin, und überlegen Sie, welche Teile Sie
zuerst warum und wie implementieren. Welche hängen dann davon ab?
• Identifzieren Sie die wichtigsten Konzepte des Spiels (welche sind das?) und packen Sie
diese in Klassen.
• Überlegen Sie, welche Schnittstellen die Klassen benötigen. Welche Klasse hat welche
Aufgaben bzw. Verantwortlichkeiten?
• Es ist eine interessante und wichtige Aufgabe sich zu überlegen, an welcher Stelle welche
Arbeit erledigt wird – die Kriterien dafür sind Klarheit, Erweiterbarkeit, Allgemeinheit,
Wiederverwendbarkeit, usw.
12.9 Lsg. zu Aufgabe „Türme von Hanoi“ – Kap. 12.8.1
public class Hanoi {
private ArrayList startTower, middleTower, endTower;
private int count;
private int move;
//-------------------------------------------------------------------------public void play(int count) {
this.count = count;
startTower = new ArrayList(count);
middleTower = new ArrayList();
endTower = new ArrayList();
for (int i=count; i>0; --i) {
startTower.add(i);
}
move = 1;
print();
moveTower(0, startTower, endTower, middleTower);
}
//-------------------------------------------------------------------------private void moveTower(
int layer, ArrayList source, ArrayList dest, ArrayList help) {
// Wenn die zu bewegende Ebene die oberste ist,
// dann kann die Scheibe direkt bewegt werden.
if (layer==source.size()-1) {
moveSlice(source, dest);
return;
Seite 245 / 409
}
// Um den gesamten Haufen von Scheiben ab der angegebenen Ebene
// zu bewegen, muss:
// - zuerst der Haufen Scheiben ueber der Ebene zum Hilfs-Turm
//
bewegt werden,
// - dann die Scheibe zum Ziel-Turm bewegt werden, und dann
// - der verschobene Haufen auf die bewegte Scheibe bewegt werden.
int helpLayer = help.size();
moveTower(layer+1, source, help, dest);
moveSlice(source, dest);
moveTower(helpLayer, help, dest, source);
}
//-------------------------------------------------------------------------private void moveSlice(ArrayList source, ArrayList dest) {
// Den Umweg ueber die Klasse Integer kann man sich sparen, aber
// wir kennen Vererbung und die Klasse "Object" noch nicht.
Integer slice = (Integer)source.remove(source.size()-1);
dest.add(slice);
++move;
print();
}
//-------------------------------------------------------------------------private void print() {
System.out.println("\n" + move + '.');
for (int layer=count-1; layer>=0; --layer) {
System.out.print(' ');
printTowerLayer(startTower, layer);
printTowerLayer(middleTower, layer);
printTowerLayer(endTower, layer);
}
System.out.println(createString(6*count+7, '*'));
}
//-------------------------------------------------------------------------private void printTowerLayer(ArrayList tower, int layer) {
int sliceWidth = tower.size()<=layer ? 0 : (Integer)tower.get(layer);
int spaceCount = count - sliceWidth;
String spaces = createString(spaceCount, ' ');
String halfSlice = createString(sliceWidth, '-');
System.out.print(spaces + halfSlice + '|' + halfSlice + spaces);
}
//-------------------------------------------------------------------------private static String createString(int len, char c) {
StringBuffer sb = new StringBuffer(len);
for (int i=0; i<len; i++) {
sb.append(c);
}
return sb.toString();
}
}
public class Appl {
System.out.print("Anzahl Scheiben: ");
try {
Seite 246 / 409
int count = Integer.parseInt(in);
if (count<1) {
System.out.println("Fehler");
return;
}
Hanoi h = new Hanoi();
h.play(count);
System.out.println("Fehler: " + x);
}
}
}
12.10 Lsg. zu Aufgabe „Gerüchteküche“ – Kap. 12.8.2
12.10.1 Vorüberlegungen
Bevor wir überhaupt mit dem Programmieren anfangen, machen wir uns Gedanken zu den
Stati des Dorfes und den stabilen (End-)Zuständen.
• Nicht nach jeder Simulations-Runde muss sich der Status des Dorfes ändern. Es kann z.B.
sein, dass die Simulation zwei Einwohner aufeinander treffen läßt, die beide das Gerücht
nicht kennen – dann kennen sie es natürlich auch hinterher noch nicht. Die AufgabenStellung verlangt, dass nur nach einer Änderung des Dorf-Status eine neue Ausgabe zu
erfolgen hat – dem müssen wir Rechnung tragen.
• Wann muss die Simulation beendet werden?
Wenn die max. Anzahl an Durchläufen erreicht ist.
Und wenn ein stabiler Endzustand erreicht ist, d.h. nichts mehr passiert. Dies ist dadurch
bestimmt, dass es keinen Erzählenden mehr gibt. Achtung – es ist nicht zwingend nötig,
dass alle wissend und schweigsam sind. Auch unwissende53 haben nichts zu erzählen. Also
führen auch nur Unwissende und Schweigsame zu einem stabilen Endzustand.
12.10.2 Haupt-Programm
Eine typische Simulation läßt sich schnell in zwei Teile zerlegen:
• Erstmal muss die zu simulierende Situation aufgebaut werden, d.h. alle Daten müssen
eingelesen und initiiert werden.
• Dann müssen die Duchläufe gestartet werden, bis sie zu beenden sind.
Damit liegt die Struktur des Haupt-Programms fest.
main
Anzahl Personen einlesen
Anzahl max. Durchlaeufe einlesen
Daten initialisieren
Schleife-ueber-max-Duchlaeufe
Naechste Runde der Simulation
Wenn sich was geaendert hat
Ausgabe Status Dorf
Wenn stabiler Zustand, Schleifen-Ende
53
Gibt es die in einem echten Dorf eigentlich?
Seite 247 / 409
Ausgabe warum Schleifen-Ende
Ein kleine Optimierung kann man noch vornehmen. todo
main
Anzahl Personen einlesen
Anzahl max. Durchlaeufe einlesen
Daten initialisieren
Schleife-ueber-max-Duchlaeufe
Naechste Runde der Simulation
Wenn sich was geaendert hat
Ausgabe Status Dorf
Wenn stabiler Zustand, Schleifen-Ende
Ausgabe warum Schleifen-Ende
Die weiteren Erklärungen folgen (hoffentlich) später – todo...
12.10.3 Zusammenfassung
Alles zusammen ergibt das damit folgendes Programm:
public class Utils {
try {
}
return "";
}
public static int readInt() {
try {
return Integer.parseInt(in);
}
return 0;
}
public static int digits(int arg) {
if (arg==0) return 1;
return (int)Math.log10(arg)+1;
}
// In java.text stehen verschiedene Format-Klassen zur Verfuegung,
// mit denen diese Aufgabe auch problemlos loesbar waere. Da wir
// diese Klassen aber nicht eingefuehrt haben, machen wie die
// Formatierung haendisch, und lernen dabei noch etwas programmieren.
public static String toString(int width, int value) {
StringBuffer sb = new StringBuffer(width);
int len = digits(value);
for (int i=0; i<width-len; i++) {
sb.append(' ');
}
return sb.toString() + value;
}
Seite 248 / 409
}
private static final int UNKNOWING = 1;
private static final int TELLING = 2;
private static final int CLOSEMOUTHED = 3;
private int state = UNKNOWING;
public void setTelling() {
state = TELLING;
}
public boolean isUnknowing() {
return state == UNKNOWING;
}
public boolean isTelling() {
return state == TELLING;
}
public boolean isClosemouthed() {
return state == CLOSEMOUTHED;
}
switch (state) {
case UNKNOWING:
System.out.print('_');
break;
case TELLING:
System.out.print('|');
break;
case CLOSEMOUTHED:
System.out.print('*');
break;
}
}
//
//
//
//
//
Diese Funktion waere auch tabellen-gesteuert moeglich.
Dann waere sie performanter. Aber so ist sie vielleicht
besser zu lesen fuer einen Programmier-Anfaenger. Deshalb
auch extra als Kommentar die - weil nicht notwendig - nicht
zugewiesenen Stati.
public static boolean meet(Person p1, Person p2) {
if (p1.isUnknowing() && p2.isUnknowing()) {
// p1.state = UNKNOWING;
return false;
}
if (p1.isUnknowing() && p2.isTelling()) {
p1.state = TELLING;
// p2.state = TELLING;
return true;
}
if (p1.isUnknowing() && p2.isClosemouthed()) {
// p2.state = CLOSEMOUTHED;
return false;
}
if (p1.isTelling() && p2.isUnknowing()) {
// p1.state = TELLING;
p2.state = TELLING;
return true;
}
if (p1.isTelling() && p2.isTelling()) {
p1.state = CLOSEMOUTHED;
return true;
Seite 249 / 409
}
if (p1.isTelling() && p2.isClosemouthed()) {
return true;
}
if (p1.isClosemouthed() && p2.isUnknowing()) {
return false;
}
if (p1.isClosemouthed() && p2.isTelling()) {
return true;
}
return false;
}
}
public class Village {
private Random rnd = new Random();
private int width;
private Person[] persons;
public Village(int count) {
width = Utils.digits(count);
persons = new Person[count];
for (int i=0; i<count; i++) {
persons[i] = new Person();
}
persons[0].setTelling();
}
public boolean next() {
int rnd1 = random();
int rnd2 = random();
while (rnd1 == rnd2) {
rnd2 = random();
}
return Person.meet(persons[rnd1], persons[rnd2]);
}
public boolean stableState() {
for (int i=0; i<persons.length; i++) {
if (persons[i].isTelling()) {
return false;
}
}
return true;
}
int unknowingCount = 0;
int tellingCount = 0;
int closemouthedCount = 0;
Person p = persons[i];
if (p.isUnknowing())
unknowingCount++;
if (p.isTelling())
tellingCount++;
if (p.isClosemouthed())
closemouthedCount++;
}
Seite 250 / 409
System.out.print(
"U(" + Utils.toString(width, unknowingCount) +
") E(" + Utils.toString(width, tellingCount) +
") S(" + Utils.toString(width, closemouthedCount) + ") ");
persons[i].print();
}
}
private int random() {
return rnd.nextInt(persons.length);
}
}
public class Appl {
System.out.println("Geruechtekueche\n===============\n");
System.out.print("Anzahl Personen: ");
int count = Utils.readInt();
if (count < 2) {
return;
}
System.out.print("Max Durchlaeufe: ");
int loops = Utils.readInt();
if (loops < 1) {
return;
}
Village v = new Village(count);
int width = Utils.digits(loops);
printLine(width, 0, v);
for (int i=0; i<loops; i++) {
if (v.next()) {
printLine(width, i + 1, v);
if (v.stableState())
break;
}
}
System.out.println("\nEnde wegen " +
(v.stableState() ? "stabilem Zustand" : "Erreichen max Durchlaeufe"));
}
private static void printLine(int width, int n, Village v) {
System.out.print(Utils.toString(width, n) + ": ");
v.print();
}
}
12.11 Lsg. zu Aufgabe „Tic-Tac-Toe 1“ – Kap. 12.8.3
Bei Tic-Tac-Toe ist der Programm-Ablauf stark durch die Spiel-Regeln geprägt: es wird
abwechselnd gezogen bis ein Spieler gewonnen hat oder das Spiel unentschieden zu Ende
gegangen ist. Dieser Ablauf legt die Grobstruktur des Programms fest.
Seite 251 / 409
12.11.1 Grobstruktur von „main“
Unter der Maßgabe, dass der Mensch „weiß“ spielt und damit anfängt, läßt sich der Ablauf von
Tic-Tac-Toe folgendermaßen beschreiben:
Endlos-Schleife über:
1. Mensch macht Zug
2. Ausgabe Spielbrett
3. Hat Mensch gewonnen?
Wenn ja, Meldung und Ende
4. Ist Remis?
5. Computer macht Zug
7. Hat Computer gewonnen?
8. --- (Remis Abfrage nicht notwendig)
Da das Tic-Tac-Toe Spielfeld 9 Felder hat, kann ein Remis nur nach dem menschlichen Zug
stattfinden, darum wird die Abfrage auf Remis nach dem Computer-Zug (Punkt 8) nicht
benötigt.
Diese Grobstruktur wirft sofort einige Fragen auf:
• Das Spielbrett muss angezeigt werden.
• Jemand muß wissen, wann das Spiel Remis ist.
• Jemand muß wissen, wann ein Spieler das Spiel gewonnen hat.
• Züge müssen berechnet, ausgeführt und verwaltet werden.
Eigentlich lassen sich die Fragen leicht beantworten:
• Für die Berechnung der Züge sind sicher der Mensch (im Programm vertreten durch ein
einfaches Benutzer-Interface) und der Computer zuständig - beide werden in
entsprechenden Klassen gekapselt.
=> Klasse „Human“ und „ComputerNext“
• Es ist sicher nicht Aufgabe eines Spielers, die Züge zu verwalten, Sieg und Remis zu
erkennen, oder das Spielbrett anzuzeigen. Statt dessen bietet sich eine Klasse an die das
Spielbrett darstellt, und über sich (Sieg, Remis, besetzte Felder, usw.) Bescheid weiß.
=> Klasse „Board“
Ohne an dieser Stelle der Programm-Analyse ins Detail zu gehen, lassen sich die ungefähren
Verantwortlichkeiten der Klassen schon darstellen:
12.11.1.1 Klasse „Board“
Verantwortlichkeiten:
• Verwaltung von Brett und der aktuellen Stellung.
• Erkennen von Sieg und Remis.
• Ausgabe auf der Konsole.
• Annahme eines neuen Zugs.
Abhängigkeiten:
Seite 252 / 409
• ---
12.11.1.2 Klasse „Human“
• Verwaltung seiner Spielfarbe.
In der ersten Version ist dies eigentlich nicht notwendig, da der Mensch hier immer „weiß“
hat. Aber auf Dauer wird das sicher änderbar sein sollen.
• Benutzer-Interaktion für die Eingabe des nächsten Zugs:
1. Zug eingeben (1..9)
2. Korrekte Eingabe? ja => weiter, nein => neue Eingabe (Sprung zu 1.)
3. Erlaubter Zug? (Feld unbesetzt?) ja => weiter, nein => neue Eingabe (Sprung zu 1.)
4. Zug zurück geben
- Für die Überprüfung auf erlaubten Zug (siehe 3.) wird der Element-Funktion von „Human“
das „Board“ als Parameter übergeben.
Abhängigkeiten:
• Klasse „Board“, da für die Interaktion abgefragt werden muß ob der eingegebene Zug
erlaubt ist oder nicht – d.h. das Feld schon besetzt ist oder nicht.
12.11.1.3 Klasse „ComputerNext“
• Verwaltung seiner Spielfarbe.
In der ersten Version ist dies eigentlich nicht notwendig, da der Computer hier immer
„schwarz“ hat. Aber auf Dauer wird das sicher änderbar sein sollen.
• Berechung des nächsten Zugs. In der ersten Version wird hier einfach nur das nächste leere
Feld zurückgegeben. Um das zu finden, wird der Element-Funktion von „ComputerNext“ das
„Board“ als Parameter übergeben.
Abhängigkeiten:
• Klasse „Board“, da für die Berechnung die aktuelle Stellung benötigt wird, und auch
abgefragt werden muß ob ein Feld schon besetzt ist oder nicht.
12.11.1.4 Klasse „Board“ II
Aus den Abhängigkeiten der Klassen „Human“ und „Computer“ ergibt sich, dass die Klasse
„Board“ Funktionen benötigt, um die aktuelle Stellung zu ermitteln und ob ein Zug erlaubt ist.
Da wir in dieser ersten Version keine wirklich gute Computer-Spiel-Strategie implementieren
wollen, und wir im Augenblick auch nicht überblicken können in welcher Form wir dafür die
aktuelle Stellung benötigen, beschränken wir uns auf die Abfrage ob ein Zug erlaubt ist.
12.11.1.5 Offene Frage
Nach dieser kurzen Analyse bleibt eigentlich nur noch eine Frage offen: „Wer führt den Zug
Seite 253 / 409
letztlich eigentlich durch?“
Lösungs-Vorschlag 1:
Man könnte das Board als Parameter an die Berechnungs-Funktionen von „Human“ und
„Computer“ geben, und diese geben den nächsten Zug nicht zurück, sondern setzen ihn direkt.
• Direktes Setzen des Zugs geht eigentlich über die Verantwortlichkeiten der Spieler Klassen
hinaus.
• Mit dieser Lösung würde man jede direkte Kontrolle über den Zug abgeben, da man ihn gar
nicht mehr richtig mitbekommt. Z.B. eine grafische Anzeige des Zugs oder vergleichbares
wären nur schwer integrierbar. Bedenken sie, dass sowas nicht zu den Zuständigkeiten von
„Human“ bzw. „ComputerNext“ gehören kann, da diese sonst in einem anderen UI nicht
benutzbar wären.
• Von meinem Gefühl her ist es nicht gut, dass eine Spieler-Klasse direkt am Brett
rummanipuliert. Nun ist ein Stück Software zwar nicht betrügerisch (ausser es ist so
programmiert), aber eine Spieler Klasse sollte nicht direkt am Brett manipulieren.
Lösungs-Vorschlag 2:
Man könnte dem Board die Spieler mitgeben, und das Board ruft die „nächster-Zug“ Funktion
auf, und setzt den zurückgegebenen Zug dann direkt.
• Dies würde Ringabhängigkeiten erzeugen: die Spieler kennen ja das Brett, und jetzt müßte
das Brett auch die Spieler kennen – sehr schlecht.
• Auch hier wäre die Kontrolle über den Zug – z.B. für eine grafische Rückkopplung – weg.
• Und hier bekommt das Brett viel zu viel Verantwortlichkeiten – es ist für das Brett und das
Umfeld zuständig, aber es soll nicht der aktive Part sein, der als zentrale Komponente das
Spiel am Laufen hält (und dazu würde es bei dieser Lösung zumindest ansatzweise werden).
Beide Lösungen – man legt das Setzen in die Spieler bzw. in das Brett – kommen nicht gut
weg. Also lassen wir das Setzen erstmal außerhalb beider Klassen in der Spielschleife liegen.
Damit hat die Haupt-Schleife auch alle Kontrolle über das Geschehen, z.B. für eine
Rückkopplung auf der Kommandozeile – und die wollen wir ja auch haben.
12.11.1.6 Erste Implementierung
Zuerst müssen wir die entsprechenden Objekte von Mensch, Computer und Brett in „main“
anlegen. Da die Spieler schon mal ihre Spielfarbe verwalten sollen, werden diese im
Konstruktor übergeben (Integer-Konstanten aus der Klasse „Board“54). Außerdem wird einmal
initial das Spielbrett ausgegeben.
public class Appl {
Achtung – ein typischer Fall, wo ein echter Aufzählungs-Typ (siehe Kapitel 12.6) besser
wäre. Da wir sie aber aus Zeitmangel nicht eingeführt haben, und sie auch erst seit JDK 1.5
verfügbar sind, lösen wir das Problem auf althergebrachte Weise mit Integer-KlassenKonstanten.
54
Seite 254 / 409
Board b = new Board();
Human pl1 = new Human(Board.WHITE);
ComputerNext pl2 = new ComputerNext(Board.BLACK);
b.print();
// Endlos-Schleife...
}
}
Als nächstes fügen wir die Schleife von oben hinzu – schauen wir uns nochmal den
Pseudocode an:
Endlos-Schleife über:
1. Mensch macht Zug
4. Ist Remis?
1. Mensch macht Zug
Nach unserer Überlegung müssen das jetzt drei Anweisungen sein:
• Objekt „Spieler“ gibt Zug zurück.
• Rückkopplung im CUI über den Zug.
• Setzen des Zugs am Spielbrett.
Um den Zug transportieren zu können, definieren wir eine entsprechende Klasse „Move“.
Achtung – wir benutzen hier nicht das Wissen, dass Spieler 1 im Augenblick immer der
Mensch ist, sondern formulieren den Code schon allgemein, um für spätere Erweiterungen
Erfahrungen zu sammeln und offener zu sein.
Move m = pl1.next(b);
System.out.println(pl1.getName() + " zieht " + m + '\n');
b.set(m);
Das kennen wir schon.
b.print();
Oben hatten wir festgelegt, dass das Brett die Informationen über den Spielstatus hält – damit
ist dieser Teil einfach hin zu schreiben. Wir übergeben aber die Spielfarbe an das Brett, damit
es weiss auf wessen Sieg es checken soll. Wir wissen hier natürlich, dass wenn hier einer
gewonnen hat, es nur der Mensch sein kann da er den letzten Zug gemacht hat. Aber im Sinne
von allgemeiner Formulierung ist es hier sicher besser allgemein zu bleiben. Das gleiche gilt für
die Ausgabe – hier fragen wir lieber allgemein den Spieler nach dem Namen statt ihn fest zu
verdrahten.
Seite 255 / 409
if (b.wins(pl1.getColor())) {
System.out.println(pl1.getName() + " hat gewonnen");
return;
}
4. Ist Remis?
Vergleichbar zu Punkt 3.
if (b.remis()) {
System.out.println("Das Spiel ist remis ausgegangen");
return;
}
Da die Punkte 1. bis 4. allgemein formuliert waren, kann der Code hierfür fast 1:1 kopiert
werden. Unterschiede sind nur, dass statt Spieler 1 Spieler 2 genommen wird, und die Abfrage
auf Remis entfällt.
m = pl2.next(b);
b.set(m);
b.print();
return;
}
Wenn wir jetzt davon ausgehen, dass es für alle benutzten Klassen „Move, Board, ...)
entsprechende Definitionen im gleichen Package gibt, und die Aufzählungs-Konstanten für die
Spielfarbe in Board definiert werden, ergibt sich der ganze Quelltext:
public class Appl {
Human pl1 = new Human(Move.WHITE);
ComputerNext pl2 = new ComputerNext(Move.BLACK);
b.print();
while (true) {
b.set(m);
b.print();
return;
}
if (b.full()) {
return;
}
m = pl2.next(b);
b.set(m);
b.print();
Seite 256 / 409
return;
}
}
}
}
Eine Bemerkung noch zum Schluss: dadurch dass wir die beiden Teile der Schleife für Mensch
und Computer so ähnlich gestaltet haben, haben wir 2 Vorteile gewonnen:
• Wir konnten den zweiten Teil quasi durch copy&paste erzeugen. Copy&Paste ist zwar nicht
so gut wie Code nur einmal wiederverwendbar schreiben (siehe Punkt 2), aber immer noch
viel besser als sich alles noch mal neu auszudenken.
• Weiter nach vorne gedacht, sehen wir in welche Richtung das Zusammenführen der beiden
Teile mal gehen könnte/muss. Auf Dauer kann es einfach nicht sein, dass wir zwei so
ähnliche Teile Code in unserem Tic-Tac-Toe behalten, und die nicht irgendwie
zusammenführen.
12.11.2 Die Rahmen der Klassen
Der nächste Schritt folgt zwangsläufig ohne echtes Nachdenken. Mit unserem „main“ haben wir
festgelegt welche Typen es gibt und wie ihre Schnittstelle aussieht. Das sollten wir erstmal
hinschreiben55.
12.11.2.1 Klasse „Move“
Eine Kleinigkeit muss hier noch überlegt werden, bevor die Rahmen quasi von alleine da sind.
Wie sieht die Klasse „Move“ aus?
Nun, ein Zug besteht letztlich aus zwei Koordinaten mit den Werten 0..2 mit denen das zu
setzende Feld definiert wird, und der Spielfarbe. Von daher würde eine einfache Klasse mit drei
Integer-Attributen (x,y und Farbe) für die Klasse „Move“ reichen.
Bevor wir die Klasse weiter durchdenken, muß ich auf einige Einwände eingehen, die sie
möglicherweise haben:
• Im Benutzer-Interface wird der Mensch einen Zug durch die Zahlen 1..9 eingeben. Ist ein
Zug also nicht einfach nur ein Integer?
Nein! Verfallen sie nie auf die Idee sich von einem Benutzer-Interface ihre interne
Repräsentation der Daten vorgeben zu lassen: die Zahlen 1..9 sind unsere augenblickliche
einfache Lösung zur Abbildung der Felder im Benutzer-Interface. In einem GUI benutzen sie
möglicherweise 9 Buttons um das Spielfeld abzubilden, die der Benutzer zum Setzen dann
direkt anklicken kann. Ist dann ein Zug etwa ein Button?
• Warum die Werte 0..2 und nicht 1..3?
Nun, gleiches Thema. Der Benutzer will vielleicht Koordinaten von 1..3 sehen,
möglicherweise aber auch a..c – keine Ahnung, das ist Sache des Benutzer-Interfaces.
Übrigens – Eclipse kann das fast von alleine für uns machen. Schauen sie sich mal die
Quick-Fixes von Eclipse an.
55
Seite 257 / 409
Intern arbeiten wir immer – wenn möglich – 0-basiert und mit Integer-Indices, da das
einfach, schnell, unproblematisch ist, und die Sprache und die Bibliotheken das auch überall
so machen.
• Aber warum dann nicht einfach nur einen Integer von 0..8? Das wäre doch einfacher?
Nun, ein Feld auf einem Spielbrett wird nun mal durch zwei Koordinaten beschrieben. Daher
steht zu erwarten, dass wir diese Repräsentation dauernd brauchen werden. Warum eine
andere wählen?
Und außerdem steht uns ja die Möglichkeit offen, auch noch ein zweite Schnittstelle für die
andere Repräsentation anzubieten.
Zurück zu unserer Klasse „Move“. Wir wissen jetzt, dass sie zwei Integer und die Farbe
enthalten soll, und das wir diese sicher abfragen können müssen. Da dies trivial ist,
implementieren wir die Funktionen auch direkt.
public class Move {
private int x;
private int y;
private int color;
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getColor() {
return color;
}
}
Erfüllt „Move“ damit wirklich alle Anforderungen, die aus der Main-Funktion resultieren? Nein!
Wir haben eine Stelle übersehen, da wir sie noch nicht verstehen.
Hier wird das Move-Objekt „m“ einfach so mit Strings verkettet und ausgegeben. Nun gut, wir
haben u.a. in Kapitel 9.1.2 gelernt, dass das immer geht. Aber wir wissen nicht, warum und wie.
Und da wir jetzt dort eingreifen müssen – wir wollen ja unsere spezielle Tic-Tac-Toe Ausgabe
des Zugs haben – müssen wir jetzt wissen, wo wir ran müssen.
In Kapitel 14.11.1 werden wir lernen, dass wir hierfür die Element-Funktion „toString“
implementieren müssen. Dort lernen wir auch, wie das funktioniert, und warum das immer
klappt. Hier soll uns genügen, dass wir „toString“ implementieren müssen (siehe Kapitel
12.11.4.1).
Also sieht der Rahmen von „Move“ jetzt so aus, und ist jetzt wirklich fertig.
public class Move {
private int x;
private int y;
Seite 258 / 409
private int color;
public int getX() {
return x;
}
public int getY() {
return y;
}
return color;
}
public String toString() {
return null;
}
}
12.11.2.2 Klasse „Board“
Der erste Wurf (der Rahmen) des Klasse „Board“ fällt jetzt eigentlich einfach so ab. Die beiden
Farb-Konstanten und alle augenblicklich bekannten öffentlichen Elementfunktionen sind ja
durch unser Hauptprogramm vorgegeben – zusätzlich definieren wir noch eine ElementFunktion „valid“, die aufgrund der Klassen „Human“ und „Computer“ – siehe Kapitel 12.11.1.2
und 12.11.1.3 – benötigt wird.
public class Board {
public static final int WHITE = 1;
public static final int BLACK = 2;
public Board() {
}
public void set(Move m) {
}
public boolean valid(Move m) {
return false;
}
public boolean remis() {
return false;
}
public boolean wins(int color) {
return false;
}
}
}
Achtung – wir machen uns hier noch keine Gedanken um die Implementierung von „Board“ –
das kommt später. Wir sorgen erstmal nur dafür dass unser Programm compiliert.
12.11.2.3 Klasse „Human“
Der Rahmen der Klasse „Human“ ergibt sich genauso automatisch.
Seite 259 / 409
public class Human {
public Human(int color) {
}
public Move next(Board b) {
return null;
}
return 0;
}
public String getName() {
return null;
}
}
12.11.2.4 Klasse „ComputerNext“
Na ja, und der Rahmen der Klasse „ComputerNext“ ist fast identisch.
public class ComputerNext {
public ComputerNext(int color) {
}
return null;
}
return 0;
}
return null;
}
}
12.11.2.5 Ergebnis
Jetzt sollte unser Programm problemlos compilieren. Mehr noch nicht – gestartet macht das
Verhalten des Programms wenig Sinn, da noch massenhaft Implementierungen fehlen.
12.11.3 Implementierung der Klassen
Jetzt geht’s ans implementieren der Klassen. Nur, mit welcher fängt man an?
Immer mit den unabhängigen Klassen, bzw. mit denen deren abhängige Klassen vorhanden
sind. In unserem Fall ist das die Klasse „Move“, da diese von nichts abhängt, die Spielfeld und
die Spieler-Klassen aber von ihr abhängen.
Warum wählt man diese Reihenfolge? Nun, der Grund ist, dass sie so eine Klasse erhalten, die
voll compilierbar, funktionstüchtig, lauffähig und testbar ist. Da sie ja von keiner anderen Klasse
abhängt, bzw. diese Klassen schon implementiert sind, können sie für diese Klasse ein TestProgramm schreiben, es compilieren und laufen lassen und damit die Klasse testen.
Seite 260 / 409
Umgekehrt geht das nicht. Würden sie in unserem Beispiel zuerst einen der Spieler entwickeln,
so würde die Klasse zwar compilieren (da wir ja zufälligerweise den Rahmen von „Move“ und
„Board“ schon fertig haben), aber sie könnten sie nicht testen. Damit würden sie in einem halbfertigen Zustand dann doch zu den Klassen „Move“ und „Board“ wechseln müssen, und erst
nachdem diese fertig sind (vollständig fertig, mit testem und allem) könnten sie an der SpielerKlasse weiter machen.
Okay – in der Praxis ist das meist nicht so schwarz/weiß. Sie benötigen für eine Klasse B nicht
die vollständige Klasse A. Und viele Anforderungen an A ergeben sich auch erst, wenn die
Klassen B und C A benutzen – und so wächst A parallel zu B und C. Aber jede dieser kleinen
Iterationen beginnt immer bei A.
12.11.4 Klasse „Move“
Die Klasse „Move“ ist eigentlich schon fertig, da wir mit dem Rahmen (siehe Kapitel 12.11.2.1)
auch direkt fast alle Element-Funktionen implementiert haben. Da sie alle einfache GetterFunktionen sind, war dies auch nicht weiter schwierig. Nur „toString“ fehlt noch.
12.11.4.1 Element-Funktion „Move.toString“
Was noch fehlt ist ein sinnvolle Darstellung eines Zugs auf der Konsole. Dazu müssen wir nur
die Element-Funktion „toString“ entsprechend implementieren, z.B. so:
return (3*x+y+1) + " - Feld " + (x+1) + '/' + (y+1);
}
Wie das alles funktioniert mit dieser automatischen String-Umwandlung, und warum wir
„toString“ implementieren müssen, und all das – das wird in Kapitel 14.11.1 erklärt.
12.11.4.2 Konstruktoren
Was der Klasse aber sicher noch fehlt, sind ein oder mehrere Konstruktoren. Ohne das wir
wissen, wie Objekte der Klasse später in „Human“, „ComputerNext“ oder sonst-wo erzeugt
werden, können wir schon sagen, dass es zwei mögliche Kandidaten gibt:
• Move(int x, int y, int c)
– x und y gehen von 0..2
Diese Variante enspricht unserer Denkweise mit x/y-Koordinate des Feldes und der
Spielfarbe. Die Indices gehen von 0..2, da wir intern immer 0-basiert arbeiten.
• Move(int field, int c)
– field geht von 0..8
Diese Variante ist ein Zugeständnis an unser erstes einfaches Benutzerinterface. Hier muss
der Wert 1..9 in die Felder 0..2/0..2 umgesetzt werden. Da dies möglicherweise öfter
vorkommt, implementieren wir diese Zerlegung zentral in der Klasse „Move“. Da intern aber
immer 0-basiert gerechnet wird, erwartet die Funktion einen Feld-Index von 0..8.
Da es nicht viel Arbeit ist, implementieren wir profilaktisch beide Konstruktoren. Man könnte mit
Seite 261 / 409
dieser Arbeit auch problemlos warten, bis sie denn wirklich gebraucht werden. So, im Vorfeld
implementiert, kann es halt passieren, dass die Schnittstelle doch nicht paßt, oder wir gar eine
Funktion implementieren, die wir dann doch nicht brauchen.
public Move(int n, int c) {
x = n/3;
y = n%3;
color = c;
}
public Move(int x, int y, int c) {
this.x = x;
this.y = y;
color = c;
}
12.11.4.3 Zusammenfassung
Damit ergibt sich der komplette Quelltext der Klasse „Move“.
Source „Move.java“
public class Move {
private int x;
private int y;
private int color;
public Move(int n, int c) {
x = n/3;
y = n%3;
color = c;
}
public Move(int x, int y, int c) {
this.x = x;
this.y = y;
color = c;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
return color;
}
return (3*x+y+1) + " - Feld " + (x+1) + '/' + (y+1);
}
}
12.11.5 Klasse „Board“
Nach „Move“ ist die nächst-tiefere Klasse „Board“, d.h. wird die als nächstes implementiert.
Seite 262 / 409
12.11.5.1 Spielfeld-Repräsentation und erweiterte Klassen-Definition von „Board“
Die erste Entscheidung, die zu treffen ist, ist: wie repräsentieren wir das Spielfeld in der
Klasse? Schauen wir uns mal die Anforderungen an das Spielfeld an:
• Wahlfreier Zugriff wird benötigt: zwei Indices definieren das Feld
• Sortierung wird nicht benötigt.
• Spielfeld benötigt keine dynamische Größe.
• Suchen findet nicht statt.
• Inhalte sollten nicht umsortiert werden – das Brett ist und bleibt wie es ist.
Gleichen wir dies mit unserem Java Wissen ab, dann sehen wir das ein normales 2-dim Array
die Anforderungen am Besten erfüllt.
Stellt sich noch die Frage, was wird der Inhalt des Arrays sein, d.h. wie repräsentieren wir im
Programm ein Feld bzw. den Status eines Feldes? Welche Zustände kann ein Feld annehmen?
• Leer
• Weißer Spielstein
• Schwarzer Spielstein
Das klingt nach einer Aufzählung mit Klassen-Konstanten56. Und Konstanten für die Spielfarben
sind schon vorhanden – ergänzen wir noch eine für ein leeres Feld.
Damit sind die Attribute und Klassen-Konstanten von „Board“ klar.
public static final int EMPTY = 1;
private int[][] field;
...
}
12.11.5.2 Attribut-Initialisierung und Konstruktor „Board“
Bei der Objekt-Initialisierung muss nur das Spielfeld aufgebaut werden, d.h. ein 3x3 Array, bei
dem alle Felder „Empty“ sind. Es gibt viele Arten dies zu machen, hier mache ich das mit einer
einfachen Attribut-Initialisierung. Der Konstruktor bleibt dadurch leer.
private static final int EMPTY = 1;
private static final int WHITE = 2;
private static final int BLACK = 3;
private int[][] field =
{ EMPTY, EMPTY, EMPTY
{
},
},
}
Achtung – noch ein Fall, wo ein echter Aufzählungs-Typ (siehe Kapitel 12.6) besser wäre. Da
wir sie aber aus Zeitmangel nicht eingeführt haben, und sie auch erst seit JDK 1.5 verfügbar
sind, lösen wir das Problem auf althergebrachte Weise mit Integer-Klassen-Konstanten.
56
Seite 263 / 409
};
public Board() {
}
...
}
12.11.5.3 Element-Funktion „Board.set“
Die Elementfunktion „set“ bekommt einen Zug übergeben und setzt ihn.
Hierbei gibt es ein Thema, über das man zumindest kurz nachdenken sollte: Was passiert,
wenn als Zug ein Feld übergeben wird, das schon besetzt ist? Wir definieren hier für den ZugParameter, dass ein solcher Parameter nicht erlaubt ist. An dieser Stelle ist das eine
akzeptable Forderung, da im Rahmen des „main“-Designs die von den Spielern „berechneten“
Züge regelkonform sein müssen.
Trotzdem sollten wir uns darüber im klaren sein, dass ein Programmier-Fehler in den SpielerKlassen hier zu einem Problem führen kann. Solchen Situationen kann man z.B. mit Assertions
begegnen, die wir aber aus Zeitmangel im Rahmen des Tutorials nicht besprechen.
field[m.getX()][m.getY()] = m.getColor();
}
12.11.5.4 Element-Funktion „Board.valid“
Die Elementfunktion „valid“ soll zurückgeben, ob ein Spielzug erlaubt ist, d.h. das Feld noch
unbesetzt ist.
return field[m.getX()][m.getY()]==EMPTY;
}
12.11.5.5 Element-Funktion „Board.remis“
Die Element-Funktion „remis“ soll zurückgeben, ob das Spiel remis ausgegangen ist. Die erste
Idee das zu lösen, ist ganz einfach: es müssen alle Felder besetzt sein.
boolean remis() {
for (int x=0; x<3; ++x) {
for (int y=0; y<3; ++y) {
if (field[x][y]==EMPTY) return false;
}
}
return true;
}
Aber dann denken wir noch mal darüber nach. Diese Funktion gibt auch dann „true“ zurück,
wenn das Spielfeld voll ist, aber ein Spieler gewonnen hat. Hier wird nämlich nicht auf Remis
untersucht, sondern auf „Erzwungendes-Spielende wegen vollem Feld“. Also eigentlich müßten
wir vorher abfragen, ob kein Spieler gewonnen hat – erst dann arbeitet die Funktion korrekt.
Seite 264 / 409
boolean remis() {
if (wins(WHITE) || wins(BLACK)) {
return false;
}
for (int x=0; x<3; ++x) {
for (int y=0; y<3; ++y) {
}
}
return true;
}
Wenn wir uns jetzt aber unser Haupt-Programm vor Augen führen, dann sehen wir, dass das
nicht das ist, was wir wollten. Uns ging es schon um das erzwungende Spielende, wenn das
Brett voll ist, denn einen möglichen Sieg hatten wir vorher schon abgehandelt.
return;
}
if (b.remis()) {
return;
}
Jetzt haben wir zwei Möglichkeiten:
1. Wir akzeptieren die obige aufwendigere „remis“ Funktion, selbst wenn dort Abfragen
gemacht werden, die in unserem Programm nicht notwendig sind.
2. Oder wir bleiben bei der ersten Variante, benennen die Funktion aber um.
Achtung – kommen Sie bitte nicht auf die Idee, den Namen bei „remis“ zu belassen, aber von
der Funktionalität her „Brett-voll“ zu implementieren – die Funktion macht dann nicht mehr das,
was der Name verspricht. Irgendwann wird sich das rächen. Man muss nur im HauptProgramm die Abfrage-Reihenfolge von „wins“ und „remis“ verändern, und schon hat man den
Salat. Aus Sicht des Haupt-Programms wäre dann noch alles okay – in der Praxis leider nicht.
Ich persönlich habe mich für Möglichkeit 2 entschieden, d.h. ich nehme unsere erste einfachere
Variante der Element-Funktion, und benenne sie in „full“ um. Denn das liefert sie zurück: ob
das Brett voll ist.
public boolean full() {
for (int x=0; x<3; ++x) {
for (int y=0; y<3; ++y) {
}
}
return true;
}
Hinweis – wenn ich jetzt doch noch eine Element-Funktion „remis“ benötige, dann würde ich
sie jetzt auf Basis von „wins“ und „full“ ganz einfach implementieren können. So habe ich zwei
Fliegen mit einer Klappe geschlagen: zur Zeit keine überflüssigen Implementierungen, und auf
Dauer einfache verständliche Funktionen. So z.B. könnte „remis“ dann aussehen:
boolean remis() {
if (wins(WHITE) || wins(BLACK)) {
return false;
Seite 265 / 409
}
return full();
}
12.11.5.6 Element-Funktion „Board.wins“
Die Element-Funktion „wins“ soll zurückgeben, ob der Spieler der übergebenen Farbe
gewonnen hat. Möglicherweise gibt es einen tollen Algorithmus um das schnell und kurz zu
checken – wenn ja, so kenne ich ihn nicht. Und ich hatte auch keine Lust mir groß Gedanken
darum zu machen – acht mögliche Gewinnstellungen kann ich auch schnell bruce-force
durchtesten.
public boolean wins(int
if (field[0][0]==c &&
if (field[1][0]==c &&
if (field[2][0]==c &&
if (field[0][0]==c &&
if (field[0][1]==c &&
if (field[0][2]==c &&
if (field[0][0]==c &&
if (field[0][2]==c &&
return false;
}
c) {
field[0][1]==c
field[1][1]==c
field[2][1]==c
field[1][0]==c
field[1][1]==c
field[1][2]==c
field[1][1]==c
field[1][1]==c
&&
&&
&&
&&
&&
&&
&&
&&
field[0][2]==c)
field[1][2]==c)
field[2][2]==c)
field[2][0]==c)
field[2][1]==c)
field[2][2]==c)
field[2][2]==c)
field[2][0]==c)
return
return
return
return
return
return
return
return
true;
true;
true;
true;
true;
true;
true;
true;
12.11.5.7 Element-Funktion „Board.print“
Die Element-Funktion „print“ soll das Spielfeld ausgeben. Kein Problem – zwei geschachtelte
for-Schleifen für das 2-dim Array und darin eine switch-Anweisung für die jeweiligen FeldAusgaben.
for (int x=0; x<3; ++x) {
for (int y=0; y<3; ++y) {
switch (field[x][y]) {
case EMPTY:
break;
case WHITE:
System.out.print('O');
break;
case BLACK:
System.out.print('X');
break;
}
}
}
}
Damit ergibt sich der komplette Quelltext der Klasse „Board“.
Source „Board.java“
public static final int EMPTY = 1;
Seite 266 / 409
private int[][] field =
};
{
},
},
}
public Board() {
}
field[m.getX()][m.getY()] = m.getColor();
}
return field[m.getX()][m.getY()]==EMPTY;
}
public boolean full() {
for (int x=0; x<3; ++x) {
for (int y=0; y<3; ++y) {
}
}
return true;
}
public boolean wins(int
if (field[0][0]==c &&
if (field[1][0]==c &&
if (field[2][0]==c &&
if (field[0][0]==c &&
if (field[0][1]==c &&
if (field[0][2]==c &&
if (field[0][0]==c &&
if (field[0][2]==c &&
return false;
}
c) {
field[0][1]==c
field[1][1]==c
field[2][1]==c
field[1][0]==c
field[1][1]==c
field[1][2]==c
field[1][1]==c
field[1][1]==c
&&
&&
&&
&&
&&
&&
&&
&&
field[0][2]==c)
field[1][2]==c)
field[2][2]==c)
field[2][0]==c)
field[2][1]==c)
field[2][2]==c)
field[2][2]==c)
field[2][0]==c)
return
return
return
return
return
return
return
return
true;
true;
true;
true;
true;
true;
true;
true;
for (int x=0; x<3; ++x) {
for (int y=0; y<3; ++y) {
switch (field[x][y]) {
case EMPTY:
break;
case WHITE:
System.out.print('O');
break;
case BLACK:
System.out.print('X');
break;
}
}
}
}
}
12.11.6 Klasse „Human“
12.11.6.1 Erweiterte Klassen-Definition von „Human“
Bzgl. der Attribute der Klasse „Human“ fällt erstmal nur auf, dass sie sich die Spielfarbe merken
Seite 267 / 409
muss.
private int color;
...
}
12.11.6.2 Attribut-Initialisierung und Konstruktor „Human“
Der Konstruktor muss einfach nur das Attribut mit der übergebene Spiel-Farbe initialisieren.
private int color;
public Human(int c) {
color = c;
}
...
}
12.11.6.3 Element-Funktion „Human.getColor“
Die Element-Funktion „getColor“ soll nur die Spiel-Farbe zurückgeben – trivial.
return color;
}
12.11.6.4 Element-Funktion „Human.getName“
Die Element-Funktion „getName“ soll den Namen des Spielers zurückgeben – auch trivial.
return "Mensch";
}
12.11.6.5 Element-Funktion „Human.next“
Die einzige Funktion der Klasse „Human“ in der wirklich was passiert, ist die Element-Funktion
„next“. Sie ist auch relativ kompliziert – was aber nicht an der eigentlichen Funktionalität liegt,
sondern daran dass in ihr Benutzer-Interaktion statt findet – und „Fehlertolerantes Einlesen ist
einfach der pure Spass!“.
Bevor wir anfangen zu implementieren lassen sie uns kurz überlegen, was in „next“ passieren
muss:
1. Ausgabe „Bitte Zug eingeben“
2. Benutzer-Eingabe 1..9
3. Korrekte Eingabe? Wenn nein, Fehlerhinweis und zurück zu 1.
4. Eingabe in Zug wandeln
5. Freies Feld? Wenn nein, Fehlerhinweis und zurück zu 1.
6. Rückgabe des Zugs
Seite 268 / 409
Man sieht, dass man hier eine Endlos-Schleife benötigt, die im Falle einer richtigen Eingabe
abgebrochen wird.
...
while (true) {
System.out.print("Bitte machen Sie ihren Zug (1..9): ");
try {
int field = Integer.parseInt(in);
if (field<1 || field>9) {
System.out.println("Fehlerhafte Eingabe!\n");
continue;
}
Move m = new Move(field-1, color);
if (b.valid(m)) {
return m;
}
System.out.println("Feld schon besetzt!\n");
}
}
}
}
}
Damit ergibt sich der komplette Quelltext der Klasse „Human“.
Source „Human.java“
private int color;
public Human(int c) {
color = c;
}
return color;
}
return "Mensch";
}
Seite 269 / 409
while (true) {
System.out.print("Bitte machen Sie ihren Zug (1..9): ");
try {
int field = Integer.parseInt(in);
if (field<1 || field>9) {
continue;
}
Move m = new Move(field-1, color);
if (b.valid(m)) {
return m;
}
System.out.println("Feld schon besetzt!\n");
}
}
}
}
}
12.11.7 Zwischenstand
Hiermit könnten sie jetzt schon das Tic-Tac-Toe eingeschränkt zum Laufen bringen. Sie
ersetzen im Haupt-Programm einfach den Computer-Spieler durch einen zweiten menschlichen
Spieler, und schon ist der Computer das Spielfeld für zwei Menschen beim Tic-Tac-Toe.
public class Appl {
Human pl2 = new Human(Move.BLACK);
// <<<<<<<<<<<<<< Aenderung
b.print();
...
}
}
12.11.8 Klasse „ComputerNext“
Die erste Implementierung eines Computer-Spielers wird ganz einfach ausfallen – der
Computer wird einfach das erste leere Feld nehmen.
Das Attribut „color“ und die Element-Funktionen „ComputerNext.getColor“ und
„ComputerNext.getName“ werden analog zur Klasse „Human“ sein – d.h. können wir hier auf
die Herleitung verzichten.
12.11.8.1 Element-Funktion „ComputerNext.next“
Damit bleibt als einzige Funktion mit etwas Aufwand die Element-Funktion „next“ über. Aber
auch diese ist nicht schwer.
Der Computer soll einfach das erste freie Feld nehmen, dass heisst wir müssen einfach nur die
Seite 270 / 409
Felder durchprobieren, und den ersten erlaubten Zug zurückgeben. Da wir in der Klasse „Move“
u.a. einen Konstruktor implementiert haben, der mit einem Feld-Index auskommt, können wir
uns hier auf eine Schleife beschränken, statt zwei verschachtelte Schleifen implementieren zu
müssen.
for (int i=0; true; i++) {
Move m = new Move(i, color);
if (b.valid(m)) {
return m;
}
}
// <-- keine Rueckgabe noetig, da man hier nicht hinkommen kann
}
Auch hier verlassen wir uns wieder darauf, dass das Spiel in der Gesamtheit sauber und
fehlerfrei programmiert ist. Wir ignorieren das Problem: welchen Zug geben wir zurück, wenn
es kein freies Feld mehr gibt – da dieses in der Praxis nicht vorkommen dürfte.
Da – unter dieser Bedingung – spätestens beim Feld-Index „8“ ein freies Feld gefunden werden
muß, können wir uns die Abbruch-Bedingung sparen. Damit wird die Stelle hinter den Schleifen
nie erreicht werden können. Das erkennt der Compiler, und verlangt daher dort von uns auch
keine Rückgabe – wir würden eh nur sinnloses Zeug dort hinschreiben können.
Damit ergibt sich der komplette Quelltext der Klasse „ComputerNext“.
Source „ComputerNext.java“
public class ComputerNext {
private int color;
public ComputerNext(int c) {
color = c;
}
return color;
}
return "Computer (naechstes freies Feld)";
}
Move m = new Move(i, color);
if (b.valid(m)) {
return m;
}
}
}
}
Seite 271 / 409
12.11.9 Fazit
Das Programm ist fertig. Natürlich gibt es noch eine Menge offener Wünsche – diese ergeben
sich zum größten Teil aber aus der Aufgaben-Stellung: das Programm hat kein GUI, der
Computer spielt ziemlich dumm spielt, die Gegner liegen fest, der Mensch beginnt immer, usw.
Wirklich unschön an dem Programm sind eigentlich nur wenige Dinge:
• Die Schleife im Haupt-Programm enthält zweimal fast den gleichen Code.
• Es gibt keine saubere Trennung von Benutzer-Oberfläche und Programm-Logik.
• Das Programm enthält viele implizite Annahmen – siehe z.B. Kapitel 12.11.5.3.
In den nächsten Kapiteln werden wir die ersten beiden Unschönheiten beseitigen und das TicTac-Toe gleichzeitig um einige Features bereichern. Um angemessen mit impliziten Annahmen
und darauf basierenden Fehlern umgehen zu können, müßten wir uns mit Assertions
auseinander setzen – dies wird leider im Rahmen der Vorlesung aus Zeitmangel nicht gemacht.
Wenn sie sich das gesamte Programm mal anschauen, so sollten sie eins bemerken. Jede
Klasse ist genau für eine Sache zuständig, und die meisten Funktionen sind ziemlich einfach
und erledigen genau eine Aufgabe. Kompliziert und aufwändig sind nur die Funktionen, die
Benutzer I/O machen – vor allem Benutzer-Eingabe. Dies ist nicht ungewöhnlich.
• Durch ein sauberes OO-Design (OOD) erhält man klare überschaubare Abstraktionen, und
die Klassen und Funktionen bleiben einfach, klein und übersichtlich.
• Benutzer I/O dagegen, und hier vor allem die Eingabe ist nicht trivial. Denn Benutzer können
allen möglichen Blödsinn eingeben, d.h. die Eingabe muss fehlertolerant sein und gute
Meldungen liefern. Dies ist nicht imnmer trivial.
13 Packages
Packages sind neben Klassen das zweite Modul-Konzept von Java. Während Klassen
wiederverwendbare Komponenten darstellen und einen Aspekt der realen Welt abbilden, sind
Packages ein reines Strukturierungsmittel, das konzeptionell zusammengehörige Klassen zu
einer Einheit verbindet.
13.1 Package-Anweisung
In Java ist jede Klasse automatisch Bestandteil eines Packages - indem sie eine .java Datei mit
einer Package-Anweisung wie z.B. „package packagename;“ beginnen, geben sie automatisch
das Package an, zu dem die Klasse gehört.
package mypackage;
// Package Anweisung
public class A {
}
// Die Klasse A liegt jetzt im Package „mypackage“
Achtung – eine Package-Anweisung muss immer die erste Anweisung in einem Quelltext sein.
Seite 272 / 409
Daher vorher darf es nur Kommentar- und Leerzeilen geben.
Hinweis – Klassen in Quelltexten ohne Package-Anweisungen liegen im sogenannten DefaultPackage – siehe Kapitel 13.5.
Hinweis – denken sie daran, dass jedes Package auf der Datei-Systeme-Ebene einem
Verzeichnis entsprechen muss – siehe auch Kapitel 3.8, Kapitel 4.2 bzw. Kapitel 4.3.2.
Hinweis – per Konvention sollten Package Namen immer klein beginnen und klein geschrieben
werden, z. B.: „nameeinespackage“ – siehe auch Kapitel 3.2.5.
13.2 Klassen in Packages
Der vollständige Name einer Klasse ist nicht nur der Klassen-Name, sondern beinhaltet auch
den bzw. die Package-Namen, durch den Punkt-Operator getrennt – Beispiel „java.util.Date“.
Dies wird auch der „vollständig-referenzierte“ oder auch der „vollständig-qualifizierte“ Name
genannt.
Um eine Klasse zu benutzen gibt es drei Möglichkeiten:
• Benutzung des vollständig qualifizierten Namens.
• Benutzung einer Import-Anweisung für die Klasse.
• Benutzung einer Import-Anweisung für das gesamte Package der Klasse.
13.2.1 Benutzung des vollständig qualifizierten Namens
Sie können immer jede Klasse über ihren voll referenzierten Namen ansprechen.
java.util.Date d = new java.util.Date();
13.2.2 Benutzung einer Import-Anweisung
Sie können eine Klasse in den Namensraum ihrer Datei importieren. Dafür können sie mit dem
Schlüsselwort „import“ Import-Anweisungen an den Anfang ihrer Datei schreiben. ImportAnweisungen müssen nach der Package-Anweisung stehen, wenn eine solche vorhanden ist.
Aber sie müssen vor jeder Klassen- oder Interface-Definition erfolgen.
Mit import und exakt referenzierter Klasse importieren sie eine Klasse:
import java.util.Date;
...
Date d = new Date();
Alternativ können sie mit einer Import-Anweisung auch alle Symbole eines Package in den
Namensraum ihrer Datei importieren. Hierfür muss statt des Klassen-Namens in der ImportAnweisung ein „*“ angegeben werden.
Seite 273 / 409
import java.util.*;
...
Date d = new Date();
Vector v = new Vector();
13.2.3 Klassen im gleichen Package
Klassen im gleichen Package brauchen weder importiert noch vollständig qualifiziert werden –
sie sind immer automatisch bekannt und können einfach durch Benutzung des KlassenNamens angeprochen werden – siehe z.B. Bsp. todo.
13.3 Language-Package
Z. B. die Klassen String und Object sind Teil des Packages java.lang, trotzdem konnten wir sie
benutzen57 ohne dieses Package importiert zu haben.
Das Package java.lang wird immer automatisch importiert, ohne dass Sie sich darum kümmern
müssen.
13.4 Verschachtelung
Packages können natürlich wieder in einander verschachtelt sein. Wollen Sie z. B. eine Klasse
Model dem Package generator im Package report zuordnen, so müssen sie nur folgende
package-Anweisung am Anfang Ihrer Datei Model.java unterbringen:
package report.generator;
Wollen sie diese Klasse in einem anderen Package nutzen, so haben sie natürlich folgende
drei Möglichkeiten:
report.generator.Model m = new report.generator.Model();
import report.generator.Model;
...
Model m = new Model();
import report.generator.*;
...
Model m = new Model();
13.5 Default-Package
Und was passiert, wenn sie keine Package-Anweisung benutzen? Nichts - auch das ist
korrekter Code.
57
Falls Ihnen nicht klar ist, das Sie Object benutzt haben - denken Sie daran, dass Object
automatisch die Basisklasse einer Klasse ist, wenn keine andere explizit angegeben ist.
Seite 274 / 409
Für kleinere Projekte bzw. schnelle Tests wurde zur Arbeitserleichterung in Java das Feature
eingeführt, dass in diesem Fall alle diese Klasse in einem Default-Package der
Entwicklungsumgebung landen. Sie brauchen auch keinen import-Anweisung anzugeben - das
Default-Package wird immer automatisch importiert.
Dem Java-Compiler ist die physikalische Realisation des Default-Packages übrigens freigestellt
- er braucht nur eins, kann aber auch mehrere Packages anlegen und diese dann über mehrere
Unterverzeichnisse zu verteilen.
13.6 Verzeichnisse
Packages müssen physikalisch auf der Platte durch Unterverzeichnisse abgebildet werden.
Eine Klasse „first.second.third.ClassName“ muss also in einer Datei „ClassName.java“ in den
Verzeichnis-Struktur „first/second/third“ liegen.
Moderne Entwicklungsumgebungen wie z.B. Eclipse können die notwendige VerzeichnisStruktur automatisch im Hintergrund erzeugen, und legen z.B. neue Dateien automatisch richtig
ab.
14 Vererbung
14.1 Vererbungs-Hierarchien
Vererbung bedeutet "ist ein".
Abb. 14-1 : Vererbungs-Hierarchie
Voraussetzung für öffentliche Vererbung ist immer eine ist-ein Beziehung.
Allgemein:
Abb. 14-2 : Allgemeine Vererbungs-Hierarchie
Hierbei ist:
• A Basisklasse (von B und C)
• B ist abgeleitet von A => B ist ein A => alles was für A gilt, gilt auch für B
• C ist abgeleitet von A => C ist ein A => alles was für A gilt, gilt auch für C
In Richtung der abgeleiteten Klassen findet eine Spezialisierung statt:
• B ist eine Spezialisierung von A
• Ein Pferd ist eine Spezialisierung eines Säugetiers
• Alles, was für Säugetiere gilt (z. B. geboren werden, schwanger sein, sterben), gilt auch für
Pferde. All diese Attribute und Funktionen erbt Pferd von Säugetier.
Seite 275 / 409
In Richtung der Basis-Klassen findet eine Generalisierung oder Verallgemeinerung statt
- Basis-Klassen fassen gemeinsame Dinge der abgeleiteten Klassen zusammen:
• A enthält alle Gemeinsamkeiten von B und C
• Vogel enthält alles Vogel-typische, unabhängig, ob es sich um eine Amsel oder eine Möve
handelt.
Hinweise
• Abgeleitete Klassen (z. B. B und C) sind unabhängig voneinander.
• Von einer Klasse können beliebig viele andere Klassen abgeleitet werden.
• Eine Klasse hat immer nur eine Basisklasse (Einfachvererbung58).
Achtung
Unterscheiden sie zwischen ”hat ein” bzw. ”ist implementiert mit” und ”ist ein”.
• Eine Person hat einen Namen, ist aber kein Name => Aggregation, Komposition, ...
• Eine Person ist ein Lebewesen, immer ohne wenn und aber => Vererbung
14.2 Implementation
Wie wird Vererbung in Java implementiert?
Syntax
[Modifier] class klassenname extends Basisklasse { Klassen-Definition }
public class A {
public void afct() {
System.out.println("afct in A");
}
}
public class B extends A {
public void bfct() {
System.out.println("bfct in B");
}
}
// Normales A Verhalten
A a = new A();
a.afct();
// Normales B Verhalten
B b = new B();
b.bfct();
// Aber B ist auch ein A, darum 'kann' es alles, was A 'kann'
b.afct();
// Ausgabe: afct in A
58
Es gibt viele objektorientierte Sprachen, die auch Mehrfachvererbung unterstützen.
Seite 276 / 409
Abb. 14-3 : Vererbungs-Hierarchie des Beispiels
An diesem Beispiel sehen sie, dass die Klasse B alle Funktionen von A erbt, d.h. sie ohne
weitere Schreibarbeit zur Verfügung stehen. Jede Änderung in A wirkt sich damit sofort auch
auf B (und natürlich alle weiteren abgeleiteten Klassen) aus.
Und sie sehen, dass die Klasse B das Verhalten (Methoden) von A erbt, d.h. sie ohne weitere
Schreibarbeit zur Verfügung stehen. Jede Änderung in A wirkt sich damit sofort auch auf B
(und natürlich alle weiteren abgeleiteten Klassen) aus.
14.3 Schlüsselwort super
In jeder Element-Funktion steht das Schlüsselwort super zur Verfügung, das immer für den
Objektanteil der Basisklasse des aktuellen Objektes steht59. Beispiel siehe z. B. Konstruktoren.
14.4 Konstruktoren
Konstruktoren werden in Java nicht vererbt. Dies macht auch keinen Sinn, da ein Konstruktor
immer das erzeugte Objekt initialisieren soll - ein geerbter Konstruktor aber nur den
Objektanteil der Basisklasse initialisieren kann. Sie müssen daher für jede Klasse wieder neu
Konstruktoren erstellen.
Die Konstruktoren der abgeleiteten und der Basis-Klasse sind automatisch miteinander
verkettet, d.h. jeder Konstruktor einer abgeleiteten Klasse ruft als erstes defaultmäßig den
Standard-Konstruktor der Basisklasse auf.
public class A {
public A() {
System.out.println("Konstruktor A");
}
}
public B() {
System.out.println("Konstruktor B");
}
}
B b = new B();
Ausgabe
Konstruktor A
Konstruktor B
Sie sehen, dass als erstes automatisch der Standard-Konstruktor der Basisklasse aufgerufen
wird. Wollen sie, dass ein anderer Konstruktor für die Basisklasse benutzt wird, können sie
59
Ähnlich wie this, das immer für das komplette aktuelle Objekt steht (siehe Kapitel 12.4.3).
Seite 277 / 409
diesen am Anfang des Konstruktors der abgeleiteten Klasse mit super angeben.
public class A {
public A(int i) {
System.out.println("Konstruktor A mit " + i);
}
}
public B() {
super(11);
System.out.println("Konstruktor B");
}
}
Ausgabe
Konstruktor A mit 11
Konstruktor B
Wenn die Basisklasse keinen Standard-Konstruktor hat, so müssen sie in den abgeleiteten
Konstruktoren mit super einen Konstruktor angeben.
Sie können in einem Konstruktor mit this auch einen anderen Konstruktor der Klasse
anspringen, der dann einen Konstruktor der Basisklasse aufruft.
Achtung – die Verwendung von überschriebenen (s.u.) Element-Funktionen in Konstruktoren
ist gefährlich, da die Oberklassen-Anteile noch nicht konstruiert sind.
14.5 finalize
Finalize Funktionen (siehe Kapitel 12.3) werden in Java nicht automatisch verkettet. Wenn sie
dies erreichen wollen, so müssen sie in der finalize Funktion die finalize Funktion der
Basisklasse selber aufrufen.
super.finalize();
}
}
14.6 Überschreiben
Funktionen von Klassen können in abgeleiteten Klassen überschrieben werden, d.h. sie können
für eine abgeleitete Klasse neu definiert werden (gleicher Name, gleiche Parameterliste).
public class A {
public void fct() {
System.out.println("fct in A");
}
}
Seite 278 / 409
public void fct() {
System.out.println("fct in B");
}
}
A a = new A();
a.fct();
B b = new B();
b.fct();
// fct in A
// fct in B
Auf die Art und Weise kann eine nicht passende Implementierung einer Basisklasse in einer
abgeleiteten Klasse neu implementiert, d. h. überschrieben werden. Ein Beispiel wäre die
Methode berechneGehalt in einer Klasse Angestellter und in der abgeleiteten Klasse Vertreter.
Ein Vertreter ist sicherlich auch ein Angestellter, d.h. für ihn gelten die Methode getName,
getPersonalNo(),..., aber das Gehalt wird bei Vertretern oft anders berechnet.
Oft ist es so, dass die Basisklassen Implementierung gar nicht so schlecht ist, aber eben nicht
100 % passt. Vielleicht bekommt der Vertreter zusätzlich zu einem Festgehalt nur noch einen
variablen Anteil hinzu – in diesem Fall wäre die Basisklassen Implementierung ja nicht falsch,
sondern eben nur ein Teil der korrekten Implementierung. Darum ist es oft sinnvoll in einer
Neu-Implementierung auf die Basisklassen Implementierung zurückzugreifen. Hierbei gibt es
zwei ‚reine‘ Formen (Korrektur und Filterung), aber natürlich auch beliebige Mischformen.
14.6.1 Korrektur
Falls das Ergebnis der Basisklassen-Elementfunktion nicht 100% passend ist, kann es in einer
abgeleiteten Klasse korrigiert werden – denken sie an das Vertreter Beispiel von oben.
Prinzip
void f() {
super.f();
// Korrektur
}
// expliziter Aufruf der Original-Elementfunktion
// Korrektur des Ergebnisses
14.6.2 Filterung
Falls die Basisklassen-Elementfunktion nicht alle Fälle (korrekt) behandelt, können diese vorher
abgefangen und behandelt werden.
Prinzip
void f() {
// Filterung
super.f();
}
// Filterung mancher Faelle
// expliziter Aufruf der Original-Elementfunktion
Die Filterung bezieht sich häufig auf die Übergabeparameter.
Seite 279 / 409
14.7 Ist-ein Beziehung
Eine Konsequenz aus der Semantik ‘Vererbung ist eine ist-ein Beziehung’ ist, dass einer
Referenz-Variablen der Basisklasse auch ein Objekt einer abgeleiteten Klasse zugewiesen
werden kann.
// Klasse B ist von A abgeleitet
A a1 = new A();
A a2 = new B();
Dies ist ganz im Sinne der Semantik. Ist-ein heisst, dass für ein B Objekt alles gilt, was für ein
A Objekt gilt - und daher ein B Objekt auch das Interface von A unterstützt.
Bemerkung - falls sie das Ganze etwas verwundert, machen sie sich mal von der ganzen
Computerei frei, und betrachten das Ganze mit einem normalen Beispiel: Wenn sie z.B. auf
einen Stuhl zeigen und sagen „das ist ein Stuhl“, dann wird ihnen wohl niemand widersprechen.
Aber auch die Aussage „das ist ein Möbelstück“ wäre ohne Frage richtig. Und genau das
gleiche passiert hier: Die Referenz-Variable „a2“ sagt mit ihrem statischen Typ „A“ das sie ein
Möbelstück referenziert (darauf zeigt), obwohl sie doch in Wirklichkeit einen Stuhl (ein Objekt
vom Typ „B“) referenziert (darauf zeigt). Aber daran ist nichts falsches und unwahres - sie sagt
nur nicht alles. Aber in vielen Kontexten reicht das. Wir sagen zu unserem Besuch auch „Nimm
dir einen Stuhl“, und lassen offen ob er sich in einen Sessel, die gute Coach oder den normalen
Holzstuhl setzen soll. Warum auch? Im Prinzip würde es sogar reichen zu sagen „Nimm doch
bitte Platz“.
Hinweis - man unterscheidet daher auch in den sogenannten statischen und den dynamischen
Typ.
• Der statische Typ ist der Typ der Referenz-Variablen. Diesen Typ sieht der Compiler, da er
ohne wenn und aber zur Compilezeit feststeht und eindeutig bekannt ist - er steht ja als Typ
an der Definition der Referenz-Variablen. Im Beispiel ist dies der Typ “A“ der ReferenzVariablen „a1“ und „a2“.
• Dem gegenüber ist der dynamische Typ der echte Typ des Objekts, auf das verwiesen wird.
Dieser ist zur Compilezeit nicht zwingend bekannt, und muß nicht dem statischen Typ
entsprechen. Im Beispiel ist der dynamische Typ des von „a1“ referenzierten Objekts „A“,
während es bei „a2“ „B“ ist.
14.8 Polymorphie
Überschreiben und ist-ein-Beziehung zusammen ermöglichen ein Feature, das das
Schlüsselkonzept aller OO Sprachen ist: Polymorphie.
public class A {
public void fct() {
System.out.println("fct in A");
}
Seite 280 / 409
}
public void fct() {
System.out.println("fct in B");
}
}
A a1 = new A();
A a2 = new B();
a1.fct();
// fct in A
a2.fct();
// fct in B - obwohl ueber eine A Referenz-Variab. aufgerufen
In Java wird der Funktionsaufruf erst zur Laufzeit festgelegt60, und zwar in Abhängigkeit vom
echten Typ des Objekts, und nicht in Abhängigkeit vom Typ der Referenz-Variablen. Dieses
Sprachfeature wird mit Polymorphie bezeichnet.
Mit Polymorphie ist gemeint, dass eine Funktion vielgestaltig ist, d. h. in Abhängigkeit vom
Kontext unterschiedlich (angepasst) reagiert. Genau genommen reagiert natürlich nicht eine
Funktion unterschiedlich, sondern es werden unterschiedliche Funktionen aufgerufen, ohne
dass sich der Entwickler um die echten Objekt-Typen und deren verschiedene FunktionenImplementierungen kümmern muss. Dies ermöglicht es ihm, ähnliche Objekte61 gleich zu
behandeln, ohne Details kennen zu müssen (z.B. welche Klassen es gibt, wie sie heissen, wie
sie zu behandeln sind, usw...).
Hinweis – im ersten Augenblick sieht Polymorphie nicht nach was besonderem aus, sondern
eher nur nach einem kleinen Sprachgag – aber dies ist falsch. Es ist das Schlüsselkonzept
der Objektorientierung. Seine wahre Mächtigkeit erkennt man meist erst in praktischen
Einsätzen, von denen in den weiteren Kapiteln viele folgen werden. Ein kleines Beispiel als
Einstimmung folgt gleich – siehe Kapitel 14.12.
14.9 abstract
Es gibt Situation, in denen eine Basisklasse keine sinnvolle Default-Implementierung für eine
Element-Funktion anbieten kann – ein Beispiel hierfür findet sich u.a. im Beispiel-Kapitel 14.12.
In diesem Fall bekommt die entsprechende Element-Funktion den Modifier abstract, was
bedeutet, dass diese Element-Funktion in dieser Klasse nur deklariert, aber nicht implementiert
wird.
Sobald mindestens eine Element-Funktion in einer Klasse abstract ist (und sei es auch durch
Vererbung – siehe Klasse „B“ im Beispiel), muss auch die Klasse den Modifier abstract
bekommen. In einer tieferen abgleiteten Klasse ohne Modifier abstract muss diese ElementDieses Verhalten wird u.a. auch als dynamische Bindung, späte Bindung oder late binding
bezeichnet.
61 Ähnliche Objekte sind Objekte, die eine gemeinsame Basisklasse (oder in Java auch ein
gemeinsames Interface – siehe todo...) haben.
60
Seite 281 / 409
Funktion jetzt überschrieben und implementiert werden.
public abstract class A {
public abstract void f();
}
public abstract class B extends A {
}
public abstract class C extends B {
}
public class D extends C {
public void f() {
System.out.println("Hallo");
}
}
A a = new D();
a.f();
// Ausgabe: Hallo
Eine abstrakte Klasse kann damit automatisch nicht mehr instanziiert werden – was ja auch
keinen Sinn mehr macht, da sie eine Funktion ohne Implementierung anbietet.
public abstract class A {
}
A a = new A();
a.f();
// Fehler – A laesst sich nicht instanziieren, da abstract
// Welche Funktion sollte das dann auch sein??
Eine Klasse darf auch dann abstrakt sein, wenn sie keine abstrakten Funktionen hat.
Typischerweise tritt dieser Fall bei Klassen auf, die keine konkreten Objekte beschreiben,
sondern nur allgemeine Beschreibungen für die Gemeinsamkeiten einer „Objekt-Familie“ sind.
14.10 Casts und instanceof
Mit Casts kann man statische Typen in der Vererbungs-Hierarchie verschieben. Dazu wird der
gewünschte Zieltyp in Klammern vor den Quellausdruck geschrieben. Achtung – dies geht nur,
solange die referenzierten Objekte wirklich solche sind. Ansonsten wird eine Exception
geworfen.
Mit dem Operator „instanceof“ kann abgefragt werden, ob ein Objekt von einem bestimmten
Typ ist.
public class A {
}
Seite 282 / 409
public void f() {
System.out.println("B.f");
}
}
A var = new A();
if (var instanceof B) {
System.out.println("Variable var referenziert ein B Objekt");
B b = (B)var;
b.f();
}
else {
System.out.println("Variable var referenziert KEIN B Objekt");
}
var = new B();
if (var instanceof B) {
System.out.println("Variable var referenziert ein B Objekt");
B b = (B)var;
b.f();
}
else {
System.out.println("Variable var referenziert KEIN B Objekt");
}
Ausgabe
Variable var referenziert KEIN B Objekt
Variable var referenziert ein B Objekt
B.f
try {
A a = new A();
B b = (B)a;
b.f();
}
System.out.println(x);
}
Ausgabe
java.lang.ClassCastException
Achtung – Casts innerhalb einer Vererbungs-Hierarchie sind in einer Sprache mit häufig
untypisierten Schnittstellen62 relativ normal (vergleiche hier z.B. die untypisierten Container, die
wir in Kapitel 9.3 kennen gelernt haben63). Trotzdem sollte ihnen klar sein, dass Casts kein
guter Programmierstil sind, und auf das Notwendigste beschränkt sein sollten.
Noch extremer ist dies mit der Verwendung von „instanceof“. Im Normallfall sollte die Kenntnis
der konkreten Typen hinter einem Basis-Klasse oder einem Interface unnötig sein, da dies z.B.
die Erweiterbarkeit und Wiederverwendbarkeit stark einschränkt. Daher sollte die Benutzung
von „instanceof“ der gut begründete Ausnahmefall bleiben.
Also ganz untypisiert sind sie nicht, sondern typisiert auf „Object“ – siehe Kapitel 14.11. Aber
abgesehen von den elementaren Datentypen sind alle Klassen von „Object“ abgeleitet, so dass
die Typisierung hier nicht wirklich viel hilft.
63 Mit dem JDK 1.5 hat Java Generics bekommen, die u.a. typisierte Container ermöglichen.
Damit werden Casts in Java etwas weniger häufig notwendig, was sicher zu einer
Verbesserung der Progamm-Qualität beitragen wird. Aus Zeitgründen werden wir in der
Vorlesung Generics nicht besprechen.
62
Seite 283 / 409
14.11 Klasse „java.lang.Object“
Alle Klassen in Java sind immer direkt oder indirekt von der Klasse „Object“ abgeleitet. Wenn
sie keine Basisklasse angeben, wird automatisch „Object“ als Basisklasse angesetzt.
Die Klasse „Object“ beinhaltet allgemeine Methoden, die für jede Klasse sinnvoll sind, z.B.
clone()
equals(Object)
finalize()
getClass()
hashCode()
toString()
Erzeugt eine flache Kopie des Objekts. Dazu muss das Objekt das
Interface Cloneable implementieren und diese Funktion überschreiben.
Arrays sind immer kopierbar.
Vergleicht zwei Objekte auf Identität, d.h. Referenzgleichheit. Für
Objektvergleiche, d.h. tiefe Vergleiche bzw. ein spezielles
Vergleichsverhalten muss diese Funktion überschrieben werden.
Die normale finalize Methode
Gibt die ‘Meta-Klasse’ zum Objekt zurück.
Gibt einen Hash-Wert für das Objekt zurück.
Gibt das Objekt in einer Text-Repräsentation zurück. Diese Funktion wird
automatisch z.B. bei Ausgaben auf die Console oder bei Wandlungen in
einen String aufgerufen. Siehe auch Kapitel 14.11.1.
Wenn sie die Funktionen für ihre Klassen anpassen wollen bzw. müssen, d.h. die geerbte
Funktionalität nicht ausreicht, müssen sie sie überschreiben.
Hinweis – die Funktionen „equals“ und „hashCode“ sind nicht ganz unabhängig voneinander.
wenn sie die Equals-Funktion überschreiben, müssen sie auch die HashCode-Funktion
entsprechend überschreiben. Näheres hierzu finden sie z.B. in der offiziellen Java-Doku oder
vielen Büchern. Aus Zeitmangel wird dies in der Vorlesung nicht besprochen.
Achtung – das automatische Erben von „Object“ gilt nicht für Interfaces (Kapitel 14.13),
sondern nur für Klassen. Da „Object“ eine Klasse ist, können Interfaces nicht von ihr erben,
d.h. Klassen haben immer genau eine absolute Basisklasse - das ist „Object“. Interfaces sind
da anders.
14.11.1 Element-Funktion „Object.toString“
Ich möchte hier noch mal besonders auf die Funktion „toString“ hinweisen. Sie wird immer dann
automatisch aufgerufen, wenn eine Wandlung von einem Objekt in einen String notwendig ist.
Dies geschieht:
• Bei der Ausgabe eines Objekts auf der Console mit „System.out.print“ bzw.
„System.out.println“.
• Bei der Verkettung eines Strings mit einem Objekt mit dem Plus-Operator.
Da die Klasse „java.lang.Object“ eine Default-Implementierung anbietet, kann jedes Objekt
Seite 284 / 409
immer ausgegeben bzw. in einen String gewandelt werden. Achtung – die DefaultImplementierung von Object liefert keinen besonders sinnvolle Text-Repräsentation, wie auch?
public class A {
}
public class Appl {
A a = new A();
System.out.println(a);
String s = "String: " + a;
}
}
mögliche Ausgabe
A@119c082
String: A@119c082
Mit dem Überschreiben der Funktion „toString“ legen sie das Ergebnis der Wandlung fest.
public class A {
return "Ich bin ein A-Objekt";
}
}
public class Appl {
A a = new A();
System.out.println(a);
String s = "String: " + a;
}
}
Ausgabe
Ich bin ein A-Objekt
String: Ich bin ein A-Objekt
14.11.2 Object als Basistyp
Jede Klasse ist in Java direkt oder indirekt von „java.lang.Object“ abgeleitet. Daher kann jedes
Objekt in Java immer einer Referenz-Variablen vom statischen Typ „Object“ zugewiesen
werden. Beispiele:
Object o1 = new java.util.TreeMap();
Object o2 = new StringBuffer();
Object o3 = new javax.swing.JFrame();
Von daher ist „Object“ der kleinste gemeinsame Nenner aller Objekte – wir lassen die
elementaren Datentypen mal außen vor. Und von daher werden in Java viele Funktionen auf
„Object“ typisiert, zum Beispiel die Funktionen der Container-Klassen aus Kapitel 9.3. Daher
werden in der Praxis häufig Up-Casts in der Klassen-Hierarchie (siehe Kapitel 14.10) benötigt –
siehe auch die Beispiele der Container-Klassen in Kapitel 9.3.
Seite 285 / 409
14.12 Anwendung – Beispiel „Obstkorb“
14.12.1 Aufgabe
Nehmen wir an, sie wollen einen Obstkorb implementieren:
• Ein Obstkorb soll einfach mehrere Früchte verschiedener Obstsorten aufnehmen können.
• Jede Frucht hat einen Namen.
• Auch der Obstkorb hat einen Namen.
• Außerdem soll der Obstkorb einen Konsolen Ausgabe folgender Form haben:
• Name vom Obstkorb
• Anzahl der Früchte im Obstkorb
• Darstellung alle Früchte – alphabetisch sortiert nach dem Namen der Frucht
• Die Darstellung einer Frucht besteht aus Name und Obstsorte.
• Für den Anfang begnügen wir uns mit den zwei Obstsorten „Apfel“ und „Birne“.
Hier eine mögliche Beispiel-Ausgabe eines Obstkorbs mit 5 Früchten:
Gewünschte Ausgabe – wenn denn der Obstkorb fertig wäre...
Ich bin der Obstkorb "Geschenk" und enthalte 5 Fruechte:
- Bauchiger Adler (Birne)
- Dickes Schwein (Apfel)
- Fetter Kohl (Birne)
- Gruener Baum (Apfel)
- Saftiger Schmatz (Apfel)
Vorgehen – um zu sehen, wie uns Vererbung, „ist-ein“-Beziehung und Polymorphie hier helfen,
werden wir das Programm erstmal ohne diese Sprachmittel implementieren, und dann Stück für
Stück Sprachmittel für Sprachmittel nutzen, und dann hoffentlich sehen wie sie uns das
Programmierer-Leben erleichtern.
Bemerkung – wem ein Obstkorb mit Früchten zu abstrakt oder zu gesund ist, der möge sich
statt dessen eine Angestellten-Verwaltungs-Software für Arbeiter und Vertriebler vorstellen,
oder eine Flughafen-Dispostions-Verwaltung für Flugsteige und Tankwagen, oder oder oder...
14.12.2 Lösung 1 – ohne Vererbung und ohne Polymorphie
Zuerst brauchen wir Klassen für Äpfel und Birnen, die den Namen halten und sich selber
entsprechend der Aufgabenstellung darstellen können.
public class Apple {
private String name;
public Apple(String n) {
name = n;
}
System.out.println("- " + name + " (Apfel)");
}
Seite 286 / 409
return name;
}
}
public class Pear {
public Pear(String n) {
name = n;
}
System.out.println("- " + name + " (Birne)");
}
return name;
}
}
Bevor wir zum Obstkorb kommen – dem eigentlichen Knackpunkt des Programms –
implementieren wir die „main“ Funktion – und bekommen damit implizit die SchnittstellenDefinition vom Obstkorb.
public class Appl {
FruitBasket fb = new FruitBasket("Geschenk");
fb.insert(new Apple("Dickes Schwein"));
fb.insert(new Pear("Fetter Kohl"));
fb.insert(new Apple("Saftiger Schmatz"));
fb.insert(new Apple("Gruener Baum"));
fb.insert(new Pear("Bauchiger Adler"));
fb.print();
}
}
Dann brauchen wir den Obstkorb selber, und das wird schwieriger. Da aber die Schnittstelle
aus dem „main“ automatisch heraus fällt, fangen wir damit an:
public class FruitBasket {
public FruitBasket(String n) {
name = n;
}
public void insert(Apple apple) {
...
}
public void insert(Pear pear) {
...
}
...
}
Seite 287 / 409
}
Jetzt stellt sich die Frage, wie wir Äpfel und Birnen im Obstkorb speichern können – am besten
schon alphabetisch sortiert. Für die dynamische Speicherung von Objekten haben wir in Kapitel
todo mehrere Container kennengelernt. U.a. gab es dabei auch eine Klasse „TreeMap“, die
über einen Schlüssel (hier bei uns der Name) alphabetisch sortiert.
Hinweis – in der Praxis würde man hierfür natürlich niemals einen assoziativen Container (d.h.
einen mit Schlüssel/Wert Paaren) nehmen, sondern einen Container, der die Sortierung
automatisch auf den Objekten selber vornimmt. Den gibt es in Java natürlich auch, z.B. mit der
Klasse „TreeSet“ in „java.util“, aber a) kennen wir ihn nicht, und b) müßten wir für seinen
Gebrauch wissen, wie man unsere Äpfel und Birnen sortierbar bekommt, d.h. wir müßten mit
dem Interfaces „Comparable“ arbeiten oder einen eigenen Comparator implementieren. Für
beides ist es noch etwas früh – von daher nehmen wir hier die schlechtere Lösung mit der
Klasse „TreeMap“.
Da wir aber noch ohne Vererbung und „ist-ein“ Beziehung arbeiten, können wir Äpfel und
Birnen nicht in einer TreeMap speichern64. Also geben wir der Obstkorb-Klasse für jeden
Obsttyp eine eigene TreeMap.
private TreeMap apples = new TreeMap();
private TreeMap pears = new TreeMap();
name = n;
}
apples.put(apple.getName(), apple);
}
pears.put(pear.getName(), pear);
}
int count = apples.size();
count += pears.size();
System.out.println("Ich bin der Obstkorb \"" + name + "\" und enthalte "
+ count + " Fruechte:");
...
}
}
Als Problem bleibt jetzt nur noch die Ausgabe der Früchte – damit sie über alle Füchte
Okay, in Java geht es schon, da beide implizit von java.lang.Object abgeleitet sind, und
TreeMap mit Objects arbeitet. Aber letztlich wäre das dann auch nur die Verwendung von
Vererbung und „ist-ein“ Beziehung – und das wollen wir ja noch nicht.
64
Seite 288 / 409
alphabetisch ist, müssen beide TreeMaps parallel durchlaufen werden und die jeweils kleinere
Frucht (bezogen auf den Namen) muß ausgegeben werden. Das klingt kompliziert – gerade
wenn man an später mit noch mehr Obstsorten und noch mehr TreeMaps denkt – daher sehe
ich hier von einer Lösung ab und überlasse diese dem Studenten ;-)
14.12.3 Lösung 2 – immer noch ohne Vererbung und ohne Polymorphie
Wenn Lösung 1 bei der Ausgabe zu kompliziert ist, man aber keine Vererbung und
Polymorphie zur Verfügung hat – was macht man dann? Nun, wenn man in Java ein Problem
hat, dann macht man eine Klasse daraus.
Das Problem ist hier, dass wir Äpfel und Birnen gleichzeitig verwalten wollen, dass aber noch
nicht können bzw. hier mehr wollen. Also schreiben wir eine Klasse, die das für uns macht –
und da sie Früchte verwaltet, nennen wir sie „Fruit“.
public class Fruit {
private Apple apple = null;
private Pear pear = null;
public Fruit(Apple a) {
apple = a;
}
public Fruit(Pear p) {
pear = p;
}
if (apple!=null) {
return apple.getName();
}
return pear.getName();
}
if (apple!=null) {
apple.print();
return;
}
pear.print();
}
}
Die Klassen „Apple“, „Pear“ und „Appl“ sind von dieser Änderung nicht betroffen, nur der
Obstkorb selber, da er jetzt intern diese Hilfsklasse „Fruit“ benutzt.
private TreeMap fruits = new TreeMap();
name = n;
}
Seite 289 / 409
fruits.put(apple.getName(), new Fruit(apple));
}
fruits.put(pear.getName(), new Fruit(pear));
}
int count = fruits.size();
System.out.println("Ich bin der Obstkorb \"" + name + "\" und enthalte "
+ count + " Fruechte:");
Iterator i = fruits.values().iterator();
Fruit f = (Fruit)i.next();
f.print();
}
}
}
Bevor sie weitergehen zu Lösung 3, schauen sie sich Lösung 2 ruhig mal in Ruhe an. Wir
haben hier einen wichtigen Grundsatz von Java kennen gelernt, und sehen ein großes Problem
bisheriger Programmierung.
Der Grundsatz ist einfach: „Haben sie ein Problem, machen sie eine Klasse draus“. Im
Prinzip ist dies der alte Grundsatz der Software-Entwicklung „Es gibt kein Problem, das sich
nicht durch eine weitere Indirektion kleiner machen läßt“ in neuen Gewändern, nämlich dem
OO-Kleid.
Ein großes Problem unseres kleinen Programms ist die Wartbarkeit: immer wenn wir hier eine
neue Obstsorte einführen, müssen wir neben einer weiteren Klasse in unserem kleinen
Programm schon mehrere Code-Stellen mit ändern:
• Die Klasse „FruitBasket“ braucht eine weitere „insert“ Funktion.
• Und die Klasse „Fruit“ muss quasi überall angepaßt werden.
Und wir haben ja nur ein kleines Programm. Und dass es so relativ wenig lokalisierte Stellen
sind, liegt eigentlich schon daran, dass wir die fast gesamte Logik für die Obstsorten in der
Klasse „Fruit“ gesammelt haben.
In einem wirklich großen ernsthaften Programm würde bei einer klassischen Programmierung –
wie wir sie hier haben – das Ändern (Einfügen, Löschen, Modifizieren) z.B. einer FlughafenRessource oft an tausenden von Stellen Code-Änderungen nach sich ziehen. Ein horrender
Aufwand, bei dem man sich nie wirklich ganz sicher sein kann, alle relevanten Stellen
berücksichtigt zu haben.
14.12.4 Lösung 3 – mit Vererbung, aber noch ohne Polymorphie
Im Prinzip hat sich eine bessere Lösung schon die ganze Zeit aufgedrängt, aber wir haben sie
bewußt nicht eingesetzt. Mit Vererbung und den Konsequenzen über „ist-ein“ Beziehung sind
einige Dinge viel einfacher – wir können jetzt an vielen Stellen Äpfel und Birnen gleich
behandeln.
Die Klasse „Fruit“ bekommt hier einen ganz anderen Zweck: statt fast alle Probleme zu kapseln
Seite 290 / 409
mutiert sie zu einer sehr einfachen Basisklasse, die – da sie nicht instanziierbar sein soll –
abstrakt ist:
public abstract class Fruit {
}
Am Beispiel des Apfels schauen wir uns den kleinen Unterschied in der Klassen-Definition der
Obstsorten an – er besteht nur aus der Angabe der Basisklasse und dem Schlüsselwort
„extends“.
public class Apple extends Fruit {
name = n;
}
System.out.println("- " + name + " (Apfel)");
}
return name;
}
}
Und wie sieht der Obstkorb jetzt aus?
private TreeMap fruits = new TreeMap();
name = n;
}
fruits.put(apple.getName(), apple);
}
fruits.put(pear.getName(), pear);
}
System.out.println("Ich bin der Obstkorb \"" + name
+ "\" und enthalte " + count + " Fruechte:");
Fruit f = (Fruit) i.next();
if (f instanceof Apple) {
Apple a = (Apple) f;
a.print();
continue;
}
if (f instanceof Pear) {
Pear p = (Pear) f;
p.print();
continue;
}
Seite 291 / 409
}
}
}
Unsere TreeMap kann jetzt direkt alle Früchte ohne Wrapper-Klasse aufnehmen – siehe
Element-Funktionen „insert“. Und die Fall-Unterscheidung zwischen Äpfeln und Birnen findet
sich nur noch in der Schleife der Obstkorb-Ausgabe.
14.12.5 Lösung 4 – mit Vererbung, aber immer noch ohne Polymorphie
Als wir Vererbung eingeführt haben, haben wir noch nicht über Polymorphie gesprochen,
sondern statt dessen den Vorteil herausgestellt, dass gemeinsame Funktionen in eine
Basisklasse gelegt werden, und abgeleitete Klassen diese einfach erben. Diesen Vorteil
können wir hier auch nutzen, in dem wir das Namens-Handling von Äpfeln und Birnen in die
Basisklasse „Fruit“ verschieben – hier am Beispiel von „Apple“ verdeutlicht.
public Fruit(String n) {
name = n;
}
return name;
}
}
public class Apple extends Fruit {
super(n);
}
System.out.println("- " + getName() + " (Apfel)");
}
}
Dies hat den Nebeneffekt, dass sich im Obstkorb die beiden „insert“ Element-Funktionen zu
einer zusammenfassen lassen:
public void insert(Fruit fruit) {
fruits.put(fruit.getName(), fruit);
}
14.12.6 Lösung 5 – mit Vererbung und mit Polymorphie
Als unschöne Stelle im Programm bleibt die Ausgabe-Funktion des Obstkorbs über.
Seite 292 / 409
if (f instanceof Apple) {
Apple a = (Apple) f;
a.print();
continue;
}
if (f instanceof Pear) {
Pear p = (Pear) f;
p.print();
continue;
}
}
}
Sie sieht kompliziert und fehlerträchtig aus, und sie ist wartungsintensiv. Das Problem hier ist,
dass wir Objekte unterschiedlicher Klassen in die Hand bekommen und wir jeweils die
entsprechende Element-Funktion der jeweiligen Klasse benutzen wollen. Aber genau das liefert
uns doch die Polymorphie!
Wir müssen in der Klasse „Fruit“ nur die entsprechende „print“ Funktion zur Verfügung stellen,
und sie dann in den abgeleiteten Klassen überschreiben. Und da wir für „print“ in „Fruit“ keine
sinnvolle Default-Implementierung kennen, machen wir die Funktion „abstract“.
public Fruit(String n) {
name = n;
}
return name;
}
public abstract void print();
}
Für die Obst-Klassen „Apple“ und „Pear“ ändert sich gar nichts. Aber die Ausgabe-Funktion des
Obstkorbs ist auf einmal ganz einfach:
f.print();
}
}
Und sie enthält keine Abhängigkeiten auf die verwendeten Obstsorten mehr – auf einmal ist sie
ganz allgemeingültig.
14.12.7 Erweiterte Aufgabe
Lassen sie sich das mal auf der Zunge zergehen. In unserem ganzen Programm gibt es fast
Seite 293 / 409
keine Abhängigkeiten mehr auf die verwendeten Obstsorten. Was heißt das für uns, wenn wir
z.B. eine neue Sorte „Bananen“ einführen wollen?
Zuerst brauchen wir in Anlehnung an „Apple“ und „Pear“ eine weitere Klasse „Banana“. Die
neue Klassen ist vollkommen unabhängig vom restlichen Programm, und wir können sie
einfach hinzufügen:
public class Banana extends Fruit {
public Banana(String n) {
super(n);
}
System.out.println("- " + getName() + " (Banane)");
}
}
Und in „main“ benutzen wir sie einfach:
FruitBasket fb = new FruitBasket("Geschenk");
fb.insert(new Apple("Dickes Schwein"));
fb.insert(new Pear("Fetter Kohl"));
fb.insert(new Apple("Saftiger Schmatz"));
fb.insert(new Apple("Gruener Baum"));
fb.insert(new Pear("Bauchiger Adler"));
fb.insert(new Banana("Krumme Wurst"));
fb.insert(new Banana("Langer Lulatsch"));
fb.print();
}
Ausgabe
Ich bin der Obstkorb "Geschenk" und enthalte 7 Fruechte:
- Bauchiger Adler (Birne)
- Dickes Schwein (Apfel)
- Fetter Kohl (Birne)
- Gruener Baum (Apfel)
- Krumme Wurst (Banane)
- Langer Lulatsch (Banane)
- Saftiger Schmatz (Apfel)
Und ansonsten müssen wir nichts machen – das Programm funktioniert einfach!
Unser eigentliches Programm – hier die Klasse „Obstkorb“ – arbeitet nur auf der Basisklasse,
und muß – dank Polymorphie – die konkreten Klassen nicht kennen, und ist daher vollkommen
unabhängig. Das Programm läßt sich so sehr leicht verändern oder erweitern.
14.13 Interfaces
Interfaces sind spezielle Java-Klassen:
• Sie sind quasi eine auf die Spitze getriebene abstrakte Klasse.
• Sie werden mit dem Schlüsselwort interface deklariert.
• Sie können nur abstrakte Funktionen und Klassen-Variablen enthalten,
d.h. sie enthalten weder Implementationen noch Attribute. Häufig enthalten sie nur KlassenKonstanten – siehe Kapitel 12.5.2.
•
•
•
•
•
•
Seite 294 / 409
Sie haben keine implizite Basisklasse.
Sie müssen keine Funktionen enthalten, d.h. sie dürfen auch leer sein.
Von Interface’s werden Klassen mit dem Schlüsselwort implements abgeleitet.
Eine Klasse kann beliebig viele Interface’s implementieren.
Es können Referenz-Variablen vom Typ des Interfaces definiert werden.
Interfaces benötigen – als quasi spezielle Klassen – ihre eigene Quelltext-Datei, die natürlich
so heißen muß wie das Interface.
public interface Inter {
public void fct();
}
public class Imple implements Inter {
public void fct() {
System.out.println("In fct() von Impl");
}
}
Inter in = new Imple();
in.fct();
Interface’s sind quasi das Java-Sprachmittel für Mehrfachvererbung, wobei eine Klasse nur
über die extends Schiene eine Implementierung erben kann.
Hinweis – in Java ist es möglich, dass ein Interface komplett leer ist. Mit dem Implementieren
eines solchen Interfaces bekommt eine Klasse quasi ein Flag, dass irgendein Verhalten
gewünscht ist, okay ist, nicht sein soll, oder was auch immer. Ein Beispiel hierfür ist das
Interface „Serializable“, mit dem eine Klasse serialisierbar wird – siehe Kapitel todo.
14.14 Modul-Entkopplung
Vererbung und Polymorphie sind auch ein Mittel um Module voneinander zu entkoppeln, d.h.
die Module unabhängig voneinander zu machen. Schauen wir uns hierzu mal ein Beispiel an:
Das Benutzer-Interface unterliegt in der Praxis oft häufigeren Änderungen. Damit Änderungen
im Benutzer-Interface nicht Änderungen im gesamten Programm nach sich ziehen, versucht
man die eigentliche Programm-Logik und das Benutzer-Interface in Schichten aufzuteilen65.
Abb. 14-4 : 2 Schicht-Architektur eines Programms
In einer solchen Architektur gibt es eine klare Abhängigkeits-Beziehung: hier kennt das UI66 die
In der Praxis findet man häufig drei Schichten oder mehr. Bei einer 3 Schicht-Architektur
werden die Schichten für das Benutzer-Interface und die Programm-Logik meist noch um eine
Schicht zur Daten-Haltung ergänzt.
66 UI – User-Interface, d.h. Benutzer-Interface
65
Seite 295 / 409
BL67, aber umgekehrt nicht! Die BL stellt Dienste zur Verfügung, die vom UI benutzt werden
können. Die BL kennt aber kein konkretes UI, und darf daher auch keine Benutzer-Interaktion
ausführen!
Abb. 14-5 : Abhängigkeit in einer 2 Schicht-Architektur
Was ist aber nun, wenn z.B. die BL während der Arbeit Eingaben benötigt, z.B. einen
Dateinamen, einen Parameter, ein Passwort oder sonstwas? Sie darf ja keine BenutzerInteraktion ausführen, und kann das UI auch nicht dazu auffordern (da sie es nicht kennt)68.
Was macht man dann?
Formulieren wir das Problem etwas anders, vielleicht fällt dann die Lösung leichter: Die BLSchicht darf nicht selber Benutzer-Interaktion machen, d.h. muss sie dies indirekt machen, z.B.
mittels eines Funktions-Aufrufs. Da sie die-UI Schicht nicht kennt, kann sie dort keine Funktion
direkt aufrufen. Sie muss also eine Funktion aufrufen, die in der BL-Schicht bekannt ist, aber in
einer unbekannten UI-Schicht ausgeführt wird.
Sehen sie die Lösung?
• In der BL-Schicht muss eine Funktion bekannt sein, damit die BL-Schicht sie nutzen kann,
aber sie kann in der BL-Schicht nicht implementiert sein.
• In der UI-Schicht muss genau diese Funktion dann implementiert sein, und sie muss quasi
über die BL-Funktion aufrufbar sein.
Das klingt doch wie Vererbung und Polymorphie:
• In der BL-Schicht wird ein Interface benötigt, dass die Parameter-Hol Funktion definiert.
• In der UI-Schicht muss sich eine UI-Klasse von diesem Interface ableiten und die
Parameter-Hol Funktion implementieren.
• Z.B. beim Aufruf der BL-Schicht könnte jetzt das Objekt, das das BL-Interface implementiert,
mitgegeben werden.
Abb. 14-6 : Design der Modul-Entkopplung
Und hier das Ganze als Quelltext:
package bl;
public interface GetUserParameterInterface {
public String get();
}
package bl;
public class BusinessLogic {
BL – Business-Logic, d.h. Geschäfts- oder Programm-Logik
In vielen Programm findet man hier dann häufig Code, der die Schichtung mit ihrer sauberen
Abhängigkeit durchbricht, und alle Ansätze zur Trennung und Modularisierung ad-acta legt.
Dies kann natürlich nicht Sinn der Sache sein.
67
68
Seite 296 / 409
public String doit(GetUserParameterInterface gupi) {
String parameter = gupi.get();
return "\"" + parameter + "\"";
}
}
package ui;
import bl.BusinessLogic;
import bl.GetUserParameterInterface;
public class UserInteraction implements GetUserParameterInterface {
private BusinessLogic bl = new BusinessLogic();
public void doit() {
System.out.println("Starte Verarbeitung...");
String s = bl.doit(this);
System.out.println("Ergebnis: " + s);
}
public String get() {
try {
System.out.println("Bitte geben sie einen String ein:");
}
}
return "";
}
}
import ui.UserInteraction;
public class Appl {
UserInteraction ui = new UserInteraction();
ui.doit();
}
}
mögliche Ausgabe
Starte Verarbeitung...
Bitte geben sie einen String ein:
Hallo Welt
Ergebnis: "Hallo Welt"
Hinweis – um die Trennung zwischen BL- und UI-Schicht sauber darzustellen, sind die
entsprechenden Klassen (bzw. Interfaces) in entsprechende Packages „bl“ und „ui“ eingefügt.
Bemerkung – ein weiteres, vielleicht etwas einsichtigeres Beispiel findet sich in der
Praktikums-Aufgabe 14.16.2.
Seite 297 / 409
14.15 Fazit
Wenn sie Vererbung und Polymorphie einsetzen, dann hat das Hinzufügen oder Entfernen oder
Verändern einer Klasse fast keine Auswirkungen auf ihr eigentliches Programm –
ausgenommen sind die Stellen an denen die Objekte erzeugt werden, aber auch da kann man
sich helfen.
Immer wenn sie es schaffen ihr Programm, ihre Programm-Struktur oder ihre ProgrammArchitektur auf Baisklassen (oder Interfaces) aufzubauen, dann haben sie gewonnen. Sie
haben leichtes Spiel mit Veränderungen, ohne dass sie ihren ganzen Code nach Änderungen
durchforsten müssen.
Vererbung und Polymorphie sind die Schlüsselkonzepte von OO!
14.16 Aufgaben
14.16.1 Aufgabe „Obstkorb“
Implementieren sie das Obstkorb Programm aus Kapitel 14.12.6. Erweitern sie es um eine
Klasse für Zitronen (Englisch „lemon“).
14.16.2 Aufgabe „ProgressBar“
Ein typisches Problem der Art von Kapitel 14.14 („Modul-Entkopplung“) ist eine FortschrittsAnzeige („ProgressBar“). In der BL Schicht findet eine Verarbeitung statt, die längere Zeit
braucht. Damit der Benutzer eine Rückkopplung bekommt, soll eine Fortschritts-Anzeige
aufgeblendet werden. Nur, die BL-Schicht kennt keine UI-Schicht und weiss auch nicht, was für
eine Fortschritts-Anzeige im jeweiligen UI-Kontext sinnvoll ist. Daher bietet sich eine
Entkopplung über ein Interface an.
• Denken sie sich eine einfache Verarbeitung in der BL-Schicht aus, die etwas Zeit kostet.
Z.B. eine einfache Schleife mit einem „Thread.Sleep“ (siehe Kapitel 11.3.1).
• Schreiben sie ein erstes kleines Programm ohne Fortschritts-Anzeige mit BL- und UISchicht.
• Definieren sie ein Interface, mit dem eine Fortschritts-Anzeige betrieben werden kann.
• Implementieren sie eine Fortschritts-Anzeige.
• Integrieren sie Interface und Fortschritts-Anzeige in ihr Programm.
• Implementieren sie eine weitere Fortschritts-Anzeige. Zeigen sie durch einen einfachen
Austausch der Fortschritts-Anzeigen dass die BL-Schicht mit beiden betrieben werden
kann, ohne dass die BL-Schicht betroffen ist (d.h. geändert werden muss).
• Mögliche Fortschritts-Anzeigen auf Konsolen-Ebene wären z.B.:
• Ausgabe, die von „0 %“ bis „100 %“ hochzählt.
• Liniengrafik mit z.B. dem Zeichen „|“.
Seite 298 / 409
Erweitern sie die kleine Kontaktdaten-Verwaltung aus Kapitel 11.5.3. Gegenüber der Aufgabe
11.5.3 soll dieses Programm aber mehrere Arten von Kontakten verwalten können:
• Single – entspricht der Person aus der alten Aufgabe.
Besteht aus:
• Vorname
• Nachname
• Beschreibung
Suchen über Vor- und Nachname
• Paar
Besteht aus:
• Vorname 1
• Vorname 2
• Nachname (gemeinsamer)
Suchen über beide Vornamen und den gemeinsamen Nachname
• Firmenkontakt
• Firmenname
• Ansprechpartner
• Vorname
• Nachname
• Position
Suchen über Firmenname, Vor- und Nachname des Ansprech-Partners
Trennen sie die Kontaktdaten-Verwaltung aus Kapitel 14.20 in ihre groben Strukturen auf, und
packen sie diese in eigene Packages. Besonders wichtig ist hier die vollständige Trennung
von Benutzer-Ein- und -Ausgabe und der eigentlichen Programm-Logik. Damit können wir
später problemlos eine grafische Oberfläche auf die Programm-Logik aufsetzen.
Bauen sie das Tic-Tac-Toe Programm aus Kapitel 12.8.3 so um, dass Vererbung und
Seite 299 / 409
Polymorphie benutzt wird. Welche Klasse bieten sich im Tic-Tac-Toe dafür an? Wo können sie
das Programm dadurch vereinfachen?
Nach dem Umbau von Kapitel 14.16.5 sollte es möglich sein, dass Tic-Tac-Toe so zu erweitern,
dass der Benutzer am Anfang die Spieler dynamisch festlegen kann. D.h. implementieren sie
eine Abfrage, mit der der Benutzer definiert, ob Spieler 1 bzw. Spieler 2 jeweils ein Mensch
oder der Computer ist.
Implementieren sie einen weiteren einfachen Computer-Spieler, der einfach das Feld per Zufall
festlegt. Integrieren sie den Spieler in das Programm und die Spieler-Auswahl von Kapitel
14.16.6. Sehen sie, wie einfach die Erweiterung des Spiels um einen weiteren Spieler
geworden ist?
Trennen sie das Tic-Tac-Toe aus Kapitel 14.16.7 in seine groben Strukturen auf, und packen
sie diese in eigene Packages. Besonders wichtig ist hier die vollständige Trennung von
Benutzer-Ein- und Ausgabe und der eigentlichen Programm-Logik. Immerhin wollen wir ja auch
das Tic-Tac-Toe später noch mit einer grafischen Benutzeroberfläche versehen, aber das Spiel
nicht neuschreiben müssen sondern die gesamte Logik wiederverwenden können.
14.17 Lsg. zu Aufgabe „Obstkorb“ – Kap. 14.16.1
todo...
14.18 Lsg. zu Aufgabe „ProgressBar“ – Kap. 14.16.2
todo...
Seite 300 / 409
Noch ohne Erläuterungen – todo...
public class Keyboard {
try {
}
}
return "";
}
}
public interface Contact {
public boolean find(String pattern);
public void input();
public void print();
}
public class Single implements Contact {
private String forename = "";
private String surename = "";
private String phone = "";
return forename.startsWith(pattern) || surename.startsWith(pattern);
}
}
System.out.print("- Single: " + forename + " " + surename);
}
}
}
public class Pair implements Contact {
private
private
private
private
String
String
String
String
fame1 = "";
fname2 = "";
surename = "";
phone = "";
Seite 301 / 409
return fname1.startsWith(pattern) || fname2.startsWith(pattern) ||
surename.startsWith(pattern);
}
System.out.print("Vorname 1: ");
fname1 = Keyboard.readString();
System.out.print("Vorname 2: ");
fname2 = Keyboard.readString();
}
System.out.print("- Paar: " + fname1 + " & " + fname2 + " " + surename);
}
}
}
public class Company implements Contact {
private
private
private
private
private
String
String
String
String
String
name = "";
fn = "";
sn = "";
position = "";
phone = "";
public boolean find(String p) {
return name.startsWith(p) || fn.startsWith(p) || sn.startsWith(p);
}
System.out.print("Firmen-Name: ");
name = Keyboard.readString();
System.out.println("Ansprechpartner");
System.out.print("- Vorname: ");
fn = Keyboard.readString();
System.out.print("- Nachname: ");
sn = Keyboard.readString();
System.out.print("- Position: ");
position = Keyboard.readString();
System.out.print("- Telefon: ");
}
System.out.print("- Firma " + name + " - Ap: " + fn + " " + sn);
if (position.length()!=0) {
System.out.print(" - Pos: " + position);
}
}
}
}
public class Contacts {
private ArrayList contacts = new ArrayList();
Seite 302 / 409
public void add(Person p) {
contacts.add(p);
}
public void find(String pattern) {
Iterator i = contacts.iterator();
Contact c = (Contact)i.next();
if (c.find(pattern)) {
c.print();
}
}
}
System.out.println("" + contacts.size() + " Kontakte:");
Iterator i = contacts.iterator();
Contact c = (Contact)i.next();
c.print();
}
}
}
public class Appl {
private Contacts cts = new Contacts();
public void run() {
while (true) {
System.out.println("Bitte waehlen sie eine Aktion aus");
System.out.println("- l : Liste");
System.out.println("- n : Neu");
System.out.println("- s : Suchen");
System.out.println("- e : Ende");
if (in.equalsIgnoreCase("l")) {
print();
}
else if (in.equalsIgnoreCase("n")) {
insert();
}
else if (in.equalsIgnoreCase("s")) {
find();
}
else if (in.equalsIgnoreCase("e")) {
return;
}
}
}
private void print() {
cts.print();
}
private void insert() {
Contact c;
while (true) {
System.out.println("- s : Single");
System.out.println("- p : Paar");
System.out.println("- f : Firma");
System.out.println("- a : Abbruch");
if (in.equalsIgnoreCase("s")) {
System.out.println("<Eingabe Single>");
c = new Single();
Seite 303 / 409
break;
}
else if (in.equalsIgnoreCase("p")) {
System.out.println("<Eingabe Paar>");
c = new Pair();
break;
}
else if (in.equalsIgnoreCase("f")) {
System.out.println("<Eingabe Firma>");
c = new Company();
break;
}
else if (in.equalsIgnoreCase("a")) {
return;
}
}
c.input();
cts.add(c);
}
private void find() {
System.out.print("Geben sie einen Suchstring ein: ");
String pattern = Keyboard.readString();
cts.find(pattern);
}
appl.run();
}
}
todo...
Immer wenn in einer Aufgaben-Stellung von „verschiedenen Arten von irgendwas“ geredet wird,
klingt dies nach Vererbung. Und wenn die „verschiedenen Arten von irgendwas“ noch
gemeinsam verarbeitet werden müssen, dann ist der Einsatz von Polymorphie meist sinnvoll.
14.21.1 Basis-Klasse „Player“
Im Tic-Tac-Toe aus Kapitel todo gibt es mehrere Arten von Spielern – den Menschen und den
Computer, der immer das nächste freie Feld nimmt. Hierfür könnte eine Klassen-Hierarchie
also sinnvoll sein.
Die erste Aktion ist also die Integration einer Basis-Klasse „Player“.
• Da kein Spieler an sich existiert, wird die Basis-Klasse abstrakt gemacht.
• Beide Spieler haben die Verwaltung der Spielfarbe gemeinsam, d.h. wird diese in die BasisKlasse verschoben.
• Zusätzlich werden die gemeinsamen Funktionen „getName“ und „next“ als abstrakte
Funktionen bekannt gemacht.
Seite 304 / 409
public abstract class Player {
private int color;
public Player(int c) {
color = c;
}
return color;
}
public abstract String getName();
public abstract Move next(Board b);
}
Hier die neue Klassen-Implementierung von „ComputerNext“. Die Klasse „Human“ ändert sich
analog.
public class ComputerNext extends Player {
public ComputerNext(int c) {
super(c);
}
return "Computer (naechstes freies Feld)";
}
Move m = new Move(i, getColor());
if (b.valid(m)) {
return m;
}
}
}
}
14.21.2 Haupt-Schleife vereinfachen
Werden die Spieler denn irgendwo im Programm gemeinsam verarbeitet? Wenn ja, so könnte
dies durch Vererbung und Polymorphie vielleicht vereinfacht werden.
Ja, in der Hauptschleife ist zweimal fast der gleiche Code vorhanden, da beide Spieler identisch
verarbeitet werden müssen, aber dies bislang nicht mit einem Code-Stück möglich war. Hier
noch mal der bisherige Code:
public class Appl {
ComputerNext pl2 = new ComputerNext(Move.BLACK);
b.print();
while (true) {
b.set(m);
b.print();
(*)
Seite 305 / 409
return;
}
if (b.full()) {
return;
}
(**)
m = pl2.next(b);
b.set(m);
b.print();
return;
}
}
}
}
Das Problem war, dass sich der doppelte Code (von (*) bis (**)) nicht in eine Funktion ziehen
liess, da beide Spieler unterschiedlichen Typs waren.
void play(Typ pl) {
Move m = pl.next(b);
...
}
// welcher Typ? Human oder ComputerNext
Nun gibt es eine gemeinsame Basis-Klasse, und damit ist es möglich eine Funktion für beide
Spieler zu schreiben.
• Um das Spielende zu propagieren, gibt die „play“ Funktion noch einen boolean Wert zurück.
• Außerdem bekommt „play“ neben dem Spieler noch das Board übergeben.
• Zusätzlich typisieren wir noch die Spieler „pl1“ und „pl2“ nach „Player“ um – obwoh das hier
noch ziemlich egal ist.
public class Appl {
Player pl1 = new Human(Board.WHITE);
Player pl2 = new ComputerNext(Board.BLACK);
b.print();
while (true) {
if (play(b, pl1)) return;
}
}
public static boolean play(Board b, Player pl) {
Move m = pl.next(b);
System.out.println(pl.getName() + " zieht " + m + '\n');
b.set(m);
b.print();
if (b.wins(pl.getColor())) {
System.out.println(pl.getName() + " hat gewonnen");
return true;
}
if (b.full()) {
return true;
}
(*)
(**)
(***)
Seite 306 / 409
return false;
}
}
Und warum funktioniert das?
1) Da die Funktionen „getName“ und „next“ auch in Player definiert sind – wenn auch nur
abstrakt – compilieren die Zeilen (*), (**) und (***).
2) Dank Polymorphie landen die Funktions-Aufrufe in (*), (**) und (***) auch in den jeweiligen
Spieler-Klassen in den richtigen Funktionen.
Das ist jetzt kein wirkliches Problem, da wir in Kapitel 14.21 alle Spieler schon auf „Player“
typisiert haben.
Player pl1 = new Human(Board.WHITE);
Player pl2 = new ComputerNext(Board.BLACK);
...
Schon jetzt könnten wir problemlos z.B. dem Computer „weiß“ und dem Menschen „schwarz“
geben:
Player pl1 = new ComputerNext(Board.WHITE);
Player pl2 = new Human(Board.BLACK);
...
Man muss dies nur noch durch eine Benutzer-Eingabe dynamisch steuern:
public class Appl {
Player pl1 = choosePlayer("ersten", Board.WHITE);
Player pl2 = choosePlayer("zweiten", Board.BLACK);
b.print();
while (true) {
}
}
public static Player choosePlayer(String s, int color) {
while (true) {
System.out.println("Bitte waehlen sie den " + s + " Spieler aus:");
System.out.println("- Mensch (M)");
System.out.println("- Computer erstes freies Feld (E)");
Seite 307 / 409
try {
if (in.compareToIgnoreCase("M") == 0) {
return new Human(color);
}
if (in.compareToIgnoreCase("E") == 0) {
return new ComputerNext(color);
}
}
}
}
}
public static boolean play(Board b, Player pl) {
...
}
}
14.23.1 Klasse „ComputerRandom“
Zuerst implementieren wir einen weiteren Computer-Spieler, der das zu spielende Feld per
Zufall auswählt. Damit er problemlos ins Programm integriert werden kann, wird er natürlich von
„Player“ abgeleitet.
public class ComputerRandom extends Player {
public ComputerRandom(int c) {
super(c);
}
return "Computer (Zufall)";
}
while (true) {
int field = rnd.nextInt(9);
Move m = new Move(field, getColor());
if (b.valid(m)) {
return m;
}
}
}
}
14.23.2 Spieler-Auswahl
Dann muß er noch ins Menü für die Spieler-Auswahl integriert werden:
public static Player choosePlayer(String s, int color) {
while (true) {
Seite 308 / 409
System.out.println("Bitte waehlen sie den " + s + " Spieler aus:");
System.out.println("- Mensch (M)");
System.out.println("- Computer erstes freies Feld (E)");
System.out.println("- Computer Zufall (Z)");
try {
if (in.compareToIgnoreCase("M") == 0) {
return new Human(color);
}
if (in.compareToIgnoreCase("E") == 0) {
return new ComputerNext(color);
}
if (in.compareToIgnoreCase("Z") == 0) {
return new ComputerRandom(color);
}
}
}
}
}
14.23.3 Fertig
Und das war es. Dank Vererbung und Polymorphie funktioniert das eigentliche Programm auch
mit einer Klasse, die zum Zeitpunkt der Programm-Erstellung noch gar nicht bekannt war. Das
eigentliche Programm kennt nur Player und bindet die Funktionen dynamisch, d.h. landen die
Funktions-Aufrufe an den richtigen Stellen.
Nur an den Stellen, an denen Objekte erzeugt werden, muß der Code verändert werden. Und
geschickt programmiert, gibt es nur wenige solche Code-Stellen im Programm.
todo...
15 Innere Klassen
Seit Java 1.1 können in Java Klassen und Interfaces ineinander verschachtelt werden. Man
nennt sie innere Klassen, eingebettete Klassen oder auch verschachtelte Klassen. Es gibt
mehrere Sorten von eingebetteten Klassen:
1. Member-Klassen
Eingebettete static Klassen (oder auch „statische Member-Klassen“) sind relativ normale
Klassen, d.h auch Top-Level Klassen, die logisch einer anderen Klasse zugeordnet sind,
und auch auf deren private Elemente zugreifen dürfen.
Eingebettete nicht static Klassen (oder auch „Member-Klassen“) sind sogenannte
Element-Klassen, deren Instanzen immer einer umgebenden Klassen-Instanz zugeordnet
sind.
Seite 309 / 409
Eingebettete Interfaces (oder auch „Member-Interfaces“) sind vergleichbar zu
eingebetteten static Klassen, d.h sie sind Top-Level-Interfaces, die logisch einer anderen
Klasse zugeordnet sind, und auch auf deren private Elemente zugreifen dürfen. Interfaces
sind implizit immer static.
2. Lokale Klassen sind Klassen die innerhalb eines Code-Blocks definiert sind, und auch nur
dort benutzt werden können. Obwohl doch etwas anderes, haben sie viele Eigenschaften
mit eingebetteten nicht static Klassen gemeinsam.
3. Anonyme Klassen sind lokale Klassen ohne Namen.
15.1 Eingebettete static Klassen
Eingebettete static Klassen:
• Benötigen den Modifier „static“.
• Zugriff über Kombination der Klassen-Namen mit trennendem Punkt.
• Verhalten sich wie normale Klassen (Top-Level-Klassen).
• Können beliebig tief geschachtelt werden.
• Sind logisch der (den) umgebenden Klasse(n) zugeordnet.
• Dürfen auch auf private Elemente der umgebenden Klasse(n) zugreifen.
• Haben direkten Zugriff auf static Elemente der umgebenden Klasse(n).
• Die umgebende Klasse hat auch Zugriff auf private Elemente der inneren Klasse.
public class OuterClass {
private String pstr = "Private aeussere Element-Variable";
private static String pocv = "Private aeussere Klassen-Variable";
public OuterClass() {
System.out.println("Konstruktor OuterClass");
System.out.println(picv);
new StaticInnerClass(this);
}
public static class StaticInnerClass {
private static String picv = "Private innere Klassen-Variable";
public StaticInnerClass(OuterClass o) {
System.out.println("Konstruktor StaticInnerClass");
System.out.println(o.pstr);
System.out.println(pocv);
}
}
}
OuterClass o = new OuterClass();
OuterClass.StaticInnerClass i = new OuterClass.StaticInnerClass(o);
Ausgabe
Konstruktor OuterClass
Private Innere Klassen-Variable
Konstruktor StaticInnerClass
Private aeussere Element-Variable
Private aeussere Klassen-Variable
Seite 310 / 409
Konstruktor StaticInnerClass
Private aeussere Element-Variable
Private aeussere Klassen-Variable
15.2 Eingebettete nicht static Klassen
Eingebettete nicht static Klassen:
• Heissen auch Element-Klassen.
• Sind logisch der umgebenden Klasse zugeordnet.
• Ihre Objekte sind immer mit genau einem Objekt der umgebenden Klasse verbunden.
• Dürfen auch auf private Elemente der umgebenden Klasse zugreifen.
• Dürfen keine static Elemente enthalten.
• Dürfen nicht den Namen einer umgebenden Klasse bzw. Package’s haben.
private String pstr;
public OuterClass(String s) {
System.out.println("Konstruktor OuterClass");
pstr = s;
new InnerClass();
}
public class InnerClass {
public InnerClass() {
System.out.println("Konstruktor InnerClass");
System.out.println(pstr);
}
}
}
OuterClass o = new OuterClass("Call in fct");
Ausgabe
Konstruktor InnerClass
Call in fct
Im obigen Beispiel greift der Konstruktor direkt auf eine Objekt-Variable der umgebenden
Klasse zu, obwohl hier scheinbar gar kein Objektbezug vorhanden ist. Diesen Objektbezug
stellt der Compiler automatisch her. Wird ein Objekt der Elementklasse erzeugt, übergibt der
Compiler automatisch die this Referenz des aktuellen Objekts als Objektbezug. Ausserdem
erzeugt der Compiler automatisch in der Elementklasse immer ein Attribut für die Referenz auf
das zugeordnete umgebenden Klassenobjekt.
Wird versucht, eine Elementklasse in einer anderen Klasse zu erzeugen, so meldet der
Compiler einen Fehler, da das aktuelle Objekt nicht den richtigen Klassentyp hat.
public class A {
public void fct() {
new OuterClass.InnerClass("Call from A");
}
}
// Error
Seite 311 / 409
Um ein Objekt der Elementklasse ausserhalb der umgebenden Klasse erzeugen zu können,
muss man dem Compiler den impliziten Parameter explizit angeben. Dafür wurde in Java eine
spezielle Syntax für den Operator „new“ eingeführt:
OuterClass o = new OuterClass("Call from every-wbere");
o.new InnerClass();
Ausgabe
Call from every-where
Call from every-where
Diese new Operator wird wie eine Elementfunktion für das zuzuordnende Objekt aufgerufen.
Der Klassenname der Elementklasse muss nicht weiter referenziert werden, da automatisch
der Namensraum der umgebenden Klasse benutzt wird.
15.3 Eingebettete Interface’s
Eingebettete Interface’s:
• sind äquivalent zu eingebetteten static Klassen
• sich wie normale Interfaces
• können beliebig tief geschachtelt werden
• sind logisch der (den) umgebenden Klasse(n) zugeordnet
• sind implizit immer static - das Schlüsselwort kann daher weggelassen werden
public static interface InnerInterface {
public void fct();
}
}
public class Concrete implements OuterClass.InnerInterface {
public void fct() {
System.out.println("In Concrete.fct()");
}
}
OuterClass.InnerInterface ii = new Concrete();
ii.fct();
Ausgabe
In Concrete.fct()
15.4 Lokale Klassen
Eine lokale Klasse wird innerhalb eines Code-Blocks definiert, und ist nur innerhalb desselben
bekannt. Im Prinzip ist eine lokale Klasse eine spezielle Version einer eingebetteten Klasse,
Seite 312 / 409
denn jeder Code-Block existiert in Java innerhalb einer Klasse, und so hat auch eine lokale
Klasse einen Klassen- bzw. Objektbezug. Daher können die Regeln für eingebettete Klassen
erstmal auf lokale Klassen übertragen werden.
• Lokale Klassen sind nur in dem sie definierenden Block bekannt.
• Lokale Klassen können nicht als public, protected, private oder static definiert werden.
• Lokale Klassen dürfen auch auf private Elemente der umgebenden Klasse zugreifen.
• Lokale Klassen dürfen keine static Elemente enthalten.
• Lokale Klassen können auf Variablen, Parameter und Ausnahmen im Sichtbarkeit des
definierenden Blocks zugreifen, wenn dieses als „final“ definiert sind.
• Lokale Klassen können keine Interfaces sein.
• Lokale Klassen dürfen nicht den Namen einer umgebenden Klasse bzw. Package’s haben.
public class Normal {
private String str = "String Attribute in Normal";
public void f {
final int i = 42;
class LocalClass {
public LocalClass() {
System.out.println("Konstruktor LocalClass");
System.out.println(str);
}
}
LocalClass l = new LocalClass();
}
}
Normal n = new Normal();
n.f();
Ausgabe
Konstruktor LocalClass
String Attribute in Normal
42
Hinweis - eine lokale ist gegenüber einer eingebetteten Klasse vorzuziehen, wenn die Klasse
nur in einer Funktion benötigt wird.
15.4.1 Externe Verwendung
Selbst wenn eine lokale Klasse nur innerhalb des sie definierenden Blocks bekannt ist, so
können Objekte der Klasse auch woanders benutzt werden.
public interface Interface {
public void f();
}
public class Normal {
public Interface getInterfaceObject {
class LocalClass implements Interface {
public void f() {
Seite 313 / 409
System.out.println("LocalClass.f()");
}
}
return new LocalClass();
}
}
Normal n = new Normal();
Interface i = n.getInterfaceObject();
i.f();
Ausgabe
LocalClass.f()
15.5 Anonyme Klassen
Anonyme Klassen sind lokale Klassen ohne Namen. Sie können direkt an der Stelle, wo ein
Objekt von ihnen benötigt und erzeugt wird, ohne Namen definiert werden. Im Gegensatz zu
der Definition einer lokalen Klasse ist die Definition einer anonymen Klasse ein Ausdruck, und
kann daher Teil eines größeren Ausdrucks (z.B. eines Funktionsaufrufs) sein.
• Anonyme Klassen haben nur den automatischen Default-Konstruktor.
• Objekte anonymen Klassen, die in einer Element-Funktion erzeugt werden, haben
automatischen Objekt-Bezug zum aktuellen Objekt der umgebenden Klasse – d.h. dem
Objekt, für das die Element-Funktion aufgerufen wurde (dem „this“ der Element-Funktion) –
siehe Beispiel.
• Objekte anonymen Klassen, die in einer Klassen-Funktion erzeugt werden, haben keinen
Objekt-Bezug.
Syntax
new Basisklasse () { Klassendefinition }
public interface Inter {
public void f();
}
public class Appl {
private String s = "Attribute in Appl";
public static void fct(Inter i) {
System.out.println("Appl.fct bekommt Objekt vom Typ Inter uebergeben");
i.f();
}
fct(new Inter() {
public void f() {
System.out.println("- f() von anonymer Klasse");
//System.out.println("- - Attribut-Zugriff: \"" + s + "\""); Fehler
System.out.println("- - kein Attribut-Zugriff");
}
});
appl.doit();
}
Seite 314 / 409
public void doit() {
fct(new Inter() {
public void f() {
System.out.println("- f() von anonymer Klasse");
System.out.println("- - Attribut-Zugriff: \"" + s + "\"");
}
});
}
}
Ausgabe
Appl.fct bekommt Objekt vom Typ Inter uebergeben
- f() von anonymer Klasse
- - kein Attribut-Zugriff
Appl.fct bekommt Objekt vom Typ Inter uebergeben
- f() von anonymer Klasse
- - Attribut-Zugriff: "Attribute in Appl"
Hinweis – anonyme Klassen mögen seltsam und wie ein Spezialfall wirken, aber sie sind z.B.
als Implementierung von Listener-Interfaces bzw. -Klassen beim Event-Handling in Swing das
tägliche Brot – siehe z.B. Kapitel todo.
15.6 Virtuelle Maschine
Die virtuellen Java Maschine kennt keine eingebetteten Klassen. Damit sie trotzdem den
erzeugten Byte Code verarbeiten kann, wendet der Compiler einen kleinen Trick an: er erzeugt
statt der eingebetteten Klassen scheinbare Top-Level Klassen, deren Namen sich aus dem
Namen der umgebenden Klasse, einem $ Zeichen und dem Namen der eingebetteten Klasse
ergibt.
public static class StaticInnerClass {
}
}
So finden sich nach einem solchen Code-Stück im entsprechenden Byte-Code Verzeichnis die
Dateien:
• OuterClass.class
• OuterClass$StaticInnerClass.class
wieder. Schauen sie sich das Ausgabe-Verzeichnis ruhig mal an.
16 GUI Programmierung mit Swing
Bei vielen Programmen wird heutzutage eine grafische Bedienoberfläche mit Fenstern, Menüs,
Maus, uwm. erwartet. Für die Programmierung grafischer Oberflächen enthält Java die
Bibliothek „Swing“, die Klassen für Fenster, Buttons und vieles mehr enthält.
Swing kapselt die Unterschiede zwischen den einzelnen Betriebssystemen, so dass eine mit
Java erstellt Anwendung auf allen Plattformen läuft, auf denen eine virtuelle Maschine JVM
Seite 315 / 409
vorhanden ist. Dies macht Swing u.a. dadurch, dass es das komplette GUI selber zeichnet und
sich nicht auf die nativen Widgets des jeweiligen Betriebssystems abstützt. Dieses Vorgehen
hat mehrere Konsequenzen:
• Vorteile:
o Alle Swing Elemente stehen immer auf jeder JVM zur Verfügung, auch wenn das
zugrunde liegende OS gar keine entsprechenden Widgets kennt.
o Das Look&Feel von Swing Anwendungen kann jederzeit ausgetauscht werden, und dies
sogar zur Laufzeit. So ist z.B. auf einem Windows Rechner ein Motif Look&Feel möglich,
oder umgekehrt – siehe auch Kapitel 16.6.
• Nachteile:
o Bestimmte betriebssystem-spezifische Features sind nicht in Swing vorhanden, da sie nur
bedingt auf andere Plattformen abbildbar sind - z.B. die neuen Windows 7 Elemente69.
Aufgrund der vollständigen Kapselung der unter der JVM liegenden Plattform (OS und
Prozessor) besteht ausser via JNI70 auch keine Möglichkeit solche Features
anzusprechen.
o Swing GUIs sind etwas langsamer und speicherfressender als native Widgets – dies ist
aber in der Praxis meistens nicht relevant.
Die Klassen-Bibliotheken für die grafische Oberfläche haben sich in der Geschichte von Java
mehrmals geändert. Beim Umstieg vom JDK 1.0 zum JDK 1.1 wurde u.a. das Event-Modell
komplett umgekrempelt. Mit dem JDK 1.2 wurden die alten AWT (Abstract Window Toolkit)
Klassen um die neueren viel leistungsfähigeren JFC (Java Foundation Classes) Klassen
erweitert, die ein Bestandteil von Swing sind und die alten AWT Klassen als Basis-Klassen
beinhalten.
Im gesamten Tutorial wird mit den Swing-Klassen gearbeitet und auf die alte AWT
Bibliotheken, soweit sie nicht noch als Basis von Swing relevant sind, gar nicht mehr
eingegangen.
Dieses Kapitel stellt nur eine erste Einführung in die Programmierung von grafischen
Oberflächen dar, indem es das berühmte „Hallo Welt“ implementiert. In den folgenden Kapiteln
werden einzelne Bereiche der Programmierung von grafischen Oberflächen weiter vertieft.
Hinweis – die Swing Packages wurden mit dem JDK 1.2 gegenüber Vorversionen umbenannt.
Wer also mit Quelltexten aus der JDK 1.1.x Phase konfrontiert wird, dem werden veraltete
import Anweisungen begegnen:
• Früher „com.sun.java.swing“
• Jetzt: „javax.swing“
Lange Zeit war mein Standard Beispiel die Unterstützung von Tray-Icons, aber seit dem JDK
1.6 werden nun auch diese unterstützt. Hier sehen Sie damit auch sehr schön, warum die Java
Bibliothek so gross sein muß: da die OS-API nicht direkt zur Verfügung steht, müssen alle
Fähigkeiten des OS in der Java Bibliothek abgebildet werden.
70 JNI (Java Native Interface) ist eine Schnittstelle in Java, mit der C Funktionen angesprochen
werden können.
69
Seite 316 / 409
Bemerkung – mittlerweile gibt es mehrere alternative GUI-Toolkits für Java, relevant davon
sind aber eigentlich nur folgende beiden:
• Eins davon ist SWT, das im Rahmen des Eclipse Projekts entwickelt wurde. Im Gegensatz
zu Swing baut es auf die native Widgets des jeweiligen Betriebssystems auf. Dadurch ist
das Look&Feel von SWT besser auf das OS abgestimmt und SWT ist auch performanter.
Auf der anderen Seite macht man sich politisch aber von einem Toolkit abhängig, das nicht
fester Bestandteil von Java ist, und eben daher nicht automatisch auf allen Plattformen mit
einer JVM verfügbar ist. Außerdem ist SWT nicht so gut erweiter- und anpaßbar wie Swing.
Dafür bietet es mit dem RCP (Rich-Client-Plattfom) Framework eine mächtige und sehr
hilfreiche Basis für Applikations-Entwicklung.
• Seit neustem exisitiert auch eine Java Anbindung der C++ GUI Klassen-Bibliothek QT, die
z.B. als C++ Version das GUI-Toolkit für den KDE Desktop unter Linux darstellt.
Achtung – die Kapitel über GUIs mit Swing sind natürlich nur eine kleine Einführung. Das
Thema GUI Entwicklung ist viel zu umfangreich, als das es hier umfassend behandelt werden
könnte - allein mit Swing kann man ganze Bücher füllen71. Diese Einführung versucht die
wichtigsten Konzepte von GUI Programmierung und Swing vorzustellen
16.1 Ein einfaches Fenster
Wenn es nur darum geht, ein Fenster auf den Bildschirm zu zaubern, hält sich der Aufwand in
Grenzen – wir haben das Programm schon in Kapitel 3.1.2 kennen gelernt.
public class Appl {
JFrame frame = new JFrame("Mein GUI Fenster 1");
}
}
In „main“ wird ein Objekt der Swing-Frame Klasse „JFrame“ erzeugt, die für ein einfaches
Fenster darstellt – dem Konstruktor wird der Fenstertitel übergeben. Mit ‘setLocation’ wird der
Startort, mit ‘setSize’ die Grösse, und mit ‘setVisible’ die Sichtbarkeit gesetzt. Fertig.
Aber diese Minimal-Lösung hat mehrere Nachteile:
• Mit Schliessen des Fensters wird nicht mal das Programm beendet - sie können es nur auf
der Kommandozeile mit [Strg]+[C] abschiessen.
• Das JFrame-Klasse liefert nur ein allgemeines Default-Verhalten, das eigentlich nie reicht. In
dem Fenster soll ja schließlich was passieren.
Um mit dem Schliessen des Fensters das Programm zu beenden, muss für das Fenster ein
71
Die es auch gibt – dicke Wälzer nur über Swing.
Seite 317 / 409
entsprechendes Flag gesetzt werden – dies geschieht mit „setDefaultCloseOperation“ und der
Konstanten „JFrame.EXIT_ON_CLOSE“.
public class Appl {
JFrame frame = new JFrame("Mein GUI Fenster 2");
}
}
In einem späteren Kapitel über Event-Handling werden wir das Beenden des Programms beim
Schließen des Fensters anders lösen, indem wir uns selber in die Event-Bearbeitung
einhängen. Aber das wird nur ein Beispiel zum Verständnis des Event-Handlings in Swing sein
– der normale Weg sollte der hier beschriebene mit dem Setzen der Default-Close-Operation
sein.
16.2 Ein etwas besseres Fenster
Besser wäre also ein eigenes Fenster, das wir nach unseren Vorstellungen formen
(programmieren) können - wir würden das Default-Verhalten von JFrame aber gerne
beibehalten. Was macht man dann in Java? Natürlich erben!
Hier ein zweites Programm, das zwar nicht mehr kann als das vorherige, aber schon mal die
Vorbereitungen für mehr darstellt.
public class Appl {
MyFrame frame = new MyFrame("Mein eigenes Fenster");
}
}
public class MyFrame extends JFrame {
public MyFrame(String title) {
super(title);
}
}
Im Prinzip ist es das alte Programm – nur wird statt der Swing Klasse „JFrame“ eine eigene
Frame-Klasse „MyFrame“ benutzt, die sich von „JFrame“ ableitet. Da „MyFrame“ keine neue
Funktionalität hinzufügt, verhält sich das neue Programm wie das alte.
Seite 318 / 409
16.3 Ein grafisches „Hallo Welt“
16.3.1 Das normale grafische „Hallo Welt“
Um ein grafisches „Hallo Welt“ zu erhalten, müssen wir im Fenster auch „Hallo Welt“ ausgeben.
Wie macht man das?
• Immer, wenn ein Fenster neu gezeichnet werden muss, wird automatisch die Funktion
„paint“ aufgerufen, die daher für eigene Ausgaben überschrieben werden muss – siehe
weiter unten und Kapitel 17.
• Die Funktion „paint“ bekommt ein „Graphics“ Objekt übergeben72, das u.a. Funktionen für die
Textausgabe in einem Fenster zur Verfügung stellt – siehe Kapitel 16.4.
import java.awt.Graphics;
super(title);
}
public void paint(Graphics g) {
super.paint(g);
g.drawString("Hallo Welt", 50, 50);
}
}
Für die Ausgabe überschreiben wir die Funktion „paint“, die an den Koordinaten „50/50“ den
Text „Hallo Welt“ ausgibt - mehr dazu in Kapitel 17 und Kapitel 16.4.
Abb. 16-1 : Ein grafisches „Hallo Welt“ Programm
Achtung - es ist ganz wichtig - nicht nur für die Funktion „paint“ sondern auch für viele weitere
Funktionen, die wir zukünftig kennenlernen werden - dass zuerst die überschriebene Funktion
der Basis-Klasse (hier „paint“) aufgerufen wird. Das Neu-Zeichnen unseres Fensters besteht ja
nicht nur aus der Ausgabe von „Hallo Welt“, sondern noch aus anderen Dingen - und die
geschehen natürlich in den Basisklassen, und sollten nicht verhindert werden. Und man sollte
zuerst die Super-Funktion aufrufen, da sie ansonsten möglicherweise alle unsere Aktionen
wieder zerstört.
Genau genommen wird ein „java.awt.Graphics2D“ übergeben – aber diese Details ignorieren
wir erstmal.
72
Seite 319 / 409
Hinweis – warum funktioniert das? Hier ist natürlich wieder Vererbung und Polymorphie im
Spiel. Der interne Fenster-Verwaltungs-Mechanismus der JVM kennt unsere Fenster Klasse
„MyFrame“ natürlich nicht, aber er arbeitet auf einer Basisklasse von „MyFrame“. In dieser ist
die Funktion „paint“ definiert, und die wird intern aufgerufen. Wir haben diese Funktion aber
nun überschrieben, und dank Polymorphie landet damit der Aufruf von „paint“ in
„MyFrame.paint“.
16.3.2 Probleme mit dem JDK 1.5 und zum Teil auch mit dem JDK 1.6
Das im vorherigen Kapitel 16.3.1 beschriebene Java-Programm funktioniert mit dem JDK 1.5
und manchen JDK 1.6 Versionen nicht fehlerfrei73 - zumindest in den von mir getesten
Versionen 1.5.0_04 bis 1.5.0_09. Mit allen möglichen alten JDKs, z.B. 1.2, 1.3, 1.4, 1.4.1, 1.4.2
und auch mit einigen JDK 1.6 Versionen funktioniert das Programm korrekt.
Was ist denn hier nun das Problem? Ganz einfach – immer wenn das Fenster in irgendeiner
Form vergrößert wird (d.h. es wird mit der Maus oder der Tastatur größer gezogen, oder es
wird maximiert), dann wird der Inhalt des Fensters nicht neu gezeichnet, d.h. die Paint-Funktion
wird nicht aufgerufen.
In der realen Praxis ist dies kein Problem, da dort eigentlich nie direkt das Haupt-Frame für
Paint-Aktionen genutzt wird, sondern im Haupt-Frame eigentlich immer weitere GUI-Elemente
(z.B. Menüs, Buttons, Panels, usw.) liegen. Und bei denen klappt das alles auch z.B. im JDK
1.5 problemlos.
Problematisch ist der Bug aber für dieses Tutorial und auch andere Lehrbücher. Denn hier
sollen die Beispiele natürlich möglichst einfach sein, weshalb im Frame oft keine weiteren
Elemente liegen – und damit tritt der Fehler auf.
In der Praxis sollten Sie sich dieses Problems bewußt sein – und die Musterlösungen aus dem
Tutorial entsprechend verändern. Eine mögliche Lösung z.B. ist das Frame mit einem eigenen
Panel (siehe Kapitel 20.8) zu füllen, und alle Aktionen statt im Frame im Panel unterzubringen.
Als Beispiel hier das „Hallo-Welt“ Programm in einer Version mit zusätzlichem Panel, die u.a.
auch mit dem JDK 1.5 funktioniert.
public class Appl {
MyFrame frame = new MyFrame("Hallo-Welt Fenster fuer das JDK 1.5");
}
Möglicherweise gibt es – wenn Sie dieses Tutorial lesen – eine neuere JDK Version. Und
möglicherweise ist dort der Bug nicht mehr vorhanden.
73
Seite 320 / 409
}
super(title);
getContentPane().add(new MyPanel());
}
}
import javax.swing.JPanel;
public class MyPanel extends JPanel {
super.paint(g);
}
}
16.4 Graphics Objekt
Die Klasse „java.awt.Graphics“ stellt die Schnittstelle eines Swing Programms für die Ausgabe
auf dem Bildschirm dar. Die Klasse bietet verschiedenste Element-Funktionen an um Pixel,
Linien, Kreise, Rechtecke, Texte, uvm. auf dem Bildschirm auszugeben.
Lassen sie sich von Eclipse einfach mal die Menge an Funktionen anzeigen, bzw. schauen sie
in die Java-Hilfe. Bei vielen Funktionen sagt der Name intuitiv was die Funktion macht, und
auch die Parameter benötigen kaum Erklärung, von daher sollten einfache Anwendungen kein
Problem sein.
Beispiele von Element-Funktionen in „java.awt.Graphics“
Funktion
void drawLine(int x1, int y1, int x2, int y2)
void drawRect(int x, int y, int width, int height)
void fillRect(int x, int y, int width, int height)
void drawOval(int x, int y, int width, int height)
void fillOval(int x, int y, int width, int height)
void setColor(Color c)
void setPaintMode()
void setXORMode(Color c1)
Beschreibung
Zeichnet eine Linie
Zeichnet ein Rechteck
Zeichnet ein ausgefülltes Rechteck
Zeichnet eine Elipse
Zeichnet eine ausgefüllte Elipse
Setzt die Zeichen-Farbe
Setzt den Zeichen-Mode auf Überschreiben
Setzt den Zeichen-Mode auf XOR zur
übergebenen Farbe
import java.awt.Color;
Seite 321 / 409
super(title);
setSize(380, 340);
}
super.paint(g);
g.fillOval(100, 100, 80, 50);
g.setColor(Color.RED);
g.drawRoundRect(40, 200, 300, 40, 20, 20);
g.setColor(Color.BLUE);
g.drawLine(50, 150, 300, 300);
}
}
Abb. 16-2 : Ein GUI Programm mit bunter Ausgabe im Fenster
Hinweis - während des normalen Programm-Ablaufs, z.B. bei einer Benutzer-Interaktion oder
während einer Berechnung, kann es ohne weiteres notwendig sein direkt auf den Bildschirm zu
zeichnen. Auch in diesen Fällen benötigt man ein Graphics Objekt - man kann es sich für jedes
Swing Objekt mit der Funktion „getGraphics()“ holen. Eine Anwendung dafür findet sich z.B. im
Scribble Programm in Kapitel 18.2.4.
Achtung – das Überschreiben der Paint-Funktion des Haupt-Fensters führt mit dem JDK 1.5 zu
Problemen – siehe Kapitel 16.3.2.
16.5 Klasse „Color“
Im letzten Beispiel wurde u.a. die Zeichen-Farbe für das Graphics Objekt auf „rot“ bzw. „blau“
gesetzt - siehe Kapitel 16.4. Für Farben gibt es die Klasse „java.awt.Color“. Sie enthält u.a.
Konstanten für die wichtigsten Farben wie „schwarz – BLACK“, „weiß – WHITE“, „rot – RED“,
„blau – BLUE“, „grün – GREEN“, usw.
Seite 322 / 409
Objekte der Klasse „Color“ können aber z.B. auch durch die gewünschten RGB Werte (rot,
grün, blau) erzeugt werden – die Klasse enthält hierfür verschiedene Konstruktoren.
Color c = new Color(128, 0, 128);
Die Graphics Klasse enthält die Funktion „setColor“ zum Setzen der Zeichen-Farbe.
Alle Swing Klassen haben die Funktionen „setForeground“ und „setBackgroundColor“, um die
Vorder- und Hintergrund-Farbe zu setzen – die Vordergrund-Farbe entspricht der Zeichenfarbe.
16.6 Änderung der Oberfläche in den Windows-Style
Alle GUI Programme in diesem Tutorial werden mit dem normalen Swing-Style erzeugt, d.h. der
Oberflächen-Skin ist Swing. Nehmen wir z.B. das GUI-Fenster aus Kapitel 19.4, das obwohl der
Screenshot unter Windows XP mit klassischem Windows Skin erzeugt wurde – nicht wirklich
nach Windows aussieht:
Abb. 16-3 : GUI-Fenster aus Kapitel 19.4 mit Swing-Style
Möglicherweise möchten Sie aber, dass Ihre Programme unter Windows auch einen WindowsStyle haben. Das können Sie in Swing erreichen, indem Sie in Ihrem Programm den Style
entsprechend setzen. Hier der Quelltext aus Kapitel 19.4 mit verändertem Windows-Style:
import javax.swing.UIManager;
public class Appl {
try {
UIManager.setLookAndFeel(
"com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
} catch (Exception e) {
Seite 323 / 409
// Klappt es wohl nicht - auch egal - dann eben mit Swing-Style...
}
MyFrame frame = new MyFrame();
}
}
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JPanel;
@SuppressWarnings("serial")
public MyFrame() {
super("Fenster mit verschachtelten Layouts");
setSize(400, 300);
JPanel panel = new JPanel(new GridLayout(3, 2));
panel.add(new JButton("1"));
Container c = getContentPane();
c.setLayout(new BorderLayout());
c.add(new JButton("North"), BorderLayout.NORTH);
c.add(new JButton("West"), BorderLayout.WEST);
c.add(new JButton("East"), BorderLayout.EAST);
c.add(new JButton("South"), BorderLayout.SOUTH);
c.add(panel, BorderLayout.CENTER);
}
}
Abb. 16-4 : GUI-Fenster aus Kapitel 19.4 mit Windows-Style
Seite 324 / 409
16.7 Aufgaben
16.7.1 Aufgabe „Schwebende Kugel“
Implementieren sie ein Fenster, dass eine schwebende Kugel wie in der Abb. 16-5 enthält.
Hinweis – es sind wirklich nur die problemlosesen Zeichen-Funktionen aus Kapitel 16.4 benutzt
worden. Es ist einfach ein bisschen geschickt mit der Farbe gespielt worden.
Abb. 16-5 : Fenster mit schwebender Kugel
16.7.2 Aufgabe „Farb-Fenster“
Implementieren sie ein Fenster, dessen Inhalt viele kleine Quadrate sind, die jeweils eine
andere Farbe haben. Überlegen sie, wie sie die drei Farb-Dimensionen „RGB“ auf eine zweidimensionale Fläche abbilden, bzw. wie die den Farb-Raum sinnvoll reduzieren.
Seite 325 / 409
16.8 Lsg. zu Aufgabe „Schwebende Kugel“ – Kap. 16.7.1
todo...
16.9 Lsg. zu Aufgabe „Farb-Fenster“ – Kap. 16.7.2
todo...
17 Philosophie der GUI Programmierung
Bevor wir weiter gehen, müssen einige Dinge über die Philosophie von GUI Programmierung
gesagt werden. Diese Dinge sind ganz unabhängig von Swing oder Java, sondern gelten wohl
für alle GUI Bibliotheken.
• Der Bildschirm gehört nicht dem Programm oder einem Fenster, sondern dem
Betriebssystem.
• Der Kontrollfluß wird vom GUI vorgegeben und ist stark interaktiv.
17.1 Besitzer des Bildschirms
Im Gegensatz zu alten DOS oder CPM Zeiten unterstützen heute alle modernen
Betriebssysteme die Möglichkeit mehrere Programme gleichzeitig auszuführen74. Wenn dann
diese Programme noch GUI Anwendung sind, wie die meisten Anwendungen heute, hat das
einige Konsequenzen für den Zugriff auf den Bildschirm:
• Ein Programm kann nicht einfach beliebig auf den Bildschirm schreiben, da es nicht
selbstverständlich ist, dass der Bildschirm ihm gehört, und nicht ein anderes Programm dort
seine Ausgaben macht.
• Ein Programm kann seinen Ausgabe-Zustand nicht auf dem Bildschirm abfragen, da
mittlerweile ein anderes Programm dort seine Ausgaben gemacht haben kann.
• Ein Programm muss immer in der Lage sein, seine Darstellung zu erneuern, da der
Benutzer die Fenster beliebig nach vorne, hinten, seitwärts und sonstwas verschieben kann,
d.h. ein bislang nicht sichtbarer Teil des Fensters oben liegt und neu gezeichnet werden
muss - siehe z.B. Kapitel 18.2.4 und Kapitel todo.
Die letzten beiden Punkte bedingen, dass ein Programm immer ein komplettes Modell75 seiner
Ausgabe enthalten muss. Damit kann ein Programm dann jederzeit seine Darstellung auf dem
Bildschirm erneuern, wenn es dazu aufgefordert wird. Dies geschieht via OS, JVM und PaintDas heisst, sie sind multitasking fähig.
Mit Modell sind hier alle Daten und deren Beziehungen gemeint, die das Programm
visualisiert.
74
75
Seite 326 / 409
Funktion.
17.2 Kontrollfluß
Klassische Programme wurden oft nach dem EVA Prinzip76 aufgebaut - hierbei ist der
Programmfluss relativ einfach - ein Schritt folgt nach dem anderen.
Abb. 17-1 : Aufbau klassischer Programme
Auch komplexere klassische Programme haben eine klare Kontrollflußsteuerung in ihrer
Programmlogik. Ein Beispiel dafür ist unser „Tic-Tac-Toe“, dessen „main“ den Kontrollfluß klar
vorgibt – siehe Kapitel 12.11.1.
In einem modernen grafischen Benutzerinterface werden viel höhere Anforderungen an ein
Programm gestellt. Der Benutzer kann beliebige Aktionen durch die Tasten, Menü, Buttons,...
auswählen, er kann das Fenster vergrössern, verkleinern, in den Hintergrund legen bzw. nach
vorne holen. Andere Programme können die Umgebung verändern, der Benutzer kann neue
Einstellungen vornehmen - und auf all das muss das Programm jederzeit sauber und
kontrolliert reagieren.
Damit dies mit einem halbwegs vernünftigen und überschaubaren Programmieraufwand
möglich ist, hat sich das Programmiermodell von EVA hin zu einem Event-gesteuertem Modell
verändert. Hierbei liegt die Kontrolle nicht mehr primär bei dem Programm, sondern beim
Betriebssystem, das bei jedem Ereigniss (Event) eine entsprechende Funktion des Programms
aufruft – sogenannte „Callback-Funktionen“.
Abb. 17-2 : Aufbau Event-gesteuerter Programme
Dieses event-gesteuerte Programmiermodell hat sich in der Praxis sehr bewährt, und findet
sich natürlich auch in Java wieder. An jedes mögliche Ereignis kann der Programmierer eine
Funktion ankoppeln, die bei ihrem Auftritt automatisch ausgeführt wird.
Das ganze ist am Anfang recht ungewohnt, und es sind viele Fragen zu klären:
• Wie kann auf Events reagiert werden, d.h. wie wird eine Callback-Funktion in Java
implementiert?
• Wie können Events verhindert oder modifiziert werden können?
• Wie werden Events bei mehreren aufeinanderliegenden grafischen Elementen propagiert?
• Können Events programmgesteuert ausgelöst werden?
• Welche Elemente können Events auslösen, und welche darauf reagieren?
• Wie können Events und die dahinter liegende Benutzerlogik von den Daten und der
Programmlogik getrennt werden?
76
Eingabe, Verarbeitung, Ausgabe
Seite 327 / 409
Diese und weitere Fragen müssen von einem Event-Modell beantwortet werden - und dieses
Modell gibt damit den Rahmen - oder auch die Philosophie - vor, in dem ein Programmierer ein
Programm Design erschaffen und implementieren kann und muss.
Hinweis – damit haben wir natürlich ein Problem mit unserer Tic-Tac-Toe Lösung aus Kapitel
14.24 bzw. auch den darauf aufbauenden Lösungen. In dieser Lösung liegt die Steuerung des
Kontrollflußes klar auf der Seite der Spiele-Logik, während uns das GUI Programmier-Modell
diese Option nicht läßt. In einem späteren Kapitel werden wir mögliche Lösungen dieses
Konflikts diskutieren.
18 Event-Modelle von Swing
Swing kennt zwei Event-Modelle:
• das interne Event-Modell – siehe Kapitel 18.2, und
• das externe Event-Modell – siehe Kapitel 18.3.
Achtung – nicht Java kennt zwei Event-Modelle, sondern Swing. Die Sprache stellt AusdrucksElemente zur Verfügung, in deren Rahmen Bibliotheken und Programme entwickelt werden
können. Wie eine Bibliothek (wie z.B. Swing) dann ihr Funktionalität dem Benutzer zur
Verfügung stellt – d.h. wie sie benutzt wird – ist eine Frage der Bibliothek und nicht der
Sprache. Die Sprache gibt den Rahmen vor indem sie sich bewegen kann.
Hinweis – in Java, genau genommen in den GUI Bibliotheken von Java, hat sich die
Philosophie des Event-Handlings, d.h. das Event-Modell, mehrmals geändert. Die EventModelle der JDKs 1.0, 1.1 und 1.2 unterscheiden sich zum Teil sehr stark voneinander. Dies
spiegelt sich weniger in der Sprache wieder77, sondern in erster Linie in den sehr
unterschiedlichen GUI Bibliotheken der JDK Versionen.
18.1 Events und Gruppierungen
Ein unerfahrener Programmierer mag sich die Frage stellen: „Welche Events gibt es
überhaupt?“
Grundsätzlich ist ein Event eine elementare Aktion des Benutzers, die eine Reaktion des
Programms zur Folge haben kann. Dazu gehören z.B.:
• Jede Art der Tastatur-Betätigung.
• Jede Maus-Aktion wie Linksklick, Rechtsklick, Linksdoppelklick, Maus bewegen, usw.
Da das Event-Modell eine Eigenschaft einer Bibliothek ist, sollte es sich eigentlich in keiner
Weise in der Sprache wiederspiegeln. Aber das JDK 1.1 ist u.a. um die inneren Klassen –
siehe Kapitel 15 – erweitert worden, um das neue externe Event-Modell eleganter
programmieren zu können.
77
Seite 328 / 409
• Fenster-Aktionen wie Fenster wird bewegt, vergrößert, verkleinert, minimiert, maximiert,
geschlossen, usw.
• Fokus-Aktionen, d.h. ein Element verliert bzw. bekommt den Fokus.
• uvm.
Die exakt vorhandenen Events sind vom jeweiligen grafischen Element abhängig, das den
Fokus hat. Z.B. hat ein Baum-Element sicher Events für das Selektieren von Einträgen, für das
Auf- und Zuklappen von Teilbäumen, uvm. Diese Events machen aber z.B. für ein einfaches
Fenster gar keinen Sinn.
Da alle grafische Elemente viele Events haben, sind diese in Swing gruppiert. Gerade
komplexere Elemente wie Tabellen und Bäume wären sonst sehr unübersichtlich. So gibt es
z.B. bei den meisten GUI Elementen drei Gruppen von Maus-Events:
• Mouse
• MouseMotion
• MouseWheel
Hinweis – es kann auch programm-interne Events geben, z.B. Timer-Events – siehe Kapitel
20.10 – aber die meisten Events werden durch externe Aktionen des Benutzers angestoßen,
wie Tastatur- oder Maus-Aktionen. Um die Sache einfach zu halten, gehen wir im folgenden
davon aus, dass alle Events von außen angestoßen werden. Ist dies nicht der Fall, durchläuft
das Event nur nicht soviele Stufen – die grundsätzliche Abarbeitung in Swing ist aber immer
gleich.
18.2 Internes Event-Modell
18.2.1 Der Fluß eines Events
Jedes Event, das der Benutzer auslöst – z.B. das Klicken mit der linken Maus-Taste in ein
Fenster – durchläuft mehrere Stufen:
• Das Betriebssystem bildet dabei die unterste Ebene. Es interagiert mit Hilfe von Treibern mit
der Hardware, und wird von jeder Aktion unterrichtet. Das BS interpretiert die Aktion, und
leitet sie gegebenenfalls an das aktive Programm weiter – in unserem Fall die JVM.
• Die JVM kennt das aktuelle Fenster – genau genommen das grafische Element, das den
Fokus hält – und ruft eine entsprechende Event-Behandlungs-Funktion auf.
• Das aktive grafische Element hat sich beim Erzeugen automatisch bei der JVM registriert –
dies passiert automatisch in den Konstruktoren der Basisklassen - und hat die
entsprechende Event-Behandlungs-Funktion möglicherweise überschrieben. So erfährt es
von dem Event und kann darauf reagieren.
• Hierbei wird zuerst die Funktion „processEvent“ aufgerufen, die das Event dann auf die
jeweiligen Event-Gruppen „process“ Funktionen verteilt - siehe Kapitel 18.2.2.
Abb. 18-1 : Der Fluß eines Events
Seite 329 / 409
18.2.2 Swings „process“ Funktionen und Event-Klassen
Für jede Gruppe gibt es in den Swing Klassen „process“ Funktionen, die bei den jeweiligen
Events aufgerufen werden. Hier ein Teil der „process“ Funktionen der Fenster Klasse
„JFrame“78:
• protected void processWindowEvent(WindowEvent e)
• protected void processWindowFocusEvent(WindowEvent e)
• protected void processWindowStateEvent(WindowEvent e)
• protected void processKeyEvent(KeyEvent e)
• protected void processMouseEvent(MouseEvent e)
• protected void processMouseMotionEvent(MouseEvent e)
• protected void processMouseWheelEvent(MouseWheelEvent e)
Alle diese Funktionen sind „protected“, da sie nicht von außen aufgerufen werden sollen, aber
natürlich zum Überschreiben gedacht sind, d.h. in den abgeleiteten Klassen ansprechbar sein
müssen.
Alle „process“ Funktionen bekommen ein Event-Objekt als Parameter, das detailierte
Informationen zum jeweiligen Event enthält. Welche Informationen das jeweils sind, ist vom
jeweiligen abhängig.
Die Namen der Event-Klassen entsprechen häufig dem dem der jeweiligen „process“ Funktion
ohne Präfix „process“, d.h. die Funktion „processKeyEvent“ z.B. bekommt einen Parameter
vom Typ „KeyEvent“.
Die Event-Klassen sind in den verschiedensten Packages definiert. Aber die grundlegenden
Event-Klassen wie „WindowEvent“, „KeyEvent“ oder „MouseEvent“ kommen aus
„java.awt.event“.
Achtung – im Normallfall sollte eine überschriebene „process“ Funktion zuerst die
überschriebene Basis-Klassen Funktion aufrufen. Geschieht dies nicht, schneiden sie die
geerbte Event-Behandlung vom Event-Fluß ab – d.h. sie entfällt komplett. Im Normallfall
werden sie dies nicht erreichen wollen, ganz im Gegenteil.
Achtung - ein Teil der „process“ Funktionen - wie z.B. „processMouseMotionEvent“ - müssen
explizit aktiviert werden. Der Grund ist, dass manche dieser Events sehr häufig passieren
können - z.B. Bewegungen der Maus. Je nach Event-Gruppe, Plattform und Anwendung
könnte diese aufwändige Event-Verarbeitung zu einer spürbaren PerformanceVerschlechterung führen. Auf modernen Hardware-Plattformen sollte dies zwar nicht der Fall
sein, aber beim Design von Swing wurde hier auf „Nummer Sicher“ gegangen.
„process“ Funktionen können explizit mit der Funktion „enableEvents“ und einer passenden
Die Klasse „JFrame“ hat - obwohl aus Sicht des GUIs eine recht einfache Klasse - immerhin
schon 14 „process“ Funktionen (Stand JDK 1.4.2).
78
Seite 330 / 409
Bitmaske an- und ausgestellt werden - siehe z.B. Kapitel 18.2.4. Implizit werden sie auch mit
der Registrierung eines entsprechenden Listener-Objekts aktiviert - siehe Kapitel 18.3.2.
18.2.3 Beispiel „WindowClose“
In Kapitel 16.1 haben wir gelernt wie man ein erreicht, dass das Schließen eines „JFrame“
automatisch auch das Programm beendet. Selbst wenn die dort dargestellt Methode sicher für
die meisten Fälle ausreichend und sinnvoll ist, wollen wir hier als Beispiel dies mal selber
implementieren.
Dazu muß man wissen, dass das Schließen eines Fensters unter die normalen Window-Events
fällt.
• Daraus folgt, dass wir in unserer eigenen Frame-Klasse die Funktion „processWindowEvent“
überschreiben müssen.
• Dann wollen wir auf den Event-Typ „WindowEvent.WINDOW_CLOSING“ reagieren, der mit
„getID()“ abgefragt werden kann.
• In diesem Fall wollen wir das Programm direkt beenden - dies geht mit „System.exit(0)“.
• Und auch hier gilt - wie in Kapitel 18.2.2 und Kapitel 16.3 erklärt - dass natürlich zuerst die
Basis-Klassen Funktion „processWindowEvent“ aufgerufen werden sollte.
Alles zusammen ergibt das dann folgendes Programm:
public class Appl {
MyFrame frame = new MyFrame("Fenster mit eigenem Programm-Ende");
// Nicht mehr notwendig - darum kuemmern wir uns jetzt selbst
// frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
import java.awt.event.*;
import javax.swing.*;
super(title);
}
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
}
Seite 331 / 409
18.2.4 Beispiel „Scribble“
Um das interne Event-Modell näher zu verstehen, wollen wir eine erste Version eines „Scribble“
Programms mit Hilfe des internen Event-Modells implementieren.
Scribble ist quasi ein extrem einfaches Zeichen-Programm, bei dem sie mit der Maus Kurven
und Linien in das Fenster zeichnen können.
• Mit dem Drücken einer beliebigen Maus-Taste beginnt das Zeichnen.
• Solange die Maus-Taste gedrückt ist, wird entsprechend den Maus-Bewegungen
gezeichnet.
• Mit dem Loslassen der Maus-Taste endet die Zeichen-Aktion.
Abb. 18-2 : Ein einfaches Scribble Zeichen-Programm
Als erstes müssen wir uns überlegen, wie das Programm prinzipiell arbeiten soll:
• Die gezeichneten Striche sind Geraden zwischen den Punkten, die für die Maus-Bewegung
als Event gemeldet werden.
• Für den ersten Strich benötigen wir also die x/y Koordinate der Maus beim Maus-Klick und
nach der ersten Maus-Bewegung. Die x/y Koordinaten der Maus beim Maus-Klick müssen
also gespeichert werden - hierzu werden zwei Attribute „lastX“ und „lastY“ in der FensterKlasse definiert.
• Für alle weiteren Striche werden die x/y Koordinaten zwischen Ende des letzten Strichs und
der jeweils nächsten Maus-Bewegung benötigt - auch hier benutzen wir zur Speicherung die
Attribute „lastX“ und „lastY“.
• Das Loslassen der Maus-Taste ist kein relevantes Event, da es an einer Maus-Position
passiert, die schon als Maus-Bewegung gemeldet wurde.
• Damit auch nur ein einzelner Maus-Klick gezeichnet wird, muss noch der erste Punkt explizit
gezeichnet werden.
Seite 332 / 409
Folgende Events sind also für Scribble wichtig:
• Eine beliebige Maus-Taste wurde gedrückt - dies fällt unter die normalen Maus-Events, d.h.
die Funktion „processMouseEvent“ muss überschrieben werden. Das relevante Event ist
das mit der ID „MouseEvent.MOUSE_PRESSED“ - die x/y Koordinaten können mit „getX“
und „getY“ erfragt werden.
• Das Ziehen mit gedrückter Maus-Taste muss verfolgt werden - dies ist eine Drag-Aktion und
fällt unter die Maus-Motion-Events, d.h. die Funktion „processMouseMotionEvent“ muss
überschrieben werden. Das relevante Event ist hier das mit der ID
„MouseEvent.MOUSE_DRAGGED“.
Und so ergibt sich folgender Quelltext für unser „Scribble 1“. Denken sie daran, dass beide
Event-Gruppen explizit mit „enableEvents“ aktiviert werden müssen - siehe auch Kapitel 18.2.2.
public class Appl {
JFrame frame = new ScribbleFrame("Scribble 1 : internes Event-Modell");
}
}
import java.awt.*;
public class ScribbleFrame extends JFrame {
private int lastX;
private int lastY;
public ScribbleFrame(String title) {
super(title);
enableEvents(
AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
}
protected void processMouseEvent(MouseEvent e) {
super.processMouseEvent(e);
if (e.getID() == MouseEvent.MOUSE_PRESSED) {
onMousePressed(e);
}
}
protected void processMouseMotionEvent(MouseEvent e) {
super.processMouseMotionEvent(e);
if (e.getID() == MouseEvent.MOUSE_DRAGGED) {
onMouseDragged(e);
}
}
private void onMousePressed(MouseEvent e) {
lastX = e.getX();
lastY = e.getY();
Graphics g = getGraphics();
g.drawLine(lastX, lastY, lastX, lastY);
Seite 333 / 409
}
private void onMouseDragged(MouseEvent e) {
int x = e.getX();
int y = e.getY();
g.drawLine(lastX, lastY, x, y);
lastX = x;
lastY = y;
}
}
Hiemit haben sie ein ganz einfaches Scribble programmiert, das aber genau unter der in
Kapitel 17.1 beschriebenen Problematik leidet: „Der Bildschirminhalt kann und wird auf
Anforderung nicht neu gezeichnet, d.h. er geht unter Umständen verloren.“
Probieren sie es aus: Minimieren sie z.B. das Fenster, schieben sie es in den Hintergrund, oder
verschieben sie es zum Teil aus dem Bildschirmbereich, und stellen sie es dann wieder her.
Der Bildschirm ist dann leer. Das Fenster muss neu gezeichnet werden, und zum Teil wird es
das auch, denn um Rahmen, Titelleiste, usw. kümmern sich die Swing Basis-Klassen. Aber
unser Inhalt fehlt, da wir uns nicht darum kümmern.
Wir werden dieses Problem in Kapitel 18.5 lösen, aber vorher schauen wir uns das externe
Event-Modell an.
18.3 Externes Event-Modell
Das externe Event-Modell baut auf das sogenannte Observer Pattern auf. Von daher macht es
Sinn, das Oberver-Pattern kurz für sich zu besprechen.
„Design Pattern“ bzw. Entwurfsmuster79 stellen mehr oder weniger fest umrissene DesignEntwürfe für konkrete Problem-Situationen dar. Sie enthalten keine exakte Code-Vorgabe,
sondern sie erklären das konzeptionelle Klassen-Gerüst und die Verteilung der Aufgaben, um
ein Problem zu lösen. Normalerweise finden sie d.h. keinen fertigen Quelltext, der nur noch
abgetippt werden muß, wie z. B. bei Algorithmen, sondern sie müssen selbständig den Entwurf
in passenden Code für ihr Projekt überführen.
18.3.1 Observer Pattern
18.3.1.1 Problem
Ein häufiges Problem ist, dass parallel mehrere (oftt unterschiedliche) Sichten auf einen DatenBestand existieren. Wird der Daten-Bestand nun über eine der Sichten geändert, sollen sich
alle anderen mit aktualisieren.
Entwurfsmuster sind ein wichtiges Thema in der Software-Entwicklung. Die Bibel der
Entwurfsmuster ist das sehr empfehlenswerte Buch „Entwurfsmuster“ von Gamma, Helm,
Vlissides und Johnson.
79
Seite 334 / 409
Ein sehr großes Beispiel wäre eine Daten-Visualisierung, bei der die Daten sowohl in Form
einer Tabelle als auch in Form verschiedener Grafiken angezeigt werden. Werden nun die
Daten in einer Sicht manipuliert, so sollen sich die anderen Sichten parallel anpassen
Ein anderes – vielleicht aktuelleres Beispiel – ist Eclipse. Änderungen im Quelltext werden
simultan im Package-Explorer, im Outline und in anderen Sichten angezeigt.
Das grundsätzliche Problem „ich-bin-interessiert-an-Änderungen-der-Daten“ ist ein StandardProblem der Software-Entwicklung und exisitiert in allen Größen-Ordnungen. Aber wie löst man
es verständlich, wartbar, übersichtlich, erweiterbar, wiederverwendbar, usw. in einer objektorientierten Sprache? Die Antwort ist das Observer-Pattern.
18.3.1.2 Lösung
•
•
•
•
Allgemeine abstrakte Basis-Klasse für die Daten
Allgemeines Interfaces für die Sichten
Kopplung nur zwischen der Basis-Klasse und dem Interface
Benachrichtigungs-Mechanismus wird nur einmal in der Daten-Basis-Klasse implementiert,
die konkreten Daten erben ihn.
Abb. 18-3 : Klassen-Diagramm Observer-Pattern
Abb. 18-4 : Interaktion Observer-Pattern
18.3.1.3 Betrachtung der Abhängigkeiten der Klassen
todo...
18.3.1.4 Umsetzung in Java
todo...
Abb. 18-5 Klassen-Diagramm Observer-Pattern in Java
public class Observable {
private ArrayList observers = new ArrayList();
public void addObserver(Observer obs) {
observers.add(obs);
}
public void notifyObservers() {
Seite 335 / 409
Iterator i = observers.iterator();
Observer obs = (Observer)i.next();
obs.update();
}
}
}
public class Data extends Observable {
private String date = "";
public void setDate(String arg) {
date=arg;
super.notifyObservers();
}
public String getDate() {
return date;
}
}
public interface Observer {
public void update();
}
import java.io.*;
public class View1 implements Observer {
private Data data;
public View1(Data d) {
data = d;
data.addObserver(this);
}
public void update() {
System.out.println("View 1 Daten \"" + data.getDate() + '"');
}
public void editData() {
System.out.print("View 1 - bitte geben sie neue Daten ein:\n> ");
try {
data.setDate(in);
}
}
}
}
import java.io.*;
public class View2 implements Observer {
private Data data;
public View2(Data d) {
data = d;
data.addObserver(this);
}
Seite 336 / 409
public void update() {
System.out.println("View 2 Daten \"" + data.getDate() + '"');
}
public void editData() {
System.out.print("View 2 - bitte geben sie neue Daten ein:\n> ");
try {
data.setDate(in);
}
}
}
}
public class Appl {
Data data = new Data();
View1 view1 = new View1(data);
View2 view2 = new View2(data);
data.setDate("Aus main");
view1.editData();
view2.editData();
}
}
mögliche Ausgabe
View 1 Daten "Aus main"
View 2 Daten "Aus main"
View 1 - bitte geben sie neue Daten ein:
> Dateneingabe via View1
View 1 Daten "Dateneingabe via View1"
View 2 Daten "Dateneingabe via View1"
View 2 - bitte geben sie neue Daten ein:
> Und was aus View 2
View 1 Daten "Und was aus View 2"
View 2 Daten "Und was aus View 2"
Hinweis – da das Oberver-Pattern ein Standard-Problem in der Software-Entwicklung ist, gibt
es schon seit dem JDK 1.0 in der Java Bibliothek die Klasse „java.util.Observer“ und das
Interface „java.util.Observable“. Für viele Probleme sind diese Klassen allemal ausreichend.
18.3.2 Listener-Interfaces
Das externe Event-Modell ist im Prinzip die konsequente Anwendung des Observer Patterns
auf Events. Jedes Event wird quasi als Daten-Änderung eines Observables betrachtet und an
alle registrierten Observer gesendet.
Für jede Event-Gruppe – siehe Kapitel todo – gibt es ein entsprechendes Listener-Interface
(das entspricht quasi dem Observer-Interface im Observer-Pattern). Und für jedes Event der
Event-Gruppe gibt es eine abstrakte Funktion, die überschrieben werden muss (sie
entsprechen quasi jeweils der „update“ Funktion des Observer-Interfaces.
Hier beispielhaft die Definitionen der Listener-Interfaces für die Maus- und Maus-Motion-Events
Seite 337 / 409
aus dem Package „java.awt.event“:
package java.awt.event;
public interface MouseListener implements EventListener {
public
public
public
public
public
void
void
void
void
void
mouseClicked(MouseEvent e);
mousePressed(MouseEvent e);
mouseReleased(MouseEvent e);
mouseEntered(MouseEvent e);
mouseExited(MouseEvent e);
}
public interface MouseMotionListener implements EventListener {
public void mouseDragged(MouseEvent e);
public void mouseMoved(MouseEvent e);
}
Jedes GUI-Element, dass eine Event-Gruppe unterstützt, bietet entsprechende Funktionen an,
um Listener beim GUI-Element zu registrieren und wieder abzumelden. So hat die Klasse
„JFrame“ u.a. die Funktionen:
• public void addMouseListener(MouseListener l)
• public void removeMouseListener(MouseListener l)
• public void addMouseMotionListener(MouseMotionListener l)
• public void removeMouseMotionListener(MouseMotionListener l)
Hinweis – die Listener-Interfaces heißen immer wie die Event-Gruppen mit Postfix „Listener“.
Die zugehörigen „add“ und „remove“ Funktionen heißen immer wie die Listener-Interfaces mit
Präfix „add“ bzw. „remove“.
Wir könnten unser Scribble also auch folgendermassen implementieren: todo...
import java.awt.*;
public class ScribbleFrame
extends JFrame implements MouseListener, MouseMotionListener {
private int lastX;
private int lastY;
super(title);
addMouseListener(this);
addMouseMotionListener(this);
}
lastX = e.getX();
lastY = e.getY();
}
Seite 338 / 409
int x = e.getX();
int y = e.getY();
lastX = x;
lastY = y;
}
public void mouseClicked(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void mousePressed(MouseEvent e) {
onMousePressed(e);
}
public void mouseReleased(MouseEvent e) {
}
public void mouseDragged(MouseEvent e) {
onMouseDragged(e);
}
public void mouseMoved(MouseEvent e) {
}
}
18.3.3 Listener-Adapter-Klassen
Die notwendige Implementierung aller Funktionen der Listener-Interfaces ist häufig nervig,
denn in der Praxis werden viele Funktionen leer überschrieben, da das Event für die
Anwendung nicht wichig ist – siehe z.B. Quelltext „Scribble2“ in Kapitel 18.3.2.
Eine Alternative ist hier die Verwendung der Listener-Adapter-Klassen statt der ListenerInterfaces. Die Adapter-Klassen implementieren alle Funktionen des jeweiligen Interfaces mit
leeren Funktionen.
Hier beispielhaft die Definitionen der Listener-Adapter-Klassen für die Maus- und Maus-MotionEvents aus dem Package „java.awt.event“:
public class MouseAdapter implements MouseListener {
public
public
public
public
public
void
void
void
void
void
mouseClicked(MouseEvent e) {}
mousePressed(MouseEvent e) {}
mouseReleased(MouseEvent e) {}
mouseEntered(MouseEvent e) {}
mouseExited(MouseEvent e) {}
}
public class MouseMotionAdapter implements MouseMotionListener {
public void mouseDragged(MouseEvent e) {}
Seite 339 / 409
public void mouseMoved(MouseEvent e) {}
}
Das es überhaupt Interfaces gibt liegt daran, dass Java keine Mehrfach-Vererbung von Klassen
kennt, und daher z.B. das „Scribble2“ sich nicht von „JFrame“, „MouseAdapter“ und
„MouseMotionAdapter“ ableiten kann sondern nur von einer Klasse – siehe Kapitel todo.
Dem gegenüber kann eine Klasse beliebig viele Interfaces implementieren, und kann so
mehrere Aufgaben übernehmen – siehe auch Kapitel todo.
Hinweis – die Listener-Adapter-Klassen heißen immer wie die Event-Gruppen mit Postfix
„Adapter“.
18.3.4 Innere Klassen
Das „Scribble2“ in Kapitel todo ist erstmal kein wirklicher Fortschritt gegenüber dem „Scribble1“
in Kapitel todo – eher im Gegenteil, da auch die unbenutzten Interface-Funktionen leer
implementiert werden müssen.
Aber das externe Event-Modell hat gegenüber dem internen einen wichtigen Vorteil:
• Im internen Event-Modell muss man immer eine eigene Klasse schreiben, die sich von der
normalen Klasse ableitet und die entsprechende „process“ Funktion überschreibt. Eine
solche eigene abgeleitete Klasse ist aber spezifisch für das aktuelle Problem und könnte
daher nicht wiederverwendet werden. Daher benötigt man dann viele abgeleitete Klassen
mit sehr ähnlichem Code, was sehr unschön ist.
• Im externen Event-Modell dagegen können sie einen Observer beim zu beobachtenden
Element registrieren, ohne das sie dieses anpassen müßten.
Um diesen Unterschied zwischen den beiden Event-Modellen noch mal klar zu machen,
implementieren wir mit beiden Strategien die gleiche Aufgabe:
• Ausgabe der Maus-Koordinaten auf der Console bei Drücken einer beliebigen Maus-Taste in
einem Fenster.
• D.h. konkret soll beim Drücken einer beliebigen Maus-Taste in einem Fenster die möglichst
„private“ Element-Funktion „out“ der Klasse „Appl“ mit den x- und y-Koordinaten der Maus
aufgerufen werden.
• Die Element-Funktion „out“ der Klasse „Appl“ soll die Koordinaten dann mit einer Meldung
auf der Console ausgeben.
Bei der Aufgabe geht es darum, dass ein Event (hier Maus-Taste drücken) eines GUI-Elements
(hier das Fenster) für ein Objekt einer anderen Klasse (hier „Appl“) eine Aktion auslöst (d.h.
eine Element-Funktion aufruft). Dies ist eine Standard-Aufgabe. Denken sie z.B. an einen
Button in einem Fenster. Wird der Button betätigt soll im Fenster irgendwas passieren. Die
eigentliche Aktion ist also sicher nicht Bestandteil des Buttons, sondern des Fensters. Das
Fenster in unserer Aufgabe entspricht hier also dem Button, das „Appl“ Objekt dem Fenster,
und die „out“ Funktion der Aktion. Und da die Aktion ein Teil des Verhaltens des Gesamt© Detlef Wilkening 1997-2016
Seite 340 / 409
Moduls ist, sollte „out“ möglichst „private“ sein.
Hinweis – die Aufgabe ist absichtlich so gewählt, da sie mit unserem aktuellen Wissen
problemlos implementierbar ist, denn wir kennen die Fenster-Klasse „JFrame“ und die MausEvents, aber z.B. noch keine Buttons.
18.3.4.1 Implementierung mit dem internen Event-Modell
Um die Aufgabe mit dem internen Event-Modell zu lösen, muss:
• eine eigene Fenster-Klasse von „JFrame“ abgeleitet werden,
• die Maus-Events im Konstruktor enabled werden, und
• die entsprechende „process“ Funktion überladen werden.
Außerdem muß die Element-Funktion „out“ des „Appl“ Objekts aufgerufen werden können dazu muß das „Appl“ in unserer Fenster-Klasse bekannt sein - d.h. implementieren wir ein
entsprechendes Attribut „appl“ und setzen dies im Konstruktor, der nun natürlich auch einen
solchen Parameter benötigt. Die Funktion „out“ kann hierbei leider nicht „private“ sein.
Der Rest ist Pflicht, und sollte kein Problem mehr sein.
public class Appl {
appl.run();
}
private void run() {
MyFrame frame = new MyFrame(this);
}
public void out(int x, int y) {
System.out.println("Maus-Pressed an " + x + "/" + y);
}
}
import java.awt.AWTEvent;
import java.awt.event.MouseEvent;
private Appl appl;
public MyFrame(Appl a) {
super("Maus-Pressed Koordinaten auf Console via internem Event-Modell");
appl = a;
enableEvents(AWTEvent.MOUSE_EVENT_MASK);
}
protected void processMouseEvent(MouseEvent e) {
super.processMouseEvent(e);
if (e.getID() == MouseEvent.MOUSE_PRESSED) {
Seite 341 / 409
appl.out(e.getX(), e.getY());
}
}
}
18.3.4.2 Implementierung mit dem externen Event-Modell
Die Implementierung mit dem externen Event-Modell ist hier ganz einfach.
• Da „Appl“ keine Basis-Klasse hat80, können wir „Appl“ direkt von „MouseAdapter“ ableiten,
und sind nicht auf das Interface „MouseListener“ angewiesen. Darum brauchen wir auch nur
die „process“ Funktion überladen, die uns interessieren – siehe Kapitel todo.
• Da wir das externe Event-Modell benutzen und keine speziellen Fenster-Fähigkeiten
brauchen, können wir direkt die Fenster-Klasse „JFrame“ nehmen.
• Jetzt können wir die „out“ Funktion auch „private“ machen – siehe Aufgaben-Stellung.
import java.awt.event.MouseAdapter;
public class Appl extends MouseAdapter {
appl.run();
}
JFrame frame = new JFrame("M-P Ko auf Console via externem Event-Modell");
frame.addMouseListener(this);
}
out(e.getX(), e.getY());
}
private void out(int x, int y) {
}
}
Die Implementierung mit dem externen Event-Modell ist hier so einfach da:
• „Appl“ keine Basis-Klasse hat.
• Wir nur für ein GUI-Element „mousePressed“ überschreiben müssen.
18.3.4.3 Implementierung mit einer non-static Member-Klasse
Was wäre aber, wenn es zwei Fenster gäbe, für die die „MousePressed“ Events überwacht
werden müssen? Das ginge natürlich auch, aber dann müßte die Funktion „mousePressed“
Jedenfalls keine explizite von uns. Natürlich ist „Appl“ implizit von „java.lang.Object“
abgeleitet.
80
Seite 342 / 409
unterscheiden, welches Fenster das Event abgetriggert hat. Prinzipiell funktioniert das, da die
Event-Klassen (hier „MouseEvent“) u.a. auch Informationen über das Source-Element enthalten
– die Frage, die sich stellt, ist: „Will man das?“
Übertragen auf ein Fenster mit vielen Buttons hieße das z.B., dass die „mousePressed“
Funktion alle Buttons kennen und unterscheiden können muß. Das ergibt weder schönen noch
wirklich wartbaren Code. Besser wäre es sicher, pro Button eine eigene kleine unabhängige
„process“ Funktion zu haben.
Das Problem ist doch eigentlich, dass man folgendes braucht:
• Eine von „MouseListener“ abgeleitete „kleine“ Klasse.
• Am besten eine spezielle Klasse ohne explizite Basis-Klasse, damit man „MouseAdapter“
benutzen kann, und sie sich nur um die Event-Gruppe kümmern muss.
• Ein Objekt dieser Klasse muss mit dem Objekt der übergeordneten Klasse verbunden sein –
in unserem Beispiel z.B. mit dem „Appl“ Objekt, oder mit dem Fenster-Objekt im Button
Beispiel.
• Und es wäre schön, wenn sie auf die „private“ Elemente des übergeordneten Objekts
zugreifen könnte – z.B. auf „private“ Funktionen – um das Modul-Konzept der
übergeordneten Klasse nicht aufzubrechen.
Erinnern sie sich? So was gibt es, und nennt sich „eingebette nicht-static Klasse“, „innere nichtstatic Klasse“, „Member-Klasse“ oder auch „Element-Klasse“ – siehe Kapitel 15.2.
Schreiben wir unser Beispiel mal auf eine Member-Klasse um.
public class Appl {
class MouseEventTarget extends MouseAdapter {
}
}
appl.run();
}
JFrame frame = new JFrame("M-P Koor. auf Console mit Member-Klasse");
frame.addMouseListener(new MouseEventTarget());
}
}
}
Seite 343 / 409
18.3.4.4 Implementierung mit einer lokalen Klasse
Da die Klasse nur an einer Stelle benötigt wird, können wir sie auch zu einer lokalen Klasse
machen – siehe Kapitel 15.4.
public class Appl {
appl.run();
}
JFrame frame = new JFrame("M-P Koor. auf Console mit lokaler Klasse");
class MouseEventTarget extends MouseAdapter {
}
}
frame.addMouseListener(new MouseEventTarget());
}
}
}
18.3.4.5 Implementierung mit einer anonymen Klasse
Und da auch nur ein Objekt der Klasse benötigt wird, kann man daraus auch eine anonyme
Klasse machen – siehe Kapitel 15.5.
public class Appl {
appl.run();
}
JFrame frame = new JFrame("M-P Koor. auf Console mit anonymer Klasse");
frame.addMouseListener(new MouseAdapter() {
Seite 344 / 409
}
});
}
}
}
Die Verwendung einer anonymen Klasse – abgeleitet von einer Event-Adapter-Klasse –
als Event-Listener-Klasse ist das normale Verfahren zum Event-Handling in Swing.
18.3.5 Scribble 3 mit anonymen Listener-Klassen
Lassen sie uns jetzt unser Scribble mit dem externen Event-Modell und anonymen ListenerKlassen implementieren.
public class Appl {
JFrame frame = new ScribbleFrame("Scrib 3 mit anonymen Listener-Klassen");
}
}
import java.awt.*;
private int lastX;
private int lastY;
super(title);
addMouseListener(new MouseAdapter() {
onMousePressed(e);
}
});
addMouseMotionListener(new MouseMotionAdapter() {
onMouseDragged(e);
}
});
}
lastX = e.getX();
lastY = e.getY();
}
Seite 345 / 409
int x = e.getX();
int y = e.getY();
lastX = x;
lastY = y;
}
}
18.4 Vergleich der Event-Modelle
Wann nimmt man nun welches Event-Modell?
• Im Normallfall ist das externe Event-Modell vorzuziehen. Im Zusammenspiel mit anonymen
Listener-Klassen ist es einfach und unproblematisch zu verwenden.
• Bei der Entwicklung eigener bzw. spezialisierter GUI-Elemente kann es Sinn machen, sich in
die interne Event-Verarbeitung einzuklinken. Auf dieser Ebene hat man mehr viel Einfluss
und Möglichkeiten, der bei der Entwicklung eigener Elemente notwendig sein kann. Aber
man kann auch viel kaputt machen, da ein Eingriff in die interne Event-Verarbeitung eine
Operation am offenen Herzen des Elements ist. Man sollte daher wissen, was man macht
und was man will. Ansonsten sollte man besser die Finger davon lassen.
18.5 Scribble 4 mit Daten-Modell
Bleibt zum Schluß noch eine Sache zu tun: die versprochene Implementierung81 eines
Scribbles, das auch nach dem Neu-Zeichnen sein Bild darstellt – siehe Kapitel 17.1.
Im Prinzip ist das ganz einfach: wir müssen uns das gezeichnete Bild merken, und es auf Abruf
(d.h. in der Funktion „paint“ – siehe Kapitel 16.3) zeichnen. Dieses Problem zwingt uns dazu,
uns Gedanken zu machen, was denn unser Scribble-Bild eigentlich ist bzw. wie es aufgebaut
ist:
• Jede x/y-Koordinate ist ein Punkt.
• Mit der Maus zeichnet der Benutzer Linien-Züge, d.h. eine Aneinander-Reihung (oder
Verkettung) von Linien – sogenannte „Polygone“. Hierbei ist der Extrem-Fall zu beachten,
dass ein Polygon auch nur aus einem einzelnen Punkt bestehen kann. Ein Polygon ist also
eine Reihe von beliebig vielen, aber mindestens einem Punkt.
• Von diesen Polygonen kann das Scribble beliebig viele enthalten.
Aus dieser Problem-Analyse ergeben sich zwangsläufig folgende notwendige Klassen:
• Eine Klasse für Punkte, die x/y- Koordinaten aufnehmen kann. Hiermit sind wir schnell fertig,
da es im Package „java.awt“ eine einfache Klasse „Point“ für Punkte gibt.
• Eine Klasse „Polygon“ für Polygone, die beliebig viele Punkte aufnehmen kann. Um
mindestens einen Punkt zu garantieren, wird der erste Punkt direkt im Konstruktor
übergeben.
81
Siehe Ende Kapitel 18.2.4.
Seite 346 / 409
• Und eine Klasse „PaintModel“ für das gesamte Bild, die beliebig viele Polygone aufnehmen
kann. Die Klasse heißt „PaintModel“ und nicht „Picture“, da man in der SoftwareEntwicklung häufig von Modellen redet, wenn strukturierte Daten gemeint sind. Z.B. werden
wir bei Swing-Tabellen noch sogenannte „TableModel‘s“ kennen lernen – siehe Kapitel
todo.
Damit wäre Schritt 1 unserer Klassen-Entwicklungs-Überlegungen – siehe Kapitel 11.2 –
erledigt.
1. Überlegung - Art der Objekte
2. Überlegung - Schnittstelle
3. Überlegung - Vererbung
4. Überlegung - Implementierung
Weitere Überlegungen – todo...
import
import
import
import
java.awt.Graphics;
java.awt.Point;
java.util.Iterator;
public class Polygon {
private ArrayList points = new ArrayList();
// Ersten Punkt doppelt einfuegen, damit mindestens
// zwei Punkte da sind - siehe Funktion 'paint'.
public Polygon(Point p) {
points.add(p);
points.add(p);
}
public void addPoint(Point p) {
points.add(p);
}
// Diese Funktion setzt voraus, dass mindestens zwei Punkte
// vorhanden sind - der Konstruktor garantiert dies.
// - waere kein Punkt da
=> Exception in Zeile (*)
// - waere nur ein Punkt da => kein Zeichnen, da die Schleife
//
nie betreten wird.
Iterator it = points.iterator();
Point start = (Point) it.next();
// (*)
Point end = (Point) it.next();
g.drawLine(start.x, start.y, end.x, end.y);
start = end;
}
}
}
import
import
import
import
java.awt.Graphics;
java.awt.Point;
java.util.Iterator;
public class PaintModel {
private ArrayList polygons = new ArrayList();
private Polygon actuellPolygon;
Seite 347 / 409
public void addPolygon(Point p) {
actuellPolygon = new Polygon(p);
polygons.add(actuellPolygon);
}
public void addPoint(Point p) {
actuellPolygon.addPoint(p);
}
Iterator it = polygons.iterator();
Polygon poly = (Polygon) it.next();
poly.paint(g);
}
}
}
import java.awt.*;
private int lastX;
private int lastY;
private PaintModel model = new PaintModel();
super(title);
addMouseListener(new MouseAdapter() {
onMousePressed(e);
}
});
addMouseMotionListener(new MouseMotionAdapter() {
onMouseDragged(e);
}
});
}
lastX = e.getX();
lastY = e.getY();
model.addPolygon(new Point(lastX, lastY));
}
int x = e.getX();
int y = e.getY();
lastX = x;
lastY = y;
model.addPoint(new Point(x, y));
}
super.paint(g);
model.paint(g);
}
}
Seite 348 / 409
18.6 Aufgaben
18.6.1 Aufgabe „MainFrame“
Schreiben sie eine eigene Frame-Klasse „MainFrame“, die von „JFrame“ abgeleitet ist, aber
beim Schliessen des Fensters immer automatisch das Programm beendet.
• Welche Möglichkeiten haben sie diese Aufgabe zu lösen?
• Welche Vor- und Nachteile haben die einzelnen Lösungen?
• Welche würden sie bevorzugen?
18.6.2 Aufgabe „Scribble 5 zeichnet Rechtecke“
Implementieren sie mit dem externen Event-Modell ein Rechteck-Scribble, dass statt LinienZüge Rechtecke zeichnet.
• Entwickeln sie zuerst eine Version ohne Modell, und konzentrieren sie sich auf die EventBehandlung und die eigentliche Zeichen-Aufgabe.
• Danach entwickeln sie ein passendes Modell, und integrieren es in ihr Rechteck-Scribble.
19 Swing Layouts
Für viele GUI-Elemente gibt es in Swing natürlich fertige Klassen, z.B. für verschiedene Arten
von Buttons, für Labels, Eingabe-Felder, Listen, Tabellen, Bäume, uvm. Ein Teil dieser Klassen
besprechen wir in Kapitel 20. Bevor wir diese Elemente besprechen, sollten wir aber wissen,
wie man sie in ein Fenster einfügt und positioniert.
Das ganze hat was von der Henne/Ei-Problematik. Man kann keine Elemente in ein Fenster
einfügen, wenn man keine Layouts kennt. Aber wie soll man Layouts erklären, wenn man keine
Elemente zum Einfügen hat.
Wir lösen das ganz pragmatisch – in Kapitel 19.1 führen wir ein einfaches GUI-Element ein,
einen Button. Danach besprechen wir die Layouts, und nutzen erstmal für alle Beispiele nur
Buttons.
Aber warum gibt es überhaupt Layouts? Man könnte doch einfach die GUI Elemente
pixelgenau positionieren und fertig!? Dieses Vorgehen hat in der Praxis viele Probleme, da z.B.
Schriftgrößen sehr unterschiedlich sind, und damit eine pixelgenaue Postionierung nicht
sinnvoll ist. Außerdem können pixelgenaue Positionierungen z.B. sich nicht von alleine an
wechselnde Fenster-Größen anpassen. Darum gibt es in Swing Layouts, die die Ausrichtung,
Grösse und Position selbständig angleichen.
Seite 349 / 409
19.1 Swing Klasse „JButton“
Für einen normalen Button gibt es in Swing die Klasse „JButton“ im Package „javax.swing“. Um
einen Button mit Text auf der Schaltfäche zu erzeugten, muß der Konstruktor „JButton(String
text)“ benutzt werden. Weitere Informationen zur Klasse „JButton“ finden sie in Kapitel 20.3.
Ein GUI-Element wird in das Fenster mit „getContentPane().add“ eingefügt.
public MyFrame() {
super("Fenster mit Button");
getContentPane().add(new JButton("Hallo"));
}
}
Dieser Code erzeugt ein Fenster, dass komplett mit einem Button ausgefüllt ist. Und der Button
passt sich automatisch der Größe des Fensters an. Probieren sie es aus!
Abb. 19-1 : Ein Fenster mit einem Button
19.2 Grundlagen
Ein „JFrame“ Fenster unterteilt sich in den sogenannten Client-Bereich und den Rest. Der Rest
sind die Titelzeile, die Rahmen, möglicherweise Menü und Statusleiste, usw. Der innere
Bereich steht dem Programm zur Verfügung und nennt sich Client-Bereich.
Für die Verwaltung des Client-Bereichs enthält ein „JFrame“ Fenster ein sogenantes „ContentPane“ Objekt - vom Typ her ist es ein „java.awt.Container“.
• Zugreifen kann man auf die Content-Pane mit der Funktion „getContentPane()“.
• In diese Content-Pane können GUI-Elemente mit „add“ eingefügt werden.
• Ohne Layout verwaltet die Content-Pane nur das zuletzt eingefügte Element. Im folgenden
Programm z.B. enthält das Fenster nur den Button mit dem Text „3“.
Seite 350 / 409
Abb. 19-2 : Die Content-Pane enthält nur den letzten Button
public MyFrame() {
super("Nur der letzte Button \"3\" gewinnt");
getContentPane().add(new JButton("1"));
}
}
Hinweis – GUI-Elemente im Sinne von Swing sind alle Objekte, die von „java.awt.Component“
abgeleitet sind.
19.3 Layouts
Layouts sind Klassen, die mehrere GUI Elemente verwalten können, und diese aneinander
positionieren. Folgende Layouts sind u.a. Teil der Swing Bibliothek:
• Border-Layout
• Flow-Layout
• Grid-Layout
Swing enthält noch viel mehr Layout-Klassen, aber diese drei sind mit Abstand am einfachsten
zu benutzen und decken schon viele Anwendungs-Fälle ab. Aus Zeitmangel werden wir uns
daher auf diese drei beschränken.
19.3.1 Border-Layout
Das Border-Layout teilt sich in einen großen mittleren Bereich (CENTER) und vier SeitenBereiche (NORTH, SOUTH, WEST und EAST) auf. Beim Hinzufügen eines Elements muss der
Ziel-Bereich angegeben werden – dafür existieren entsprechende Konstanten in der Klasse
„BorderLayout“.
Seite 351 / 409
Abb. 19-3 : Fenster mit Border-Layout
import java.awt.*;
public MyFrame() {
super("Fenster mit BorderLayout");
setSize(300, 200);
c.add(new JButton("Center"), BorderLayout.CENTER);
}
}
Beim Border-Layout müssen nicht alle Bereiche gesetzt werden. Sind welche unbesetzt, dann
werden die anderen einfach vergrößert – bis der Client-Bereich abgedeckt ist.
19.3.2 Flow-Layout
Das Flow-Layout ordnet Komponenten zeilenweise von links nach rechts und von oben nach
unten an, wobei es preferredSize für jede Komponente verwendet. Es werden so viele
Komponenten wie möglich in eine Zeile gesetzt, bevor eine neue Zeile begonnen wird.
Abb. 19-4 : Fenster mit Flow-Layout
import java.awt.*;
Seite 352 / 409
public MyFrame() {
super("Fenster mit FlowLayout");
setSize(320, 170);
c.setLayout(new FlowLayout());
c.add(new JButton("Schalter 1"));
c.add(new JButton("S 5"));
c.add(new JButton("S 6"));
c.add(new JButton("Ein sehr sehr sehr langer Schalter 7"));
}
}
19.3.3 Grid-Layout
Das Grid-Layout fügt Komponenten in ein Gitter von Zellen, bestehend aus Zeilen und
Spalten, ein. Es vergrössert die Komponenten auf den in der Zelle verfügbaren Platz.
Jede Zelle hat dieselbe Grösse. Das Gitter ist einheitlich. Wenn Sie die Grösse eines
Grid-Layout-Containers verändern, vergrössert Grid-Layout die Zellen im Rahmen des
für den Container verfügbaren Platzes auf das grösstmögliche Mass.
Abb. 19-5 : Fenster mit Grid-Layout
import java.awt.*;
public MyFrame() {
super("Fenster mit GridLayout");
setSize(320, 170);
c.setLayout(new GridLayout(2, 3));
c.add(new JButton("1"));
}
}
Seite 353 / 409
19.4 Verschachtelte Layouts
Um Komponenten „tiefer zu layouten“, können Panels als Komponenten in ein Layout
eingeführt werden. Panels können ihrerseits wieder ein Layout haben und Komponenten
aufnehmen. Panels sind Objekte vom Typ „javax.swing.JPanel“ und auch ganz normale GUI
Elemente – siehe auch Kapitel 20.8.
Das folgende Beispiel zeigt ein Fenster mit Border-Layout, bei dem im Center-Bereich ein GridLayout integriert ist.
Abb. 19-6 : Fenster mit verschachtelten Layouts
import java.awt.*;
public MyFrame() {
super("Fenster mit verschachtelten Layouts");
setSize(400, 300);
JPanel panel = new JPanel(new GridLayout(3, 2));
c.add(panel, BorderLayout.CENTER);
Seite 354 / 409
}
}
Hinweis – in Kapitel 16.6 finden Sie dieses Programm auch mit Windows-Style.
19.5 Aufgaben
19.5.1 Aufgabe „Layouts 1“
Entwickeln sie ein Fenster, dass oben zwei Reihen mit je 6 Buttons enthält, und den Rest des
Bildschirms „frei“ läßt.
19.5.2 Aufgabe „Layouts 2“
Entwickeln sie ein Fenster, dass an den Seiten je 5 Buttons unter einander enthält, und im
restlichen Mittelbereich einen einzelnen Button.
19.6 Lsg. zu Aufgabe „Layouts 1“ – Kap. 19.5.1
todo...
19.7 Lsg. zu Aufgabe „Layouts 2“ – Kap. 19.5.2
todo...
20 Swing GUI-Elemente
In diesem Kapitel werden kurz einige Swing GUI-Elemente vorgestellt. In Swing gibt es
natürlich noch viel mehr fertige GUI-Elemente – hier können nur ein paar kleine wichtige GUIElemente vorgestellt werden. Und vor allem können all diese GUI-Elemente viel mehr, als hier
beschrieben wird. Die Kapitel stellen nur kurze Einführungen in die wichtigsten GrundFunktionalitäten der GUI-Elemente dar.
20.1 Labels
Die Klasse „javax.swing.JLabel“ ist eine Klasse für einfache Labels (Beschriftungen).
Wichtige Element-Funktionen:
Konstruktor JLabel ()
Konstruktor JLabel (String text)
void setText(String text)
String getText()
void setEnabled(boolean b)
Seite 355 / 409
Erzeugt ein einfaches Label.
Erzeugt ein Label mit Text.
Setzt den Text des Labels neu.
Gibt den Text des Labels zurück.
Aktiviert bzw. deaktiviert das Label.
Das Beispiel ist ein einfaches Fenster mit Label.
Abb. 20-1 : Fenster mit Label
public MyFrame() {
super("Fenster mit Label");
getContentPane().add(new JLabel("Ich bin ein Label"));
}
}
20.2 Text-Felder
Die Klasse „javax.swing.JTextField“ ist eine Klasse für Text-Eingabe-Felder – auch Edit-Felder
genannt.
Konstruktor JTextField()
Konstruktor JTextField (String text)
String getText()
Erzeugt ein leeres Text-Feld.
Erzeugt ein Text-Feld mit Text.
Setzt den Text neu.
Gibt den Text zurück.
Aktiviert bzw. deaktiviert das Text-Feld.
Wichtige Events:
• Caret
• Key
Name:
Beschreibung:
Listener-Interface:
Eine Funktion:
Adapter-Klasse:
Event-Klasse:
Caret
Wird aktiviert, wenn das Caret bewegt wird.
javax.swing.event.CaretListener
void caretUpdate(CaretEvent e)
--javax.swing.event.CaretEvent
Name:
Key
Beschreibung:
Listener-Interface:
Drei Funktionen:
Adapter-Klasse:
Event-Klasse:
Seite 356 / 409
Wird aktiviert, wenn die Tastatur benutzt wird.
java.awt.event.KeyListener
void keyPressed(KeyEvent e)
void keyReleased(KeyEvent e)
void keyTyped(KeyEvent e)
java.awt.event.KeyAdapter
java.awt.event.KeyEvent
Das Beispiel zeigt automatisch bei jeder Änderung des eingegebenen Textes im unteren Label
die Anzahl von Zeichen des Textes an.
Abb. 20-2 : Fenster mit Text-Feld und automatischer Längen-Angabe
import
import
import
import
java.awt.*;
java.awt.event.*;
javax.swing.*;
javax.swing.event.*;
private JTextField field = new JTextField();
private JLabel output = new JLabel();
public MyFrame() {
super("Fenster mit Text-Feld");
onTextChanged();
field.addCaretListener(new CaretListener() {
public void caretUpdate(CaretEvent e) {
onTextChanged();
}
});
field.addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
onTextChanged();
}
});
c.setLayout(new GridLayout(3, 1));
c.add(new JLabel("Bitte geben sie Text ein:"));
c.add(field);
c.add(output);
}
private void onTextChanged() {
String text = field.getText();
output.setText("Der Text ist " + text.length() + " Zeichen lang.");
}
}
Hinweis – es werden sowohl „Update-Caret“ als auch „Key-Typed“ Events überwacht, da je
Seite 357 / 409
nach Benutzung von „Entf“, „Backspace“, dem Clipboard, usw. unterschiedliche Events
getriggert werden, und daher die Überwachung eines Events nicht ausreicht.
20.3 Buttons
Die Klasse „javax.swing.JButton“ ist eine Klasse für normale Buttons, auch „Push-Buttons“
genannt.
Konstruktor JButton()
Konstruktor JButton(String text)
String getText()
Erzeugt einen einfachen Button mit leerer Schaltfläche.
Erzeugt einen Button mit Text auf der Schaltfläche.
Setzt den Text der Schaltfäche neu.
Gibt den Text der Schaltfäche zurück.
Aktiviert bzw. deaktiviert den Button.
Wichtige Events:
• Action
Name:
Beschreibung:
Listener-Interface:
Eine Funktion:
Adapter-Klasse:
Event-Klasse:
Action
Wird aktiviert, wenn der Button betätigt wird.
java.awt.ActionListener
void actionPerformed(ActionEvent e)
--java.awt.ActionEvent
Das Beispiel ist ein Fenster mit einem Button „Klick mich“. Wird der Button angeklickt, so
ändert sich der Text auf „Aua“, und bei jedem weiteren Klick wird ein weiteres „aua“
hinzugefügt.
Abb. 20-3 : Fenster mit Button im initialen Zustand und nach dreimaliger Betätigung
private JButton button;
public MyFrame() {
Seite 358 / 409
super("Fenster mit Button");
button = new JButton("Klick mich");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
onButtonClick();
}
});
getContentPane().add(button);
}
private void onButtonClick() {
if (button.getText().equals("Klick mich")) {
button.setText("Aua");
}
else {
button.setText(button.getText() + ", aua");
}
}
}
20.4 Radio-Buttons
Die Klasse „javax.swing.JRadioButton“ ist eine Klasse für Radio-Buttons, d.h. Buttons die
gruppiert auftreten, und von denen nur einer pro Gruppe selektiert sein kann.
Default-mässig ist erstmal jeder Radio-Button seine eigene Gruppe, d.h. alle Radio-Buttons
schalten unabhängig voneinander an und aus. Sollen mehrere Radio-Buttons einander
automatisch deselektieren, so müssen sie einer gemeinsamen Button-Gruppe zugeordnet
werden – hierfür gibt es in Swing die Klasse „javax.swing.ButtonGroup“. Mit „add“ können
Radio-Button einer Gruppe hinzugefügt werden.
Konstruktor JRadioButton()
Konstruktor JRadioButton(String text)
Ko. JRadioButton(String text, boolean b)
String getText()
void setSelected(boolean b)
boolean isSelected()
Erzeugt einen unselektierten Radio-Button ohne Text.
Erzeugt einen unselektierten Radio-Button mit Text.
Erzeugt einen Radio-Button mit Text und entsprechender
Selektion.
Setzt den Text neu.
Aktiviert bzw. deaktiviert den Radio-Button.
Selektiert bzw. deselektiert den Radio-Button.
Gibt zurück, ob der Radio-Button selektiert ist.
Wichtige Events:
• Action – siehe Kapitel 20.3
Das Beispiel zeigt ein Fenster mit vier Radio-Buttons, die einer Gruppe zugeordnet sind.
Ausserdem ist am unteren Rand ein Label vorhanden, das den jeweils selektieren Radio-Button
explizit angibt – hierfür ist im Beispiel für jeden Radio-Button ein „ActionListener“ gesetzt.
Seite 359 / 409
Abb. 20-4 : Fenster mit einer Gruppe von Radio-Buttons
import java.awt.*;
private JRadioButton[] buttons = new JRadioButton[] {
new JRadioButton("Eins", true),
new JRadioButton("Zwei"),
new JRadioButton("Drei"),
new JRadioButton("Vier"),
};
private ButtonGroup group = new ButtonGroup();
private JLabel output = new JLabel();
public MyFrame() {
super("Fenster mit Radio-Buttons");
onSelectionChanged(buttons[0]);
c.setLayout(new GridLayout(buttons.length+1, 1));
for (int i=0; i<buttons.length; i++) {
buttons[i].addActionListener(new ActionListener() {
onSelectionChanged((JRadioButton)e.getSource());
}
});
group.add(buttons[i]);
c.add(buttons[i]);
}
c.add(output);
}
private void onSelectionChanged(JRadioButton button) {
output.setText("Radio-But. \"" + button.getText() + "\" ist selektiert.");
}
}
Achtung – diese Gruppierung via „ButtonGroup“ ist eine rein logische Gruppierung, und hat
überhaupt nichts mit der Anordnung der Radio-Buttons im Fenster zu tun.
20.5 Check-Boxen
Check-Boxes sind spezielle Buttons, die meistens zwei Stati haben – diese werden im GUI
durch Boxen mit Check-Häkchen dargestellt. In Swing werden sie durch die Klasse
„javax.swing.JCheckBox“ repräsentiert.
Seite 360 / 409
Konstruktor JCheckBox()
Konstruktor JCheckBox (String text)
Kon. JCheckBox (String text, boolean b)
String getText()
void setSelected(boolean b)
boolean isSelected()
Erzeugt eine unselektierte Check-Box ohne Text.
Erzeugt eine unselektierte Check-Box mit Text.
Erzeugt eine Check-Box mit Text und entsprechender
Selektion.
Setzt den Text neu.
Aktiviert bzw. deaktiviert die Check-Box.
Selektiert bzw. deselektiert die Check-Box.
Gibt zurück, ob die Check-Box selektiert ist.
Wichtige Events:
Das Beispiel zeigt ein Fenster mit drei Check-Boxen. Werden sie selektiert bzw. deselektiert, so
wird automatisch ihre Vordergrund-Farbe auf „grün“ bzw. „rot“ gesetzt.
Abb. 20-5 : Fenster mit drei Check-Boxen
import java.awt.*;
private JCheckBox[] buttons = new JCheckBox[] {
new JCheckBox("Eins", true),
new JCheckBox("Zwei"),
new JCheckBox("Drei")
};
public MyFrame() {
super("Fenster mit Check-Boxen");
onSelectionChanged(buttons[0]);
c.setLayout(new GridLayout(buttons.length, 1));
for (int i=0; i<buttons.length; i++) {
buttons[i].addActionListener(new ActionListener() {
onSelectionChanged((JCheckBox)e.getSource());
}
});
onSelectionChanged(buttons[i]);
c.add(buttons[i]);
}
}
private void onSelectionChanged(JCheckBox button) {
button.setForeground(button.isSelected() ? Color.GREEN : Color.RED);
Seite 361 / 409
}
}
20.6 Scroll-Bars und Scroll-Panes
Möglicherweise ist dem ein oder anderen aufgefallen, dass unsere Fenster noch ein kleines
Problem haben – macht man sie zu klein, so verschwinden Elemente. Die Layouts haben
Grenzen, sobald ein Element so klein würde, dass es nicht mehr sinnvoll darstellbar wäre.
Möchte man in einem solchen Fall Scroll-Bars bekommen, so muss man sich nicht selber
darum kümmern, sondern muss eine sogenannte Scroll-Pane zwischen Container und den
enthaltenden Elementen legen. Im Extremfall ist dies sogar für ein einzelnes GUI-Element
nötig, z.B. Tabellen – siehe Kapitel 20.7.2.
Ein Scroll-Pane ist eine Fläche, die Scrollbars zur Verfügung stellt – in Swing dargestellt durch
die Klasse „javax.swing.JScrollPane“ – ein Beispiel findet sich in Kapitel 20.7.2. Sowohl für die
horizontale als auch für die vertikale Richtung können die Scrollbars auf verschiedene Arten
unabhängig voneinander immer, nie, automatisch auf- und ausgeblendet werden – siehe auch
das Interface „ScrollPaneConstants“.
Bemerkung – hier sieht man wieder eine ganz zentrale OO-Philosophie, die sich natürlich auch
in Swing wiederfindet: Baue keine „ich-kann-alles“ Klassen, sondern zerlege das Problem in
viele kleine Komponenten, die man überschreiben und/oder wiederverwenden kann.
20.7 Tabellen
Die Swing Tabellen-Klasse „javax.swing.JTable“ ist sehr leistungsfähig. Man kann quasi alles
beeinflussen – bis hin zum Erscheinungs-Bild und den Editier-Möglichkeiten einer einzelnen
Zelle. Für alle eigenständigen Aufgaben gibt es eigene Interfaces und Klassen, von denen man
sich ableiten kann, und damit die Default-Einstellungen überschreiben kann.
Leider sind die Tabellen dadurch nicht immer einfach in ihrer Programmierung – und ein
wirklich umfassender Einstieg wäre fast ein eigenes Buch. Von daher beschränkt sich dieses
Kapitel auf die wesentlichen Themen.
20.7.1 Eine einfache Tabelle
Um eine einfache Tabelle zu erstellen, braucht es nicht viel. Man erzeugt ein Objekt der Klasse
„javax.swing.JTable“ und übergibt dem Konstruktor die Anzahl an Zeilen und Spalten – im
Beispiel 4 Zeilen und 3 Spalten.
Seite 362 / 409
Abb. 20-6 : Fenster mit einfacher 4x3 Tabelle
public MyFrame() {
super("Fenster mit Tabelle 1");
JTable table = new JTable(4, 3);
setContentPane(table);
}
}
20.7.2 Tabellen mit Scrollbars
Leider hat eine solche Tabelle ein Problem, das man erst bei einer größeren Anzahl an Zeilen
bzw. Spalten sieht – darum hier eine Tabelle mit 40 Zeilen und 30 Spalten. Wie man sieht, hat
die Tabelle keine Scrollbars.
Abb. 20-7 : Fenster mit 40x30 Tabelle ohne Scrollbar
public MyFrame() {
setContentPane(table);
}
}
Seite 363 / 409
Wie wir in Kapitel 20.6 gelernt haben, müssen wir ein Scroll-Pane einsetzen. Wir machen dies
hier in einer ganz primitiven Variante, ohne die Scrollbars hier wirklich optimal zu unterstützen.
Abb. 20-8 : Fenster mit 40x30 Tabelle mit Scrollbar
public MyFrame() {
JScrollPane scrollPane = new JScrollPane(table);
setContentPane(scrollPane);
}
}
20.7.3 Tabellen-Inhalt aus Arrays
Als wichtigstes fehlt aber noch der Inhalt der Tabellen – bislang sind sie leer und damit nicht
besonders hilfreich.
Um Inhalte in eine Tabelle anzuzeigen, muss ein Tabellen-Modell erstellt werden – siehe
Kapitel 20.7.4. Da dies für einfache Tabellen-Anzeigen sehr aufwändig ist, gibt es zwei „Hilfs“
Konstruktoren in „JTable“, die Arrays bzw. den Java-Container „java.util.Vector“ erwarten. Im
Hintergrund baut das „JTable“ aus dem Array oder demContainer ein Default-Tabellen-Modell
auf – siehe „javax.swing.table.DefaultTableModel“.
Im Beispiel bekommt „JTable“ 2 Arrays übergeben:
• Parameter 1 ist ein zwei-dimensionales Array, das den Inhalt der Tabelle enthält – typisiert
ist er auf „Object[ ][ ]“. Da sich jedes Objekt immer in einen String wandeln läßt, kann dieses
Array immer angezeigt werden.
• Parameter 2 ist ein ein-dimensionales Array, das die Spalten-Überschriften enthält. Auch es
ist auf „Object[ ]“ typisiert.
Seite 364 / 409
Abb. 20-9 : Fenster mit Tabelle, dessen Inhalt aus einem Array stammt
public MyFrame() {
String[][] values = {{"1","2"}, {"3","4"}, {"5","6"}, {"7","8"}};
String[] titles = { "Col 1", "Col 2"};
JTable table = new JTable(values, titles);
setContentPane(new JScrollPane(table));
}
}
20.7.4 Tabelle mit Tabellen-Modell
Für komplexere Inhalte, Interaktion, und weitreichende Einflußmöglichkeiten muss der Tabelle
ein Tabellen-Modell mitgegeben werden – d.h. das Objekt muss das Interface
„javax.swing.table.TableModel“ implementieren. In diesem Interface ist die minimale
Schnittstelle zwischen Tabellen-Anzeige und Tabellen-Daten beschrieben, so z.B. Funktionen
für die Anzahl an Zeilen und Spalten, für die Inhalte, und einiges mehr.
In der Praxis werden nicht alle diese Beeinflussungs-Möglichkeiten benötigt – d.h. gibt es die
abstrakte Klasse „javax.swing.table.AbstractTableModel“, die für einige Funktionen DefaultImplementierungen anbietet. So müssen nur noch minimal drei Funktionen überschrieben
werden.
Das folgende Beispiel nutzt genau diese Klasse, leitet sich von „AbstractTableModel“ ab, und
überschreibt den minimalen Satz an notwendigen Funktionen.
Seite 365 / 409
Abb. 20-10 : Fenster mit Tabelle mit Tabellen-Modell
public MyFrame() {
JTable table = new JTable(new MyTableModel());
setContentPane(new JScrollPane(table));
}
}
import javax.swing.table.*;
class MyTableModel extends AbstractTableModel {
public int getRowCount() {
return 15;
}
public int getColumnCount() {
return 3;
}
public Object getValueAt(int arg0, int arg1) {
return "" + arg0 + " / " + arg1;
}
}
20.8 Panels
Auch die in Kapitel 19.4 vorgestellten Panels „javax.swing.JPanel“ sind ganz normale GuiElemente. Häufig werden sie einfach als eine Art GUI-Container in Verbindung mit Layouts
genutzt.
Aber sie können auch als einfache GUI-Elemente benutzt werden, die z.B. eigene Zeichnungen
enthalten – natürlich via Ableiten und Überschreiben der „paint“ Funktion.
20.9 Menüs
Um an ein „JFrame“ Fenster ein Menü anzuhängen, müssen drei Klassen benutzt werden:
• „javax.swing.JMenuBar“ repräsentiert das komplette Menü, d.h. die Menü-Zeile im Fenster.
• „javax.swing.JMenu“ repräsentiert einzelne Menüs, die Items, Seperatoren und Sub-Menüs
enthalten können. Sub-Menüs sind wiederrum nur ganz normale Menüs – sie lassen sich
halt verschachten.
• „javax.swing.JMenuItem“ sind einzelne Menü-Einträge, die vom Benutzer angewählt werden
können.
Wichtige Element-Funktionen von „JMenuBar“
Konstruktor JMenuBar()
void add(JMenu m)
Seite 366 / 409
Erzeugt eine leere Menü-Zeile.
Fügt das Menü ans Ende der Menü-Zeile an.
Wichtige Element-Funktionen von „JMenu“
Konstruktor JMenu(String text)
void add(JMenuItem item)
void add(String text)
void addSeparator()
String getText()
Erzeugt ein leeres Menü mit dem übergebenen Text.
Fügt den Menü-Eintrag ans Ende des Menüs an. Hier
dürfen auch „JMenu“ Objekte übergeben werden, da diese
von „JMenuItem“ abgeleitet sind.
Fügt einen Menü-Eintrag mit dem übergebenen Text ans
Ende des Menüs an.
Kurzform für „add(new MenuItem(text))“.
Fügt einen Separator ans Ende des Menüs an.
Setzt den Text des Menüs neu.
Gibt den Text des Menüs zurück.
Aktiviert bzw. deaktiviert das Menü.
Wichtige Element-Funktionen von „JMenuItem“
Konstruktor JMenuItem(String text)
Erzeugt einen Menü-Eintrag mit dem übergebenen Text.
Aktiviert bzw. deaktiviert den Menü-Eintrag
Wichtige Events von „JMenuItem:
Um ein Menü ohne spezielle Features zu erstellen, muß man also:
• eine Menü-Zeile erstellen,
• mindestens ein Menü an die Menü-Zeile anhängen,
• Menü-Einträge, Separatoren und Unter-Menüs an das Menü anhängen, und
• die Menü-Einträge mit Action-Listener versehen.
Hinweis – um Menü-Einträge selektiert, d.h. mit einem Häkchen versehen, darzustellen muss
statt eines „JMenuItem“ ein Objekt der abgeiteten Klasse „JCheckBoxMenuItem“ genommen
werden. Mit „void setSelected(boolean)“ kann die Selektion gesetzt, und mit „boolean
isSelected()“ abgefragt werden.
Das Beispiel ist ein „JFrame“ Fenster mit einer Menü-Zeile, die zwei Menüs enthält. Im Bild ist
das erste Menü zu sehen – es besteht aus zwei Einträgen, einem Separator und einem SubMenü. Das Sub-Menü enthält drei Einträge, wobei der erste deaktiviert und der dritte selektiert
ist. Das zweite Menü „Menü-2“ enthält nur einen Eintrag, an dem aber ein Action-Listener
hängt.
Seite 367 / 409
Abb. 20-11 : Fenster mit Menü
public MyFrame() {
super("Fenster mit Menü");
JMenuItem subItem1 = new JMenuItem("Sub-Item 1");
JMenuItem subItem2 = new JMenuItem("Sub-Item 2");
JMenuItem subItem3 = new JCheckBoxMenuItem("Sub-Item 3");
subItem1.setEnabled(false);
subItem3.setSelected(true);
JMenu submenu = new JMenu("Sub-Menü");
submenu.add(subItem1);
JMenu menu1 = new JMenu("Menü-1");
menu1.add("Item 1");
menu1.add("Item 2");
menu1.addSeparator();
menu1.add(submenu);
JMenu menu2 = new JMenu("Menü-2");
JMenuItem item3 = new JMenuItem("Item 3");
item3.addActionListener(new ActionListener() {
setTitle("Item 3 wurde betätigt");
}
});
menu2.add(item3);
JMenuBar menubar = new JMenuBar();
menubar.add(menu1);
menubar.add(menu2);
setJMenuBar(menubar);
}
}
20.10 Timer
Für periodisch wiederkehrende Aufgaben gibt es in Swing eine Timer-Klasse
„javax.swing.Timer“. Gestartet ruft sie in regelmäßigen Zeit-Intervallen – diese können in MilliSekunden definiert werden – die gesetzten Action-Listener auf.
Seite 368 / 409
Hinweis –bei positiven Intervall-Werten muss der Timer explizit gestartet werden – siehe
Tabelle und Beispiel.
Konstr. Timer(int delay, ActionListener l)
void start()
void stop()
Erzeugt einen Timer mit dem Zeit-Intervall „delay“ in MilliSekunden und dem übergebenen Action-Listener.
Startet den Timer.
Stoppt den Timer.
Wichtige Events:
Das Beispiel erzeugt ein Fenster, dass jede halbe Sekunde die Farbe von „grün“ nach „rot“ und
wieder zurück wechselt. Außerdem wird die aktuelle Farbe in der Titelzeile des Fensters
angezeigt.
Abb. 20-12 : Fenster in grün und in rot – gesteuert von einem Timer
import java.awt.Color;
public MyFrame() {
onTimer();
Timer timer = new Timer(500, new ActionListener() {
onTimer();
}
});
timer.start();
}
private void onTimer() {
if (getContentPane().getBackground() == Color.GREEN) {
getContentPane().setBackground(Color.RED);
setTitle("Fenster in \"rot\" mit Timer");
}
else {
getContentPane().setBackground(Color.GREEN);
setTitle("Fenster in \"grün\" mit Timer");
Seite 369 / 409
}
}
}
20.11 Aufgaben
20.11.1 Aufgabe „Liste“
Programmieren sie ein Fenster mit einer Liste – Swing Klasse „JList“ – mit Scrollbars und
Listen-Model. Die Benutzung der Listen-Klasse ist quasi analog zur Tabellen-Klasse, nur sind
Liste und Listen-Modell einfacher, da eine Liste nur eine Spalte hat.
20.11.2 Aufgabe „Scribble 6“
Implementieren sie zuerst ein Scribble, das sowohl Linienzüge als auch Rechtecke zeichnen
kann. Setzen sie für die Auswahl Buttons oder ein Menü ein. Implementieren sie das Scribble in
mehreren Schritten82:
• Erste Version ohne Modell, mit dem Haupt-Augenmerk auf die Auswahl und die Integration
von „Scribble 3“ – siehe Kapitel 18.3.5 – und „Scribble 5“ – siehe Kapitel 18.6.2.
• In der zweiten Version müssen sie ein Modell entwickeln, das sowohl Linien-Züge als auch
Rechtecke aufnehmen kann. Nehmen sie das Model vom „Sribble 4“ – siehe Kapitel 18.5 –
erweitern es um Rechtecke, und integrieren es. Denken sie schon nach vorne – auf Dauer
werden noch andere Grund-Elemente (Ellipsen, Texte,...) gezeichnet werden müssen. Am
besten entwickeln sie also ein Modell, das offen ist für neue Grund-Elemente und mit
verschiedenen Arten von Grund-Elementen umgehen kann.
• Wenn sie eine gute offene Lösung für das Modell gefunden haben, ist die Integration einer
weiteren Zeichen-Figur kein Problem. Also lassen sie ihr Scribble noch Ellipsen zeichnen
können – natürlich zusätzlich zu den Polygonen und Rechtecken, und natürlich auch mit
Model. An dem Aufwand, den sie treiben müssen, um Ellipsen zu integrieren können sie
erkennen, wie gut ihr Programm-Design ist.
20.11.3 Aufgabe „TextField“
Entwickeln sie ein eigenes Text-Feld Element, dass gegenüber dem Original-Element
Ein guter Entwickler zeichnet sich nicht dadurch aus, dass er direkt am Computer die größten
und tollsten Programme entwickelt, sondern dadurch, dass er gute Angewohnheiten hat, die ihn
gut machen. Dazu gehört eben auch ein Problem in mehrere Stufen zu zerlegen und diese
nach und nach abzuarbeiten. Aber auch so Dinge wie: Coding-Styles, Unit-Tests, Assertions,
Refactoring, Weiterbildung, Reflektion, und einiges mehr.
82
Seite 370 / 409
„JTextField“ noch zusätzlich ein externes Event für die Änderung des Inhalts hat, d.h. einen
Change-Listener.
Implementieren sie ein GUI für die „Kontaktdaten-Verwaltung 4“ aus Kapitel todo bzw. Kapitel.
20.12 Lsg. zu Aufgabe „Liste“ – Kap. 20.11.1
todo...
20.13 Lsg. zu Aufgabe „Scribble 6“ – Kap. 20.11.2
todo...
20.14 Lsg. zu Aufgabe „TextField“ – Kap. 20.11.3
todo...
todo...
21 Applets
Applets sind kleine Programme, die in eine HTML Seite eingebettet sind und von einem
Browser ausgeführt werden.
Achtung – gleich vorweg ein paar Hinweise zur praktischen Seite der Entwicklung von Applets:
• Der verwendete Browser muss natürlich java-fähig sein.
• Es muss ein entsprechendes Java-Plugin (passendes JDK) für den Browser installiert sein.
• Es gibt immer wieder Ärger mit den Browser-Caches. D.h. die Browser merken nicht dass
sie eine neue Class-Datei erzeugt haben, und benutzen die aus dem Cache.
21.1 Beispiel
Sie benötigen die einbettende HTML Seite und die „class“ Datei des Applets im gleichen
Seite 371 / 409
Verzeichnis (wenn die Applet Klasse nicht in einem Package liegt).
<html>
<head>
<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<title>
Mein erstes Applet
</title>
</head>
<body>
<applet
codebase = "."
code = "MyApplet.class"
weidth = 400
hight = 300
>
</applet>
</body>
</html>
import java.awt.*;
public class MyApplet extends JApplet {
public MyApplet() {
final JButton button = new JButton("Klick mich bitte vorsichtig an");
button.addActionListener(new ActionListener() {
button.setText("Aua, das tat weh...");
}
});
setContentPane(button);
}
}
21.2 Applet HTML-Seite
Ein Applet kann nie für sich alleine funktionieren, sondern braucht immer eine HTML Seite, in
die es eingebettet ist. Dies soll und kann kein HTML Lehrgang sein, darum wird eine kleine
Beispiel Seite kurz besprochen - für mehr Details lesen sie bitte ein entsprechendes HTML
Buch.
<html>
<head>
<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<title>
HTML-Testseite
</title>
</head>
<body>
Mein tolles Applet erscheint in einem Java-fähigen Browser.<BR>
<applet
CODEBASE = "."
CODE
= "packageName.MeineAppletKlasse.class"
NAME
= "TestApplet"
WIDTH
= 400
HEIGHT
= 300
HSPACE
= 0
VSPACE
= 0
ALIGN
= middle
>
Seite 372 / 409
Text für den Fall, dass der Browser keine Applets anzeigen kannn
</applet>
</body>
</html>
Hinweis – aufgrund der Plattform-unabhängigkeit von HTML sollten alle „nicht-normalen“
Zeichen codiert sein, d.h. das „ä“ statt des einfachen „ä“. Auch diese Dinge sollten sie
genauer in einem HTML Buch nachlesen.
Für Java Applets wurde in HTML das Tag „applet“ aufgenommen, das mit <applet> begonnen
und mit </applet> beendet wird. Der zwischen den Tags stehende Text wird vom Browser
ausgegeben, wenn er nicht Applet-fähig ist.
Zum Applet-Start-Tag gehören Parameter, die das Applet näher spezifizieren:
Parameter
optional
Bedeutung
CODE
Gibt den Namen des Applets an:
• Gross-/Kleinschreibung muss beachtet werden.
• die Extension .class sollte angegeben werden.
• die Klassendatei muss im aktuellen Verzeichnis liegen
WIDTH
Die für das Applet zur Verfügung stehende Breite
HEIGHT
Die für das Applet zur Verfügung stehende Höhe
CODEBASE
x
Alternative Verzeichnisse (durch Kommata getrennt) für die
Klassendateien
ARCHIVE
x
Angabe eines jar-Archivs für die Klassendateien und die
Ressourcen
OBJECT
x
Datei mit dem serialisierten Inhalt des Applets
ALT
x
Alternativer Text für nicht Appletfähige Browser
NAME
x
Eindeutiger Name für das Applet. Wichtig bei der Verwendung
mehrerer miteinander kommunizierender Applets auf einer Seite
ALIGN
x
Vertikale Anordnung des Applets - einer der folgenden Werte
(left, right, top, texttop, middle, absmiddle, baseline, bottom,
absbottom)
VSPACE
x
Rand über und unter dem Applet
HSPACE
x
Rand rechts und links vom Applet
Seite 373 / 409
21.3 Grundlagen
21.3.1 Klassen-Hierarchie „Applet“ bzw. „JApplet“
Ein Applet muss zwingend von „java.applet.Applet“ abgeleitet sein. Wird Swing benutzt
Ableitungs-Hierarchie:
Object - Component - Container - Panel - Applet - JApplet
21.3.2 Default-Konstruktor
Ein Browser erzeugt ein Applet immer mit dem Default-Konstruktor. In diesem sollten sie bei
Applets aber ausnahmsweise keine Initialisierung vornehmen. Für die Initialisierung steht in
Applets die Funktion „init“ zur Verfügung – siehe Kapitel 21.3.3.1.
21.3.3 Wichtige Applet-Funktionen
Es gibt verschiedene Applet-Funktionen, die der Kommunikation zwischen Browser und Applet
dienen und in einer eigenen Applet-Klasse überschrieben werden können.
21.3.3.1 Funktion „public void init()“
Nach der Erstellung des Applets wird für das Applet die Funktion „init“ vom Browser aufgerufen,
in der Sie das Applet initailisieren sollten. Die Funktion wird genau einmal für das Applet nach
der Erzeugung aufgerufen.
21.3.3.2 Funktion „public void start()“
Um die Ausführung des Applets zu starten ruft der Browser die Funktion „start“ auf.
Achtung - diese Funktion kann mehrfach aufgerufen werden. Z. B. bei einem Seitenwechsel
muss der Browser das Applet nicht zerstören, sondern kann es cachen. Wird die Seite wieder
aufgerufen, muss der Browser das Applet daher nicht neu erzeugen und ruft dann natürlich
auch nicht mehr die Funktion „init“ auf, sondern direkt wieder „start“.
21.3.3.3 Funktion „public void stop()“
Die Funktion „stop“ ruft der Browser auf, wenn das Applet gestoppt werden soll.
Achtung - wie schon start, so kann auch stop mehrfach aufgerufen werden, da der Browser
nur die Ausführung des Applets unterbricht, aber das Applet nicht zerstört, z. B. beim Verlassen
der HTML Seite mit cachen des Applets. Geben sie also niemals Ressourcen, die beim Starten
wieder benötigt werden, in dieser Funktion frei.
Seite 374 / 409
21.3.3.4 funktion „public void destroy()“
Erst die Funktion „destroy“ zeigt an, dass das Applet zerstört wird. Auch diese Funktion wird nur
einmal (wie init) am Ende der Lebensdauer des Applets vom Browser aufgerufen.
Achtung - für die Freigabe von Ressourcen benutzen sie immer destroy und nicht den
Destruktor finalize, da dieser nicht zwingend aufgerufen wird.
21.3.3.5 Funktion „public void showStatus(String msg)“
Mit der funktion „showStatus“ können sie Ausgaben in der Statuszeile des Browsers
vornehmen.
showStatus("Hallo Welt in der Statuszeile");
21.3.3.6 Funktion „public String getAppletInfo()“
Mit dieser funktion können sie Informationen über Ihr Applet zur Verfügung stellen, die der
Browser abrufen und anzeigen kann.
public String getAppletInfo() {
return "Mein Super-Applet Version 0.001";
}
21.4 Applet-Parameter
Neben den Parametern für das Applet-Tag selber können dem Applet auch noch Appletspezifische Parameter übergeben werden. Diese werden mit dem optionalen HTML-Tag
PARAM im Applet-Bereich angegeben - PARAM wiederum hat die Parameter name und value.
<APPLET
CODEBASE
CODE
NAME
WIDTH
HEIGHT
HSPACE
VSPACE
ALIGN
>
<PARAM
<PARAM
</APPLET>
=
=
=
=
=
=
=
=
"."
"packageName.meineAppletKlasse.class"
"TestApplet"
400
300
0
0
middle
NAME = "speed" VALUE = "10">
NAME = "rate" VALUE = "2">
Damit das Applet die Parameter aus der HTML Seite erfragen kann, gibt es die Funktion public
String getParameter(String name), die den Namen des Parameters enthält und den Wert des
Parameters als String zurückgibt.
Für nähere Informationen über die Parameter kann das Applet die Funktion public String[ ][ ]
getParameterInfo() überschreiben, die ein zweidimensionales String-Array zurückgibt - eine
Zeile pro Parameter, den das Applet erwartet. Eine Zeile besteht aus drei Einträgen, die den
Namen des Parameters, den Typ und eine Beschreibung enthalten. Die Einträge sollten für
Menschen lesbar und verständlich sein, da der Browser diese Informationen nicht interpretiert,
Seite 375 / 409
sondern sie nur dem Benutzer zugänglich macht.
public String[][] getParameterInfo() {
String pinfo[][] =
{
{"speed", "int", "Schnelligkeit"},
{"rate", "int", "Rate"},
};
}
21.5 Applets & Applikationen
Von einer „stand-alone“ Applikation unterscheidet sich ein Applet durch mehrere Dinge:
Applet
„stand-alone“ Applikation
Es muss eine spezielle Applet-Klasse geben, Es wird keine spezielle Applikations-Klasse
die direkt oder indirekt83 von der Klasse
zwingend vorausgesetzt. Ein „main“ kann in
„java.applet.Applet“ abgeleitet sein muss.
jeder Klasse stehen. Wenn eine spezielle
Applikations-Klasse vorhanden ist, so kann
sie von einer beliebigen Klasse abgeleitet
sein.
Start, indem der Browser die Haupt-Klasse
Start in der eindeutigen static Funktion main.
des Applets instanziiert (Default-Konstruktor)
und die Funktion init und start aufruft.
Darf nicht auf Dateien auf dem lokalen
Rechner zugreifen und darf keine Prozesse
auf diesem starten84.
Keine Sicherheitsbeschränkungen bzgl. des
lokalen Systems
Arbeitet immer grafik- und
ereignissorientiert85.
Kann auch Texteingabe und -ausgabe auf
der Kommandozeile vornehmen.
Hinweis – es ist relativ leicht Java-Sourcen zu schreiben, die sowohl als Applet als auch als
„stand-alone“ Anwendung laufen.
83
Wenn Sie ein Applet basierend auf den Swing Klassen erstellen, so benutzen Sie als
Basisklasse „javax.swing.JApplet“, die wiederum von „java.applet.Applet“ abgeleitet ist.
84 Genau genommen gibt es ein sehr detailiertes Sicherheits-Konzept, über das der Benutzer
einem Applet beliebige Rechte geben kann. Defaultmäßig hat ein Applet aber keine Rechte auf
dem Rechner des Benutzers.
85
In der Entwicklungsumgebung kann die Kommandozeile problemlos zum Debuggen benutzt
werden. Aber in manchen Browsern existiert keine Kommandozeile, so dass Textein- und ausgabe keinen Sinn machen - viele Browser stellen ein Ausgabefenster für Textausgaben zur
Verfügung, dass der Benutzer aber extra öffnen muss.
Seite 376 / 409
21.6 Aufgaben
21.6.1 Aufgabe „Statuszeilen-Applet“
Implementieren sie ein Applet, bestehend aus einem Text-Eingabe-Feld und einem Button. Bei
Betätigung des Buttons soll der Inhalt des Text-Feldes in der Statuszeile des Browsers
ausgegeben werden.
Modifizieren sie das „Scribble 6“ – siehe Kapitel 20.11.2 – so, dass es auch als Applet läuft.
21.7 Lsg. zu Aufgabe „Statuszeilen-Applet“ – Kap. 21.6.1
todo...
21.8 Lsg. zu Aufgabe „Scribble 7“ – Kap. 21.6.2
todo...
22 Exceptions
Exceptions sind ein Sprachkonzept zur Behandlung von unnormalen Programm-Status, z.B.
von Fehlern.
22.1 Motivation
Die beiden grössten Probleme der konventionellen Fehlerbehandlung (Rückgabe von ErrorCode’s, Fehlerparameter, globale Variablen, Fehlerfunktionen,...) sind, dass sich im Code
normaler Code und Fehlerbehandlungscode logisch vermischen, und die Abfrage auf Fehler
von der Sorgfalt des Programmierers abhängig ist.
Das Ergebnis sind Quelltexte folgender Art – Achtung, Pseudocode:
back = fkt1();
if (back==ERROR) {
// behandle Fehler
}
back = fkt2();
if (back==ERROR) {
// behandle Fehler
}
fkt3();
int i = fkt4();
if (i<0) {
back = fkt5().fkt6();
if (back==ERROR) {
// behandle Fehler
}
else {
back = fkt7();
if (back==ERROR) {
// behandle Fehler
}
}
}
Seite 377 / 409
// Fehlerbehandlung vergessen
// Behandlung vergessen oder keine Fehler moeglich?
// Behandlung vergessen oder keine Fehler moeglich?
Schöner wäre aber:
// Normaler Code
fkt1();
fkt2();
fkt3();
int i = fkt4();
if (i<0) {
fkt5().fkt6();
}
else {
fkt7();
}
// Fehlerbehandlung
if (ERROR) {
// behandle Fehler
}
Aus diesen Gründen heraus entstand das Konzept der Exceptions.
22.2 Realisation
Tritt ein Fehler auf, so wird ein Exception-Objekt geworfen – dies darf nur „logisch innerhalb86“
eines try-Blocks passieren. Wird ein Exception-Objekt geworfen, wird instantan in die
entsprechende Fehler-Behandlung verzweigt.
for (int i=0; i<2; i++) {
try {
System.out.println("try-Block Anfang mit i=" + i);
if (i==1) {
throw new RuntimeException();
}
System.out.println("try-Block Ende");
}
catch (RuntimeException x) {
System.out.println("Fehler-Objekt wurde gefangen");
}
}
}
(*)
(**)
Ausgabe
try-Block Anfang mit i=0
86
„logisch innerhalb“ meint hier aus Sicht des Programm-Verlaufs – siehe auch Kapitel 22.3.
Seite 378 / 409
try-Block Ende
Fehler-Objekt wurde gefangen
An der Ausgabe sieht man sehr schön, dass bei „i==0“ die Schleife normal durchlaufen un der
catch-Block ignoriert wird. Bei „i==1“ dagegen wird direkt nach dem „throw“ die Abarbeitung des
try-Blocks unterbrochen und in den catch-Block verzweigt.
Man kann also sagen:
• Der try-Block ist der Bereich, der den normalen Code ohne Fehlerbehandlung enthält.
• Tritt im normalen Programm-Verlauf ein Fehler auf, so meldet die entsprechende Stelle
diesen indem sie mit „throw“ ein Fehler-Objekt wirft – im Beispiel vom Typ
„RuntimeException“ in Zeile (*).
• Im Falle eines Fehlers, d.h. eines „throw’s“, wird der normale Programm-Verlauf automatisch
unterbrochen und sofort zur entsprechenden Fehler-Behandlung verzweigt – im Beispiel der
catch-Block (**).
• Ein catch-Block stellt den Fehler-Behandlungs-Code zur Verfügung.
• Nach Verlassen des catch-Blocks gilt der Fehler als behandelt.
Die Idee hierbei ist, dass es nach Auftreten eines Fehler einfach keinen Sinn mehr macht den
normalen Programm-Verlauf zu verfolgen. Würde der Fehler ignoriert und der normale
Programm-Fluß weiter abgearbeitet werden, so kann dies nicht gut sein sondern statt dessen
gefährliche Folgen haben. Denken sie z.B. ganz extrem, dass die Kühlung eines Kraftwerks
nicht aktiviert werden konnte. Wenn dieser Fehler ignoriert werden würde, und die Generatoren
danach einfach weiter hoch gefahren werden würde, so wäre das sicher nicht das Beste.
Hinweis – zu einem try-Block gehört immer mindestens ein catch-Block oder ein ein finallyBlock – siehe auch Kapitel 22.4.
Hinweis – in der Praxis arbeitet man eher selten mit der Klasse „RuntimeException“ als
Exception-Klasse – siehe Zeile (*) und (**). Im Hinblick auf die nächsten Grundlagen ist die
Klasse „RuntimeException“ aber erstmal einfacher, da sie uns Exception-Spezifikationen (siehe
Kapitel todo) erspart. Welche Klassen für das Exception-Handling zur Verfügung stehen, und
welche man wann benutzt, wird in Kapitel todo erklärt.
22.3 Fehler über mehrere Funktions-Ebenen
Das Exception-Handling ist nicht auf eine Funktion festgelegt, sondern kann über eine beliebige
Menge von Funktions-Aufrufen hinweg erfolgen.
Das folgende Beispiel ist im Prinzip das Gleiche wie das Vorherige. Nur steht das „if“ mit dem
„throw“ nicht direkt im try-Block, sondern wird über 2 Funktions-Aufrufe („f1“ und „f“)
angeprochen. Die Funktionen enthalten zusätzlich noch Ausgaben, um den Programm-Verlauf
gut verfolgen zu können.
Seite 379 / 409
private static void f2(int i) {
-> f2");
if (i==1) {
}
<- f2");
}
-> f1");
f2(i);
<- f1");
}
for (int i=0; i<2; i++) {
try {
f1(i);
}
}
}
}
Ausgabe
-> f1
-> f2
<- f2
<- f1
try-Block Ende
-> f1
-> f2
Wie man an den Ausgaben deutlich sieht, arbeitet das Exception-Handling auch über mehrere
Funktions-Ebenen hinweg.
• Das throw steht weiterhin logisch in einem try-Block. Innerhalb der Funktion „f2“ ist zwar kein
try-Block vorhanden, aber im logischen Sinne steht „f2“ in „f1“ und „f1“ im try-Block von
„main“.
• Nach werfen des Exception-Objekts wird auch hier automatisch und sofort in den FehlerBehandlungs Block verzweigt. Man sagt, dass eine Exception automatisch den FunktionsStack abbaut. Es wird kein Code mehr im normalen Programm-Verlauf ausgeführt – auf
keiner Ebene der Funktionen, bis der Fehler als bearbeitet gilt.
22.4 Aufräumarbeiten und „finally“
Müssen nach einem Code-Abschnitt auf jeden Fall irgendwelche Aufräumarbeiten ausgeführt
werden – z.B. das Schließen von Dateien oder Netzwerkverbindungen – so gibt es dafür einen
finally-Block.
Ein finally-Block gehört immer zu einem try-Block. Egal wie der try-Block verlassen wird
(normaler Programmfluß, return im try-Block, Exception), der Code im finally Block wird immer
ausgeführt.
Seite 380 / 409
Das folgende Beispiel ist bis auf zwei Änderungen das Gleiche wie das Vorherige:
• In der Funktion „f1“ ist der Aufruf von „f2“ in einen try-Block gelegt, und der zugehörige
finally-Block enthält die Ausgabe zum Verlassen der Funktion.
• Der try-Block in „main“ hat einen finally-Block mit einer zusätzlichen Ausgabe bekommen.
-> f2");
if (i==1) {
}
<- f2");
}
-> f1");
try {
f2(i);
}
finally {
<- f1");
}
}
for (int i=0; i<2; i++) {
try {
f1(i);
}
}
finally {
System.out.println("finally-Block in main");
}
}
}
Ausgabe
-> f1
-> f2
<- f2
<- f1
try-Block Ende
finally-Block in main
-> f1
-> f2
<- f1
finally-Block in main
An den Ausgaben kann man gut verfolgen, dass der finally-Block immer ausgeführt wird, wenn
der zugehörige try-Block verlassen wird.
Hinweise zu Syntax:
• Zu einem try-Block gehört mindestens ein catch-Block oder ein finally-Block.
• D.h. ist auch ein try-Block nur mit finally-Block erlaubt – siehe z.B. Funktion „f1“ im Beispiel.
• Gehören zu einem try-Block catch-Blöcke und ein finally-Block, so folgt der finally-Block dem
Seite 381 / 409
letzten catch-Block, d.h. er steht am Ende des kompletten try-catch-finally-Konstrukts.
Siehe auch „main“ im Beispiel.
• Es darf nur einen finally-Block pro try-Block geben.
22.5 Exception-Objekte und Exception-Hierarchie
22.5.1 Exception-Objekte
Es können nur Objekte der Klasse „java.lang.Throwable„ oder einer von ihr abgeleiteten
Klasse Exception-Objekte sein, d.h. in einer throw-Anweisung geworfen werden.
throw new String("Error");
throw new Exception();
// Fehler, String ist kein Throwable
// Okay, Exception ist ein Throwable
Der Sinn einer konkreten Exception Klasse ist, dass sie einen ganz fest umrissenden Fehler
spezifiziert. So gibt es z.B. in Java die „java.lang.NullPointerException“, die geworfen wird,
wenn auf eine Null-Referenz zugegriffen wird. Oder z.B. beim Zugriff auf nicht existente ArrayElemente wird eine „java.lang.ArrayIndexOutOfBoundsException“ geworfen.
String s = null;
s.toString();
// erzeugt eine NullPointerException
int[] a = { 0, 1, 2 };
a[5] = 5;
// erzeugt eine ArrayIndexOutOfBoundsException
22.5.2 Exception-Hierarchie
In der Klassen-Bibliothek von Java existieren viele Exception-Klassen, d.h. Klassen die direkt
oder indirekt von „Throwable“ abgeleitet sind. Von besonderer Bedeutung sind dabei die
folgenden:
java.lang.Throwable
java.lang.Error
java.lang.Exception
java.lang.
RuntimeException
Abb. 22-1 : Ein kleiner aber wichtiger Teil der Exception-Hierarchie in Java
Die Klasse „java.lang.Error“ und ihre Unterklassen sind für interne Probleme der virtuellen
Maschine (z. B. beim Linken, Speicherüberlauf,...) reserviert. Sie müssen diese Exceptions
nicht behandeln und sollten es auch nicht, da sie im Normalfall für den Programmierer nicht
behandelbar sind. Sie sollten auch keine Unterklassen von „java.lang.Error“ bilden, da dies im
Normallfall keinen Sinn macht.
Seite 382 / 409
Die Klasse „java.lang.Exception“ ist die direkte oder indirekte Baisklasse für die normalen
Exceptions. Auch sie sollten diese Klasse im Normallfall als direkte oder indirekte Baisklasse
für ihre eigenen Exception-Klassen nutzen.
Die Klasse „java.lang.RuntimeException“ ist besonders, da sie und ihre abgeleiteten Klassen
ungeprüfte Exceptions ermöglichen – siehe Kapitel 22.9.
22.6 Fangen von Basis-Exception-Klassen
Nicht immer will man aber ganz genau wissen, was für ein Fehler aufgetreten ist. Dann ist es
möglich ganze Gruppen von Exceptions über ihre gemeinsame Basis-Klasse abzuhandeln.
Eine Exception-Basis-Klasse faßt daher eine Menge von thematisch ähnlichen oder zusammen
gehörigen Fehlern zusammen.
Bei einer Datei-Schittstelle könnte es z.B. Exceptions der folgenden Art geben:
• FileDoesNotExistException
• FileNotReadableException
• FileNotWritableException
• ...
Hier würde es sich anbieten, die Exception-Klassen von einer gemeinsamen Basis-Klasse
„FileException“ abzuleiten.
Abb. 22-2 : Klassen-Hierarchie für unsere Beispiel File-Exceptions
Will man nun gar nicht genau wissen, welche File-Exception geworfen wurde, sondern nur dass
überhaupt ein Datei-Fehler aufgetreten ist, so kann man im catch-Block einfach die BasisKlasse abfangen.
public class FileException extends RuntimeException {
}
public class FileDoesNotExistException extends FileException {
}
public class FileNotReadableException extends FileException {
}
public class FileNotWritableException extends FileException {
}
for (int i=0; i<4; i++) {
try {
System.out.println("try-Block mit i=" + i);
if (i==0) {
throw new FileDoesNotExistException();
}
else if (i==1) {
throw new FileNotReadableException();
}
Seite 383 / 409
else if (i==2) {
throw new FileNotWritableException();
}
}
catch (FileException x) {
System.out.println("FileException wurde gefangen");
}
}
}
Ausgabe
try-Block mit i=0
FileException wurde gefangen
try-Block mit i=1
try-Block mit i=2
try-Block mit i=3
try-Block Ende
Wie man sieht, wird in bei allen geworfenen Exception-Objekten der catch-Block der BasisKlasse zur Fehler-Behandlung genutzt.
22.7 Mehrere catch-Blöcke
Was ist aber nun, wenn ich ein paar konkrete Fehler abfangen und bearbeiten will, andere aber
ganz allgemein behandeln möchte?
In den vorherigen Kapiteln wurde schon zwischen den Zeilen erwähnt, dass es mehrere catchBlöcke pro try-Block geben kann.
• Jeder catch-Block ist für eine Exception-Klasse zuständig.
• Wird ein Exception-Objekt geworfen, so werden die catch-Blöcke von oben nach unten
abgesucht, ob das Exception-Objekt zu dem Typ des catch-Parameters paßt. Wenn ja, so
wird in den catch-Block verzweigt.
• Daher darf auch kein allgemeiner catch-Block vor einem spezielleren stehen. Wäre z.B. der
catch-Block für „FileException“ der erste, und erst danach würde der für
„FileDoesNotExistException“ folgen, so würde der zweite catch-Block nie zum Zuge
kommen. Denn jede „FileDoesNotExistException“ würde schon vom „FileException“ catchBlock abgefangen werden.
• Nach normaler Abarbeitung eines catch-Blocks gilt der Fehler als behandelt, und es wird –
möglicherweise nach Bearbeitung des optionalen try-Blocks – nach dem letzten catch-Block
fortgefahren.
for (int i=0; i<4; i++) {
try {
System.out.println("try-Block mit i=" + i);
if (i==0) {
throw new FileDoesNotExistException();
}
else if (i==1) {
throw new FileNotReadableException();
}
else if (i==2) {
Seite 384 / 409
throw new FileNotWritableException();
}
}
catch (FileDoesNotExistException x) {
System.out.println("FileDoesNotExistException wurde gefangen");
}
catch (FileNotReadableException x) {
System.out.println("FileNotReadableException wurde gefangen");
}
catch (FileException x) {
System.out.println("FileException wurde gefangen");
}
}
}
Ausgabe
try-Block mit i=0
FileDoesNotExistException wurde gefangen
try-Block mit i=1
FileNotReadableException wurde gefangen
try-Block mit i=2
try-Block mit i=3
try-Block Ende
22.8 Unbehandelte Exceptions
Wird ein Exception-Objekt geworfen, für das kein passender catch-Block, so wird der
Funktions-Stack Funktion für Funktion abgebaut (siehe Kapitel 22.3) bis zur „main“ Funktion. Ist
auch hier kein passender catch-Block vorhanden, so wird das Programm automatisch beendet.
private static void f2() {
System.out.println(" - f2");
=> throw ohne catch");
}
System.out.println("- f1");
f2();
}
System.out.println("main");
f1();
}
mögliche Ausgabe
main
- f1
- f2
=> throw ohne catch
java.lang.RuntimeException
at Appl.f2(Appl.java:6)
at Appl.main(Appl.java:16)
Exception in thread "main"
Durch dieses Vorgehen wird verhindert, dass ein Fehler-Zustand unbehandelt bleibt, aber das
Programm weiter läuft – siehe auch Kapitel todo.
Seite 385 / 409
22.9 Geprüfte und ungeprüfte Exceptions
In Java wird zwischen geprüften und ungeprüften Exceptions unterschieden – sie heißen auch
checked bzw. unchecked exceptions.
Für geprüfte Exceptions kann der Compiler zur Compile-Zeit feststellen, ob sie vollständig
behandelt werden, d.h. es immer einen passenden catch-Block im Quelltext gibt. Für
ungeprüfte Exceptions gilt dies nicht.
• Ungeprüfte Exceptions sind Exceptions, bei denen Objekte geworfen werden, die direkt oder
indirekt von „java.lang.Error“ bzw. „java.lang.RuntimeException“ abgeleitet sind.
• Alle anderen Exception-Objekte sind geprüfte Exceptions.
Welche Konsequenzen hat aber nun die Verwendung von geprüften Exceptions? Der Code ist
nur dann korrekt, d.h. wird vom Compiler compiliert, wenn das Werfen einer geprüften
Exception in der Funktions selber abgefangen wird, oder mit einer Exception-Spezifikation nach
außen gemeldet wird.
public void f() {
}
// Compiler-Fehler, unbehandelte Exception
Lösung 1 – Abfangen der Exception in der Funktion selber
public void f() {
try {
}
}
}
// Exception wird abgefangen
Lösung 2 – Funktion mit Exception-Spezifikation
public void f() throws Exception {
// Exception wird nach aussen gemeldet
}
Ein Exception-Spezifikation wird hinter die Paramter-Liste der Funktion geschrieben, und
besteht aus dem Schlüsselwort „throws“ und einer Auflistung der möglichen Exceptions. Wird in
der Exception-Spezifikation eine Klasse angegeben, so werden damit alle Objekte vom Typ der
Basis-Klasse bzw. einer von ihr abgeleiteten Klassen als mögliche Exception-Objekte erlaubt.
Ist keine Exception-Spezifikation vorhanden, so darf keine geprüfte Exception geworfen
werden.
Beispiele:
- void f() throws Exception
- void g() throws FileDoesNotExistException, FileNotReadableException
- void h()
• void f() throws Exception
Diese Funktion darf alle Exceptions werfen, deren Typ „java.lang.Exception“ ist bzw. deren
Typen direkt oder indirekt von „java.lang.Exception“ abgeleitet sind. Und natürlich
ungeprüfte Exceptions.
Seite 386 / 409
• void g() throws FileDoesNotExistException, FileNotReadableException
Diese Funktion darf alle Exceptions werfen, deren Typ „FileDoesNotExistException“ oder
„FileNotReadableException“ ist bzw. von einer dieser Klassen abgeleitet ist. Und natürlich
ungeprüfte Exceptions.
• void h()
Diese Funktion darf keine geprüften Exceptions werfen, sondern nur ungeprüfte.
Achtung – die Exception-Spezifikation bezieht sich nur auf geprüfte Exceptions. Jede Funktion
kann jederzeit ungeprüfte Exceptions werfen.
Durch die Exception-Spezifikation weiß der Compiler, ob eine Funktion eine geprüfte Exception
werfen könnte oder nicht. Der Funktions-Aufruf einer Funktion, die eine geprüfte Exception
werfen könnte, muss seinerseits wieder entweder durch einen try-catch-Block oder eine
Exception-Spezifikation gesichert sein.
public void f1() throws Exception {
}
public void f2() {
f1();
}
// Compiler-Fehler, unbehandelte Exception
Lösung 1 – Abfangen der Exception in der Funktion selber
}
public void f2() {
try {
f1();
}
catch (Exception x)
}
}
// Exception wird abgefangen
{
Lösung 2 – Funktion mit Exception-Spezifikation
}
f1();
// Exception wird nach aussen gemeldet
}
Die Exception-Spezifikationen von Java sind nicht unumstritten:
Ein klarer Vorteil ist, dass - zumindest die geprüften Exceptions - im Code behandelt werden
müssen, da der Compiler dies prüft. Für die geprüften Exceptions können daher zur Laufzeit
keine unangenehmen Überraschungen auftreten.
In der Praxis findet man aber häufig try-Blöcke mit leeren catch-Blöcken, d.h. ohne wirkliche
Fehlerbehandlung. Diese Blöcke stehen dann nur da, um den Compiler zu befriedigen, nicht
aus wirklicher Überzeugung. Hier im Tutorial z.B. finden sich einige Beispiele mit leeren catch© Detlef Wilkening 1997-2016
Seite 387 / 409
Blöcken - zum Teil da noch keine Exceptions bekannt waren, und zum Teil da das Beispiel um
andere Sprach-Features ging und der Code nicht zu sehr aufgebläht werden sollte.
Exception-Spezifikation blähen die Funktions-Signatur häufig um technische Fehler auf, die auf
unteren Ebenen nicht behandelt werden können. Z.B. Netzwerk- oder Datenbank-Probleme
sind typische Beispiele. Die entsprechenden Exceptions sind geprüfte Exceptions. Da sie auf
unteren Ebenen nicht sinnvoll behandelt werden können, müssen sie nach oben durchgereicht
werden, und das heißt wiederrum lange Exception-Spezifikationen ohne wirklichen Vorteil denn das eine Datenbank-Operation schief gehen kann, sollte auch so jedem klar sein.
In der Praxis geht daher mittlerweile die Tendenz zu ungeprüften Exceptions. So gibt es z.B. im
Serverbereich das immer beliebtere Framework „Spring“, das u.a. mit dem Hauptvorteil wirbt,
dass es die geprüften JDBC (Datenbank) Exceptions automatisch in ungeprüfte überführt.
Die größte Gefahr ist aber das fehlende Bewußtsein vieler Programmierer für ungeprüfte
Exceptions. Aufgrund der immer wieder vorkommenden Compiler-Fehler wegen nicht
behandelter geprüfter Exceptions entsteht bei vielen Programmieren das Gefühl, sobald der
Compiler nicht mehr nervt habe man sich um alle möglichen Probleme gekümmert. Dabei wird
dann vergessen, dass es viele - sehr viele - ungeprüfte Exceptions gibt, die mögicherweise
nicht bedacht worden sind. Hierbei sollte auch bedacht werden, dass viele sehr elementare
Exceptions wie z.B. die „NullPointerException“ oder auch die
„ArrayIndexOutOfBoundsException“ zu den ungeprüften Exceptions gehören. Und sehr
kritische Fehler, wie z.B. fehlender Speicher, werden auch über ungeprüfte Exceptions
gemeldet für die dann auch noch die Empfehlung ausgesprochen wird „sich nicht drum zu
kümmern, da man in Java dann eh nichts mehr machen kann“ - siehe Kapitel todo. Ein weiterer
wichtiger Verweis ist auch das Kapitel todo über das Thema „Exception-Sicherheit“.
22.10 Verschachtelte try-Blöcke
Natürlich kann in einem try-Block wieder ein try-Block verkommen – direkt innerhalb der
Funktion (Bsp. 1) oder auch indirekt durch Funktions-Aufrüfe (Bsp. 2).
try {
System.out.println("Aeusserer try-Block");
try {
System.out.println("Innerer try-Block");
}
System.out.println("Innerer catch-Block");
}
System.out.println("Aeusserer try-Block Ende");
}
System.out.println("Aeusserer catch-Block");
}
}
private static void f() {
try {
Seite 388 / 409
}
}
}
try {
f();
}
}
}
Ausgabe (in beiden Beispielen identisch)
Aeusserer try-Block
Innerer try-Block
Innerer catch-Block
Aeusserer try-Block Ende
In der Praxis ist gerade die zweite Variante nicht ungewöhnlich, da man häufig nicht weiß was
in den aufgerufenden Funktionen genau passiert. Und das intern irgendwas schief gehen
könnte, ist recht normal.
Drei Anwendungen sind hierbei besonders interessant:
• Erneutes Auswerfen einer Exception
• Auswerfen einer anderen Exception
• Unbehandelte Exceptions im inneren Block
22.10.1 Erneutes Auswerfen einer Exception
Eine gefangene Exception kann natürlich jederzeit im catch-Block wieder geworfen werden.
Dies passiert, wenn man auf einen Fehler oder eine Fehler-Gruppe dediziert reagieren möchte,
den Fehler aber nicht endgültig behandeln kann – ihn also weitermelden muß.
try {
try {
}
throw x;
}
// System.out.println("Aeusserer try-Block Ende");
}
}
}
unreachable code
Ausgabe
Aeusserer try-Block
Innerer try-Block
Innerer catch-Block
Seite 389 / 409
Aeusserer catch-Block
Hinweis – mit Verlassen des catch-Blocks gilt die primäre Exception als behandelt. Die neu
geworfene wurde aber noch nicht gefangen – und gilt daher nun als unbehandelt. Hierbei ist es
unwichtig, dass das neu geworfene Exception-Objekt identisch zum alten ist.
22.10.2 Auswerfen einer anderen Exception
Statt der Original Exception kann auch eine beliebige andere Excepton geworfen werden. Dies
wird häufig gemacht, wenn die Original Exception nicht nach aussen bekannt gemacht werden
soll, da sie z.B. aus einer externen Bibliothek kommt.
try {
try {
}
}
// System.out.println("Aeusserer try-Block Ende");
}
}
}
unreachable code
Ausgabe
Aeusserer try-Block
Innerer try-Block
Innerer catch-Block
Aeusserer catch-Block
Hinweis – man nennt dies auch Exception-Mapping.
Hinweis – mit Verlassen des catch-Blocks gilt die primäre Exception als behandelt. Die neu
geworfene wurde aber noch nicht gefangen – und gilt daher nun als unbehandelt.
22.10.3 Unbehandelte Exceptions im inneren Block
Es ist nicht notwendig, dass die catch-Blöcke eines try-Blocks alle möglichen Exceptions
fangen. Ist kein passender catch-Block vorhanden, wird der Stack weiter abgebaut bis ein trymit einem passenden catch-Block gefunden wird.
try {
System.out.println("Aeusserer try-Block Start");
try {
System.out.println("Innerer try-Block Start");
System.out.println("Werfe Exception");
}
catch (ClassCastException x) {
System.out.println("Innerer catch-Block: ClassCastException gefangen");
Seite 390 / 409
}
}
System.out.println("Aeusserer catch-Block: Exception gefangen");
}
}
Ausgabe
Aeusserer try-Block Start
Innerer try-Block Start
Werfe Exception
Aeusserer catch-Block: Exception gefangen
Dies ist ein ganz normaler Fall. Sie müssen nicht an jeder Stelle alle möglichen Exceptions
abfangen, nur weil sie geworfen werden könnten. Sondern an den Stellen, an denen sie
bestimmte Fehler behandeln, sie melden, neu aufsetzen oder sonst was können – also sinnvoll
auf diese Fehler reagieren können – an denen fangen sie sie ab. Ansonsten ignorieren sie sie –
im Rahmen der Exception-Sicherheit, siehe Kapitel 22.12.
22.11 Exception-Objekte
Ein Exception sollte detailierte Informationen über den Fehler enthalten, der zu ihrem Werfen
führte. Dann können Meldungen ausgeben werden, die helfen den Fehler zu finden und zu
beheben. Da sie prinzipiell für jeden Fehlertyp eine eigene Exception-Klasse entwerfen können,
stehen ihnen die kompletten Möglichkeiten einer Klasse zur Verfügung um diese Informationen
zu transportieren.
Unabhängig davon erbt jedes Exception Objekt, da es direkt oder indirekt von „Throwable“
abgeleitet ist, mehrere Funktionen – und damit implizit Funktionalitäten. Zwei davon möchte ich
hier vorstellen:
• public String getMessage()
Gibt einen String zurück, der die Exception näher beschreibt.
• public void printStackTrace()
Gibt die aktuelle Exception und den Funktions-Stack zum Zeitpunkt ihrer Erzeugung auf der
Error-Ausgabe aus.
public class Appl {
throw new RuntimeException("Ich bin ein Fehler-Objekt");
}
f3();
}
f2();
}
try {
f1();
}
catch (Throwable t) {
Seite 391 / 409
System.out.println("Throwable gefangen");
System.out.println("Obj: \"" + t + '"');
System.out.println("Msg: \"" + t.getMessage() + '"');
t.printStackTrace();
}
}
}
Ausgabe
Throwable gefangen
obj: "java.lang.RuntimeException: Ich bin ein Fehler-Objekt"
msg: "Ich bin ein Fehler-Objekt"
java.lang.RuntimeException: Ich bin ein Fehler-Objekt
at Appl.main(Appl.java:17)
Hinweis – diesmal ist das Beispiel der vollständige Quelltext, damit sie sehen das im StackTrace Dateiname und Zeilennummern der Funktions-Aufrufe enthalten sind.
22.12 Exception-Sicherheit
So einfach und schlüssig Exceptions im ersten Augenblick auch wirken - es ist schwer, wirklich
Exception-sicheren Code zu schreiben. Exception-sicherer Code ist Code, der im Falle einer
Exception keinen undefinierten Status zurückläßt, sondern die Objekte immer in einem
sauberen Zustand hinterläßt. Hierbei werden drei Level unterschieden:
Level 1 – Starke-Garantie
Wenn eine Exception geworfen wird, bleibt der Status des Programms im logischen Sinne
unverändert. Diese Garantie impliziert eine globale Commit/Rollback Strategie, die auch dafür
sorgt, dass z.B. Referenzen und Iteratoren nach einer Exception noch korrekt sind.
Level 2 – Mindest-Garantie
Wenn eine Exception geworfen wird, so entstehen keine Ressourcen-Löcher (z.B. nicht
geschlossene Dateien oder Netzwerk-Verbindungen), und alle Objekte bleiben konsistent und
benutzbar. Dies ist die Mindest-Garantie, die gegeben sein muss, damit ein Programm
funktionsfähig bleibt.
Level 3 – keine Garantie
Wenn eine Exception geworfen wird, so entstehen Ressourcen-Löcher bzw. nicht benutzbare
oder inkonsistente Objekte.
Level 3 darf nie passieren, denn dann haben sie ein potentielles Problem in ihrem Programm.
Level 1 wäre der Ideal-Zustand, der aber häufig nicht erreichbar ist, aber angesprebt werden
sollte.
Hier ein kleines Beispiel – Exception-sicher oder nicht?
Seite 392 / 409
private int age;
private String phone;
public Person(String n, String a, String p) {
name = n;
age = Integer.parseInt(a);
phone = p;
}
return name + " (Alter: " + age + ") - Telefon: " + phone;
}
public void init(String n, String a, String p) {
name = n;
age = Integer.parseInt(a);
phone = p;
}
}
Natürlich nicht! Schauen wir uns z.B. folgende Benutzung an:
Person prs = new Person("Detlef", "23", "0241 / 123 456");
System.out.println("Person: " + prs);
try {
prs.init("Bernd", "--", "012 / 345 67");
}
}
System.out.println("Person: " + prs);
}
Ausgabe
Person: Detlef (Alter: 23) - Telefon: 0241/ 123 456
Person: Bernd (Alter: 23) - Telefon: 0241/ 123 456
Wie sie an der Ausgabe sehen, existiert nach der Exception ein Personen-Objekt, das einen
inkonsistenten Zustand hat. Denn eine Person „Bernd“ mit Alter „23“ und der Telefon-Nr.
„0241/123456“ gibt es nicht.
Das Problem ist hier die „init“ Funktion in der Klasse „Person“. Mitten in der Veränderung der
Attribute der Klasse kann eine Exception geworfen werden – in diesem Augenblick ist ein Teil
der Attribute verändert, während ein anderer Teil noch den alten Wert hat. Das darf nicht
passieren!
Die Lösung ist entweder:
• Erst alle Veränderungen lokal machen, und sie dann in einem Rutsch Exception-sicher
ausführen. Oder
• Alle Veränderungen Stück für Stück ausführen, aber im Falle einer Exception die schon
gemachten rückgängig zu machen.
public void init(String n, String a, String p) {
int ag = Integer.parseInt(a);
name = n;
age = ag;
Seite 393 / 409
phone = p;
}
Das Problem ist, dass an sehr vielen Stellen Exceptions geworfen werden können – man aber
nicht daran denkt, da man sie im normalen Code nicht sieht. Und da viele Exceptions keine
geprüften Exceptions sind, macht einen der Compiler auch nicht darauf aufmerksam.
23 Streams
23.1 Einführung
Ein allgemeines Konzept in der Software-Entwicklung sind die sogenannte Streams. Ein
Stream ist eigentlich nicht mehr als ein Datenstrom, der die Daten von irgendwoher bezieht und
irgendwohin liefert. Außerdem können Streams möglicherweise manipuliert werden (z.B.
geleert werden).
Abb. 23-1 : Ein nicht näher spezifizierter Datenstrom
In der Praxis sind zwei Stream-Varianten besonders wichtig:
• Byte-Streams, d.h. Streams, bei denen der Datenstrom aus einfachen Bytes ohne jede
Struktur besteht. Byte-Streams werden in Java durch Input-Streams bzw. Output-Streams
repräsentiert – siehe Kapitel todo.
• Zeichen-Streams, d.h. Streams, bei denen der Datenstrom aus Zeichen besteht. Da Java
intern mit Unicode UTF-16 arbeitet, sind hier im Normallfall 2 Byte große Zeichen mit UTF16 Codierung gemeint. Zeichen-Streams werden in Java durch Reader und Writer
repräsentiert – siehe Kapitel todo.
Bemerkung – da Streams sehr allgemein sind, werden sie oft als Grundlage für ein
Kommunikation-Konzept zwischen zwei beliebigen „Partnern“ genommen, z.B. zwischen
Prozessen, Threads, zwei Netzwerk-Teilnehmern, einem Datei-System und einem Programm,
usw.
23.2 Java Streams
23.2.1 Architektur
In Java stehen 4 Stream-Hierarchien zur Verfügung:
• Eingabe Byte-Streams – abstrakte Basis-Klasse: „java.io.InputStream“
• Ausgabe Byte-Streams – abstrakte Basis-Klasse: „java.io.OutputStream“
• Eingabe Zeichen-Streams – abstrakte Basis-Klasse: „java.io.Reader“
• Ausgabe Zeichen-Streams – abstrakte Basis-Klasse: „java.io.Writer“
Warum gibt es überhaupt 4 Stream-Hierarchien, und nicht einfach 4 Stream-Klassen?
Seite 394 / 409
• Nun, im einfachsten Fall transportieren Streams ihre Daten unverändert von der Quelle zum
Ziel. Aber es gibt auch Streams, die die Daten unterwegs manipulieren – z.B. puffern,
filtern, zählen, zippen bzw. unzippen, Hash-Werte bestimmen, und vieles mehr.
• Außerdem sind die Quellen und Ziele je nach Anforderung unterschiedlich. In einem Fall
wird z.B. aus einer Datei gelesen und in einen String geschrieben. In einem anderen Fall
aus einem Byte-Array gelesen und in eine Datei geschrieben.
Statt einer Klasse, die „alles“ anbietet, wurde in Java die bessere und offenere Architektur einer
Klassen-Hierarchie gewählt.
• Es gibt eine abstrakte Basis-Klasse, z.B. „InputStream“
• Pro Verhalten gibt es eine konkrete abgeleitete Klasse, z.B. „BufferedInputStream“.
• Viele Streams können einen anderen gleichartigen Stream kapseln.
Welche Vorteile hat eine solche Architektur?
• Kleine, übersichtliche und gekapselte Komponenten
Jede einzelne Klasse ist nur für ein Verhalten da, und kann so klein und übersichtlich – auch bzgl.
ihrer Schnittstelle – gehalten werden.
• Erweiterbarkeit und Offenheit
Implementiert keine Stream-Klasse ein gewünschtes Verhalten, so kann es jederzeit selber
implementiert und in die Stream-Verarbeitung integriert werden.
• Kombinierbarkeit
Da viele Streams ineinander gekapselt werden können, können die einzelnen Transformationen in
beliebigen Kombinationen und Reihenfolgen aufeinander angewandt werden.
• Erweiterbarkeit, Offenheit und Kombinierbarkeit
Es können alle Quellen mit allen Zielen kombiniert werden, und es können eigene Quellen bzw. Ziele
in die Stream-Verarbeitung integriert werden.
Gerade die Voraussetzung „Streams fast beliebig ineinander zu kapseln“ erlaubt eine wahre
Vielfalt an Lösungen. So könnte z.B. ein Input-Stream eine Datei kapseln. Um diesen gepuffert
auszulesen, wird er in einem gepuffert-Input-Stream gekapselt. Ist die Datei verschlüsselt,
würde man diesen in einem Entschlüsselungs-Stream kapseln. Und wenn der eigentliche Inhalt
dann noch gezippt ist, dann wird noch ein Unzip-Input-Stream um diesen herum gelegt.
Abb. 23-2 : Bsp für ineinander gekapselte Streams
Hinweis – funktionieren tut dies intern natürlich wieder mit Vererbung und Polymorphie. Da
z.B. alle Input-Streams von einer Basis-Klasse abgeleitet sind, können sie alle über diese
gehandelt werden. Da sie die Schnittstelle der Basis-Klasse überschrieben haben, werden die
Aufrufe via Polymorphie transparent an die jeweiligen Implementierungen weitergereicht.
Abb. 23-3 : Arbeitsweise der Stream-Kapselung
Seite 395 / 409
23.2.2 Byte-Streams und Zeichen-Streams
Der allgemeinere Stream-Typ ist natürlich der Byte-Stream, da intern alle Daten aus Bytes
aufgebaut sind. Um aus einem Byte-Stream Zeichen zu lesen, existiert daher die von „Reader“
abgeleitete Klasse „java.io.InputStreamReader“, die einen Input-Stream in einem Reader
kapselt. Umgekehrt gibt es die von „Writer“ abgeleitete Klasse „java.io.OutputStreamWriter“,
die einen Output-Stream in einem Writer kapselt.
Ein Beispiel hierfür findet sich z.B. in Kapitel 23.3.1.
23.2.3 Stream-Hierarchien
Viele spezielle Stream-Fähigkeiten (d.h. konkrete Stream-Klassen) finden sich in allen 4
Stream-Hierarchien. Zum einen werden natürlich für die meisten Eingabe-Streams auch die
entsprechenden Gegenstücke auf der Ausgabe-Seite benötigt, bzw. umgekehrt. Zum anderen
sind viele Fähigkeiten unabhängig vom Daten-Typ (d.h. Byte oder Zeichen), und sind daher in
beiden Hierarchien sinnvoll.
Stellvertretend für alle Stream-Hierarchien wird hier die Eingabe Byte-Stream Hierarchie
detailierter betrachtet. Für die anderen Streams wird auf die Java-Hilfe verwiesen.
java.lang.Object
java.io.InputStream (abstract) – siehe auch Kapitel todo
javax.sound.sampled.AudioInputStream
java.io.ByteArrayInputStream – siehe auch Kapitel todo
java.io.FileInputStream – siehe auch Kapitel todo
java.io.FilterInputStream
java.io.BufferedInputStream – siehe auch Kapitel todo
java.util.zip.CheckedInputStream
javax.crypto.CipherInputStream
java.io.DataInputStream – siehe auch Kapitel todo
java.security.DigestInputStream
java.util.zip.InflaterInputStream
java.util.zip.GZIPInputStream
java.util.zip.ZipInputStream
java.util.jar.JarInputStream
java.io.LineNumberInputStream (deprecated)
javax.swing.ProgressMonitorInputStream
java.io.PushbackInputStream – siehe auch Kapitel todo
org.omg.CORBA.portable.InputStream
java.io.ObjectInputStream – siehe auch Kapitel todo
java.io.PipedInputStream
java.io.SequenceInputStream – siehe auch Kapitel todo
java.io.StringBufferInputStream (deprecated)
Seite 396 / 409
23.2.3.1 Klasse „java.io.InputStream“
Basis-Klasse für alle byte-orientierten Input-Streams
• public int available() throws IOException
• public void close() throws IOException
• public abstract int read() throws IOException
• public int read(byte[ ] b) throws IOException
23.2.3.2 Klasse „java.io.ByteArrayInputStream“
Hiermit kann ein Byte-Array mit einem Input-Stream verbunden werden.
byte[] array = new byte[10];
ByteArrayInputStream in = new ByteArrayInputStream(array);
23.2.3.3 Klasse „java.io.FileInputStream“
Ist ein Stream, der mit einem File verbunden wird.
• public FileInputStream(File file) throws FileNotFoundException
• public FileInputStream(String name) throws FileNotFoundException
Ein Beispiel hierfür finden sie z.B. in Kapitel 23.3.2.
23.2.3.4 Klasse „java.io.BufferedInputStream“
Implementiert einen gepufferten Input-Stream
• public BufferedInputStream(InputStream in)
Ein Beispiel hierfür finden sie z.B. in Kapitel 23.3.2 und Kapitel 25.
23.2.3.5 Klasse „java.io.DataInputStream“
Mit diesem Stream können die elementaren Datentypen aus einem zugrunde liegenden
InputStream auf maschinenunabhängge Weise gelesen werden.
• public DataInputStream(InputStream in)
• public final int readInt() throws IOException
23.2.3.6 Klasse „java.io.PushbackInputStream“
Implementiert einen Stream mit Puffer, in den Daten zurückgeschrieben werden können.
• public PushbackInputStream(InputStream in)
• public void unread(byte[ ] b) throws IOException
23.2.3.7 Klasse „java.io.ObjectInputStream“
Implementiert einen Stream, aus dem komplette Objekte heraus gelesen werden können.
Seite 397 / 409
• public ObjectInputStream(InputStream in) throws IOException, ...
• public final Object readObject() throws OptionalDataException, ClassNotFoundException
Beispiele hierfür finden sich im Kapitel über Serialisierung – siehe Kapitel 25.
23.2.3.8 Klasse „java.io.SequenceInputStream“
Kann Input-Streams sequenziell koppeln.
• public SequenceInputStream(InputStream s1, InputStream s2)
Ein Beispiel hierfür finden sie z.B. in Kapitel 23.3.4.
23.3 Beispiele
23.3.1 Beispiel „Tastatur-Eingabe“
Beispiel aus Kapitel 3.10. Erläuterung – todo...
try {
System.out.println("Echo-Programm");
while (true) {
if (in.length()==0) {
break;
}
}
}
}
}
mögliche Ausgabe
Echo-Programm
> Hallo
"Hallo" - 5 Zeichen
> Ich lerne jetzt Java
"Ich lerne jetzt Java" - 20 Zeichen
>
Programm-Ende
23.3.2 Beispiel „Datei lesen“
Erläuterung – todo...
try {
System.out.println("Lese Datei \"Testdaten.txt\" - Version 1");
File file = new File("Testdaten.txt");
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis);
Seite 398 / 409
while (true) {
if (in==null) break;
System.out.println("> " + in);
}
System.out.println("Datei-Ende");
}
System.out.println("Probleme beim Lesen der Datei");
}
}
mögliche Ausgabe
Lese Datei "Testdaten.txt"
> Hallo Welt,
>
> diese Zeilen kommen aus der Datei.
Datei-Ende
Eine alternative kürzere Variante arbeitet mit der Klasse „java.io.FileReader“, die intern ein FileObjekt erzeugt, dieses in einen File-Input-Stream und dann in einem Input-Stream-Reader
kapselt.
try {
System.out.println("Lese Datei \"Testdaten.txt\" - Version 2");
FileReader fr = new FileReader("Testdaten.txt");
BufferedReader reader = new BufferedReader(fr);
while (true) {
if (in==null) break;
System.out.println("> " + in);
}
System.out.println("Datei-Ende");
}
System.out.println("Probleme beim Lesen der Datei");
}
}
23.3.3 Beispiel „Lesen mit Zeilen-Nummer“
try {
System.out.println("Echo-Programm mit Zeilen-Nummern");
LineNumberReader reader = new LineNumberReader(isr);
while (true) {
break;
}
System.out.print(reader.getLineNumber() + ":");
}
}
}
}
Seite 399 / 409
mögliche Ausgabe
Echo-Programm mit Zeilen-Nummern
> Hallo Welt,
1: "Hallo Welt," - 11 Zeichen
> ich lerne jetzt Java.
2: "ich lerne jetzt Java." - 21 Zeichen
> Bald schon kann ich tolle Sachen schreiben.
3: "Bald schon kann ich tolle Sachen schreiben." - 43 Zeichen
> Bis bald...
4: "Bis bald..." - 11 Zeichen
>
23.3.4 Beispiel „Sequenzielle Kopplung“
try {
System.out.println("Lesen aus zwei gekoppelten Strings:");
String s1 = "Zeile 1\n\nUnd dies ist ";
String s2 = "die Zeile 3\nZeile 4";
// StringBufferInputStream ist zwar deprecated, aber die Klasse
// ermoeglicht das einfachste Beispiel - darum doch.
StringBufferInputStream sbis1 = new StringBufferInputStream(s1);
StringBufferInputStream sbis2 = new StringBufferInputStream(s2);
SequenceInputStream sis = new SequenceInputStream(sbis1, sbis2);
InputStreamReader isr = new InputStreamReader(sis);
LineNumberReader reader = new LineNumberReader(isr);
while (true) {
if (in==null) {
break;
}
System.out.println(reader.getLineNumber() + ": \"" + in + "\"");
}
}
}
}
Ausgabe
Lesen aus zwei gekoppelten Strings:
1: "Zeile 1"
2: ""
3: "Und dies ist die Zeile 3"
4: "Zeile 4"
23.4 Stream-Tokenizer
Hilfs-Klasse um Zeichen-Ströme in Token zu zerlegen: „java.io.StreamTokenizer“.
• public StreamTokenizer(Reader r)
• public int ttype
• public static final int TT_EOF
• public static final int TT_EOL
• public static final int TT_NUMBER
• public static final int TT_WORD
• public String sval
Seite 400 / 409
• public double nval
• public int nextToken() throws IOException
try {
String str = "3 mal 3 ist ach..., aeh ... 9!";
StringReader sr = new StringReader(str);
StreamTokenizer st = new StreamTokenizer(sr);
while (st.nextToken() != StreamTokenizer.TT_EOF) {
switch (st.ttype) {
case StreamTokenizer.TT_EOL:
System.out.println("End of Line");
break;
case StreamTokenizer.TT_NUMBER:
System.out.println("Zahl: " + st.nval);
break;
case StreamTokenizer.TT_WORD:
System.out.println("Wort: " + st.sval);
break;
}
}
}
}
}
Ausgabe
Zahl: 3.0
Wort: mal
Zahl: 3.0
Wort: ist
Wort: ach...
Wort: aeh
Zahl: 0.0
Zahl: 0.0
Zahl: 0.0
Zahl: 9.0
Der Case-Fall „StreamTokenizer.TT_EOL“ wird hier eigentlich nicht benötigt, da defaultmässig
im StringTokenizer ein EOL ein Whitespace ist.
24 Reflexion
Java bietet ein Sprachmittel, mit dem zur Laufzeit Informationen über beliebige Objekte
abgefragt und genutzt werden können. Dazu existiert in Java die Klasse „java.lang.Class“, die
eine Art Meta-Ebene über den normalen Klassen darstellt, d.h. sie enthält Informationen über
die Klassen selber. Mit solchen Informationen kann man anders programmieren, als man es
von ‘normalen’ Compiler-Sprachen gewöhnt ist.
24.1 Objekt-Erzeugung über den Klassen-Namen
Eine der Möglichkeiten die sich durch solche Meta-Informationen bietet, ist die Erstellung von
Objekten einer Klasse zur Laufzeit nur unter Angabe des Klassen-Namens.
Bitte verstehen Sie diesen Satz richtig. Es geht nicht um die normale Erzeugung eines Objekts
mit „new“ in der Art:
Seite 401 / 409
String s = new String();
sondern um eine Erzeugung, bei der der Klassen-Name zur Compile-Zeit noch vollkommen
unbestimmt ist.
Object o1 = ClassCreator.create("KlassenName");
Object o2 = ClassCreator.create(string);
Hierbei erzeugt die Funktion „create“ der Klasse „ClassCreator“ zur Laufzeit aus dem String ein
Objekt der Klasse und liefert dieses zurück. Der String kann z. B. auch aus einer BenutzerEingabe oder einer Datenbank87 stammen, d.h. er ist zur Compile-Zeit vollkommen unbestimmt.
Die Klasse „ClassCreator“ und die Funktion „create“ sind hierbei willkürlich gewählt – sie
existieren so in Java nicht. Es ging dabei erstmal nur darum, den obigen Code einfach zu
halten, und den Unterschied zu „new“ zu verdeutlichen. Aber wir können problemlos eine
Klasse erstellen, die sich entsprechend verhält.
public class ClassCreator {
public static Object create(String name) {
try {
Class descriptor = Class.forName(name);
return descriptor.newInstance();
}
catch (Throwable x) {
System.out.println("Probleme in ClassCreator.create(String)");
}
return null;
}
}
Und so wird sie dann benutzt:
StringBuffer s = (StringBuffer)ClassCreator.create("java.lang.StringBuffer");
s.append("Java ganz meta-maessig");
Ausgabe
Java ganz meta-maessig
„Object forName(String)“ ist eine Klassen-Funktion der Klasse „Class“, die einen String - den
vollständig referenzierten Klassen-Namen - erwartet, und dann einen Klassen-Descriptor vom
Typ „Class“ zurückgibt. Dieses Objekt der Klasse „Class“ enthält eine vollständige
Beschreibung der angegebenen Klasse. Mit diesem Descriptor kann z.B. mit „newInstance()“
ein neues Objekt der Klasse erzeugt werden88.
Achtung – die Klasse des so erzeugten Objekts muss einen Standard-Konstruktor haben, da
die JVM keine Parameter herbeizaubern kann.
Der Mechanismus der Serialisierung (siehe Kapitel todo...) arbeitet genau mit diesem Trick.
88 Da ClassCreator.create ein Object zurückgibt, muss das Ergebnis natürlich gecastet
werden, damit es benutzt werden kann.
87
Seite 402 / 409
Folgende Probleme können auftauchen:
String
Leerstring "", bzw. Unerlaubter Name
Unreferenzierter Klassen-Name
Nicht public Klasse in fremdem Package
Klasse mit privatem Standard-Konstruktor
Klasse ohne Standard Konstruktor
Abstrakte Klasse bzw. Interface
Exception
IllegalArgumentException
ClassNotFoundException
IllegalAccessException
IllegalAccessException
NoSuchMethodError
IllegalArgumentException
24.2 Klasse „Class“
Für jede Klasse in der virtuellen Maschine wird ein „Class“ Objekt angelegt. Mit der Funktion
‘Class getClass()’ der Klasse „Object“ kann man daher direkt an die Meta-Informationen zu
einem Objekt gelangen.89
String s = "Hallo";
Class c = s.getClass();
24.2.1 Element-Funktionen
Die Klasse „Class“ enthält Element-Funktionen, mit der Information über die Klasse des
zugehörigen Class-Objekts zur Laufzeit ermittelt werden können. Hier eine kleine Auswahl:
Funktion
String getName()
Constructor[ ] getConstructors()
Constructor[ ] getDeclaredConstructors()
Method[ ] getMethods()
Method[ ] getDeclaredMethods()
Field[ ] getFields()
Field[ ] getDeclaredFields()
boolean isArray()
boolean isInterface()
boolean isPrimitive()
Rückgabewert
voll referenziert Name der Klasse
Array aller public Konstruktoren
Array aller Konstruktoren
Array aller public Methoden
Array aller Methoden
Array aller public Attribute
Array aller Attribute
ob das Objekt ein Array ist
ob das Objekt ein Interface ist
ob das Objekt ein elementarer Datentyp ist
Hinweis – alle diese Klassen (z.B. „Constructor“, „Method“,...) und viele weitere kommen aus
dem Package „java.lang.reflect“.
Und hier ein kleines einfaches Beispiel:
class Reflect {
private int privateInt;
Da in Java jede Klasse immer direkt oder indirekt von Object abgeleitet ist, ist diese Funktion
immer vorhanden.
89
Seite 403 / 409
protected boolean protectedBoolean;
public double publicDouble;
public Reflect() {}
public Reflect(int i) {}
private void privateFct() {}
protected void protectedFct() {}
public void publicFct() {}
public int fct1() { return 0; }
public void fct1(int i) {}
public void fct1(int i, String s) {}
}
Reflect r = new Reflect();
Class c = r.getClass();
System.out.println("Allgemeine Klasseninformationen");
System.out.println(" " + c.getName());
System.out.println("Konstruktoren");
Constructor[] con = c.getConstructors();
for (int i=0; i<con.length; i++) {
System.out.println(" " + con[i]);
}
System.out.println("Methoden");
Method[] m = c.getMethods();
for (int i=0; i<m.length; i++) {
System.out.println(" " + m[i]);
}
System.out.println("Attribute");
Field[] f = c.getDeclaredFields();
for (int i=0; i<f.length; i++) {
System.out.println(" " + f[i]);
}
}
Ausgabe
Allgemeine Klasseninformationen
Reflect
Konstruktoren
public Reflect(int)
public Reflect()
Methoden
public void Reflect.publicFct()
public void Reflect.fct1(int)
public void Reflect.fct1(int,java.lang.String)
public int Reflect.fct1()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final void java.lang.Object.wait(long,int) throws
java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws
java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
public java.lang.String java.lang.Object.toString()
Attribute
private int Reflect.privateInt
protected boolean Reflect.protectedBoolean
public double Reflect.publicDouble
Seite 404 / 409
Die Parameter-Namen z.B. lassen sich übrigens zur Laufzeit nicht mehr feststellen, da diese
Informationen nicht zur Klasse gehören, und vom Compiler nirgendwo hinterlegt werden.
24.3 Disassemblieren
Bei dem Thema Reflexion liegt die Frage nahe, ob jemand bestehenden Java Byte-Code
decompilieren bzw. disassemblieren kann, und damit an das Know-How des Entwicklers / der
Firma kommen kann, der / die diesen Code geschrieben hat.
Die komplette Programmstruktur liegt immer im Java Byte-Code vor, sonst könnte das
Reflexion API nicht funktionieren. Ausserdem kann der Byte Code in hohen Masse wieder in
relativ lesbaren Quellcode zurückgewandelt werden, denn:
• Die Abbildung von Anweisungen auf Code ist relativ eindeutig.
• Es gibt in Java keinen Präprozessor.
• OO Funktion sind meist sehr klein (90% weniger als 20 Zeilen)
• Der Compiler kann nur wenige Optimierungen machen.
Nur die Namen der Parameter und der lokalen Variablen fehlen.
Ein relativ einfacher Disassembler liegt dem Java SDK bei – es ist das Kommandozeilen-Tool
„javap“. Es gibt viele viel leistungsfähigerer Disassembler – einen relativ guten Ruf hat das Tool
„Jad“ – siehe http://www.kpdus.com/jad.html.
Es gibt daher Tools – sogenannte Obfuscator – die sämtliche Symbol-Definitionen und deren
Benutzungen mit unleserlichen Namen ersetzen. Dies funktioniert aber nur, solange keine
Reflection eingesetzt wird.
24.4 Aufgaben
24.4.1 Aufgabe „Klassen-Inspektor“
Schreiben sie ein kleines grafisches Tool, einen Klassen-Inspektor. Hierbei kann der Benutzer
einen vollständig referenzierten Klassen-Namen eingeben, und erhält danach eine Tabelle der:
- (public) Konstruktoren
- (public) Funktionen
- (public) Attribute
- usw.
24.5 Lsg. zu Aufgabe „Klassen-Inspektor“ – Kap. 24.4.1
todo...
Seite 405 / 409
25 Serialisierung
Der Mechanismus der Serialisierung und der Deserialisierung erlaubt es den Status von
Objekten in einen Stream zu schreiben, bzw. ihn daraus zu lesen, um diesen z.B. nach einem
Programmlauf für den nächsten zu sichern90. Oder auch um Objekt-Stati von einem Rechner
auf den anderen zu transportieren.
Für diesen Mechanismus sind in Java folgende Elemente vorhanden:
• Interface „java.io.Serializable“
• Klasse „java.io.ObjectOutputStream“
• Klasse „java.io.ObjectInputStream“
• Interface „java.io.Externalizable“
• Interface „java.io.ObjectOutput“
• Interface „java.io.ObjectInput“
Genau genommen werden die Interface’s Externalizable, ObjectOutput und ObjectInput in
vielen Fällen gar nicht für eine Serialisierung bzw. Deserialisierung benötigt, da das DefaultVerhalten von Java für die meisten Zwecke ausreicht. Über die Implementierung dieser
Interface’s kann das Default-Verhalten der Serialisierung verändert und angepaßt werden.
Da Serialisierung und Deserialisierung Ein- bzw. Ausgabe-Operationen sind, die fehlschlagen
können, können alle Methoden eine IOException bzw. davon abgeleitete Exception-Klassen
werfen. Manche Funktionen werfen unter Umständen auch noch andere Exceptions. Dies sind
geprüfte Exceptions – bei der Benutzung werden also immer entsprechende try/catch Blöcke
oder Exception-Spezifikationen notwendig sein.
25.1 Interface Serializable
Mit dem Serializable Interface bietet Java einen leistungsstarken Default Mechanismus für
Serialisierung und Deserialisierung, der in vielen Fällen ausreicht. Damit eine Klasse serialisiert
bzw. deserialisiert werden kann, muss sie nur vom Interface Serializable abgeleitet werden. Da
Serializable keine Funktion deklariert, muss in der Serializable-Klasse nichts weiter getan
werden.
import java.io.*;
public class SerialClass implements Serializable {
private String s;
private int i;
public SerialClass(String s, int i) {
this.s = s;
this.i = i;
}
System.out.println("Objekt von SerialClass mit: " + s + " - " + i);
90
Dies wird oft auch mit dem Begriff ‘Persistenz’ belegt.
Seite 406 / 409
}
}
System.out.println("Schreiben");
try {
SerialClass obj1 = new SerialClass("Objekt 1", 42);
SerialClass obj2 = new SerialClass("Objekt 2", 23);
obj1.print();
obj2.print();
FileOutputStream file = new FileOutputStream("objekte.dat");
ObjectOutputStream oos = new ObjectOutputStream(file);
oos.writeObject(obj1);
oos.writeObject(obj2);
oos.flush();
file.close();
}
System.out.println("Fehler beim Schreiben: " + x);
}
Ausgabe
Schreiben
Objekt von SerialClass mit: Objekt 1 - 42
In diesem Beispiel werden zwei Objekte der Klasse „SerialClass“ in die Datei "objekte.dat"
serialisiert (abgespeichert).
Um die beiden Objekte wieder einzulesen ist genauso viel Aufwand nötig:
System.out.println("Lesen");
try {
FileInputStream file = new FileInputStream("objekte.dat");
ObjectInputStream ois = new ObjectInputStream(file);
SerialClass obj1 = (SerialClass) ois.readObject();
SerialClass obj2 = (SerialClass) ois.readObject();
file.close();
obj1.print();
obj2.print();
}
System.out.println("Fehler beim Lesen: " + x);
}
Ausgabe
Lesen
Hinweis – intern arbeitet dies natürlich mit Reflection, über das alle notwendigen Informationen
für die JVM zur Verfügung stehen.
25.2 Rekursion
Die Serialisierung ist nicht auf die primäre Klassen-Ebene beschränkt, sondern läuft rekursiv
durch alle abhängigen Objekte und speichert den gesamten Objekt-Graphen, der zur
vollständigen Wiederherstellung nötig ist.
public class SerialClass1 implements Serializable {
private String s;
private int i;
Seite 407 / 409
private SerialClass2 sc2;
public SerialClass1(String s, int i) {
this.s = s;
this.i = i;
sc2 = new SerialClass2(s);
}
System.out.println("Objekt von SerialClass1 mit: " + s + " - " + i);
System.out.println("- Unter-Objekt: " + sc2);
}
}
public class SerialClass2 implements Serializable {
private String s;
public SerialClass2(String s) {
this.s = s;
}
return "SerialClass2 mit \"" + s + "\"";
}
}
Ausgabe in Anlehnung an das Bsp aus Kapitel 25.1.
Schreiben
Objekt von SerialClass1 mit: Objekt 1 - 42
- Unter-Objekt: SerialClass2 mit "Objekt 1"
Objekt von SerialClass1 mit: Objekt 2 - 23
- Unter-Objekt: SerialClass2 mit "Objekt 2"
Lesen
Objekt von SerialClass1 mit:
- Unter-Objekt: SerialClass2
Objekt von SerialClass1 mit:
- Unter-Objekt: SerialClass2
Objekt 1 - 42
mit "Objekt 1"
Objekt 2 - 23
mit "Objekt 2"
Bei einer solchen Rekursion müssen auch alle abhängigen Klassen serialisierbar sein. Ist eine
Klasse dies nicht, so werden beim Speichern bzw. beim Lesen entsprechende Exceptions
geworfen – siehe Beispiel.
public class SerialClass implements Serializable {
private String s;
private int i;
private NonSerialClass nsc;
public SerialClass(String s, int i) {
this.s = s;
this.i = i;
nsc = new NonSerialClass(s);
}
System.out.println("Objekt von SerialClass mit: " + s + " - " + i);
System.out.println("- Unter-Objekt: " + nsc);
}
}
public class NonSerialClass {
private String s;
Seite 408 / 409
public NonSerialClass(String s) {
this.s = s;
}
return "NonSerialClass mit \"" + s + "\"";
}
}
Ausgabe in Anlehnung an das Bsp aus Kapitel 25.1.
Schreiben
- Unter-Objekt: NonSerialClass mit "Objekt 1"
- Unter-Objekt: NonSerialClass mit "Objekt 2"
Fehler beim Schreiben: java.io.NotSerializableException: NonSerialClass
Lesen
Fehler beim Lesen: java.io.WriteAbortedException: writing aborted;
java.io.NotSerializableException: NonSerialClass
25.3 Klassen-Variablen
Klassen-Variablen, d.h. static Attribute, werden nicht serialisiert und auch nicht deserialisiert, da
sie der Klasse und nicht einem einzelnen Objekt gehören.
25.4 Modifier „transient“
Für Attribute gibt es den Modifier transient, der dafür sorgt, dass dieses Attribut nicht serialisert
bzw. deserialisiert wird.
Hier wird im Beispiel aus Kapitel 25.1 die Klasse „SerialClass“ durch die fast identische Klasse
„SerialClassTransient“ ersetzt – einziger Unterschied ist das das „int“ Attribut den Modifier
„transient“ bekommen hat.
public class SerialClassTransient implements Serializable {
private String s;
private transient int i;
public SerialClassTransient(String s, int i) {
this.s = s;
this.i = i;
}
System.out.println("Objekt von SerialClassTransi. mit: " + s + " - " + i);
}
}
Ausgabe nach der Deserialisierung in Anlehnung an das Bsp aus Kapitel 25.1.
Schreiben
Objekt von SerialClassTransient mit: Objekt 1 - 42
Objekt von SerialClassTransient mit: Objekt 2 – 23
Lesen
Seite 409 / 409
Das „int“ Attribut „i“ wird nicht serialisiert und beim Deserialisieren auf den Defaultwert des Typs
(hier bei int ‘0’) gesetzt.
25.5 Nicht serialisierbare Basis-Klassen
Hat die serialisierbare Klasse eine nicht serialisierbar Basis-Klasse, so muss diese einen
Standard-Konstruktor besitzen, der bei der Deserialisierung zur Konstruktion des BasisKlassen-Anteils aufgerufen wird.
Ist kein Standard-Konstruktor in der Basis-Klasse vorhanden, und wird versucht eine solche
Klasse zu deserialisieren, so wird die Exception „java.io.InvalidClassException“ mit dem Fehler
„NoSuchMethodError“ ausgelöst.
25.6 Aufgaben
Erweitern sie das „Scribble 6“ um die Funktionalität das Bild zu speichern und zu laden.
25.7 Lag. zu Aufgabe „Scribble 7“ – Kap. 25.6.1
todo...

Java Tutorial - Wilkening

Transcription

Similar documents

SCHUBERT