Strukturiert Programmieren Lernen Mit Java

Strukturiert programmieren mit Java
(Grundkonzepte)
www.programmieraufgaben.ch
Philipp Gressly Freimann © 17. Juli 2019 (Version 1.2.21 (TeX))

| Impressum
© Philipp Gressly Freimann
17. Juli 2019
1.2.21 (TeX)
http://www.programmieraufgaben.ch
Alle Rechte vorbehalten

Dieses Werk ist urheberrechtlich geschützt. Der herausgebende Autor verzichtet aber auf das al-
leinige Kopierrecht. Das Werk darf als ganzes kopiert werden. Einzig muss der Originalautor und
eine Referenz auf www.programmieraufgaben.ch bei jeder Kopie (auch wenn dies nur Auszugs-
weise geschieht) mit angegeben werden.
Herausgeber: Philipp Gressly Freimann

Grafik: Philipp Gressly Freimann
Editor: GNU Emacs 23.3.1
Publisher: LATEX: pdfTeX 3.1415926-1.40.10-2.2
| Inhaltsverzeichnis
1 Ausdrücke und Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.1 Ausdrücke und Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.1.1 Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.1.2 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.1.3 Restbildung (Modulo %) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.2 Unär, binär, ternär . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.3 Vorrangregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4 Datentypen und ihre Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.4.1 Ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.4.2 Der Halbaddierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.4.3 Gebrochene Zahlen (metrische Daten) . . . . . . . . . . . . . . . . . . . . 22
1.4.4 Beliebig große, bzw. beliebig genaue Zahlen . . . . . . . . . . . . . . . . . 23
1.4.5 Funktionsresultate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.5 Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.5.1 Beispiel short vs. char . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.5.2 Bezeichner (identifier) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2 Sequenzen (Anweisungen und Abfolgen) . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.1 Abfolgen (Sequenzen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2 Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.2.1 Weitere Anweisungen in Java . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3 Deklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3.1 Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.4 Prozeduraufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.5 Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3 Selektion (Verzweigung) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.1 Einführungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1.1 Die allgemeine if -Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1.2 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.2 Boole’sche Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3 Das Bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3.1 Beispiele zu Boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.3.2 Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.3.3 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.3.4 Zusammensetzen von Vergleichen mit logischen Operatoren . . . . . . . . . 42
3.3.5 De Morgan’sche Regeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.4 else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.5 Mehrfachselektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.5.1 switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.6 Gebrochene Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.6.1 Vergleiche mit Dezimalbrüchen . . . . . . . . . . . . . . . . . . . . . . . . 48
3.6.2 Prüfe auf Ganzzahligkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.7 Funktionale Gebundenheit Boole’scher Ausdrücke . . . . . . . . . . . . . . . . . . 49
3.8 Selektionsinvariante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.9 int , diesmal Bitweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.1 Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.2 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.2.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.3 Zählervariable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.3.1 Die for -Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.4 Sichtbarkeit (Scope) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5 Unterprogramme (Subroutinen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5.1 Vor- und Nachteile von Unterprogrammen . . . . . . . . . . . . . . . . . . . . . . 66
5.2 Arten von Unterprogrammen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.2.1 Primitive Unterprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.2.2 Parameter und Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.2.3 Unveränderbarkeit (keine variable Parameter) . . . . . . . . . . . . . . . . 70
5.2.4 Rückgabewerte (Parameterlose Funktionen) . . . . . . . . . . . . . . . . . 71
5.2.5 Klassische Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.3 Ausdrücke 2. Teil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.3.1 Zusammenfassung der wichtigsten Anweisungen und der Ausdrücke . . . . 75
5.4 Lokale und globale Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.5 Geringschätzung... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.6 Wächter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.7 Leseaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.7.1 a, b oder c zum Ersten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.7.2 x, y oder z . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.7.3 a, b oder c zum Zweiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6 Felder (Arrays) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.1 Arrays und Schleifen (Iteration) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.1.1 «for-each» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.1.2 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.2 Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
7 Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.1 Die Klasse String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.2Verarbeitung von Zeichenketten in Java . . . . . . . . . . . . . . . . . . . . . . 94
7.3Zeichenketten und Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.4Vergleichen von Strings in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.5Plus Operator für String Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.6Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.6.1 char -Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.7 Bemerkung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8 Datenstrukturen und Sammelobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
8.1 Neuer Datentyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
8.1.1 Zugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
8.2 Sammelobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
8.2.1 Beispiel Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
8.2.2 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
8.2.3 HashMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
8.2.4 Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9 Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.1 Leseaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
9.1.1 Selektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
9.1.2 Iteration (Schleife) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
9.1.3 Selektion und Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
9.1.4 Zahlenspielerei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
9.1.5 Fuß-gesteuerte Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
9.1.6 Nur für Spieler ;-) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
9.1.7 Ein sehr alter Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
10 Simulationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
10.1 Random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
11 Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
11.1 Beispiel Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
11.2 Beispiel Ebene zerschneiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
11.3 Vor- und Nachteile der Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
A Anhang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
A.1 Installation und erstes Java-Programm . . . . . . . . . . . . . . . . . . . . . . . 129
A.1.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
A.1.2 Erstes Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
A.1.3 Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
A.2 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
A.3 Die Kommandozeile (Shell bzw. CMD) . . . . . . . . . . . . . . . . . . . . . . . . 136
A.4 Strukturierter Java Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
A.5 Reservierte Wörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
A.6 Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
A.6.1 Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
A.6.2 Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
A.6.3 Eingabe- und Ausgabeumlenkung . . . . . . . . . . . . . . . . . . . . . . . 144
A.7 Weglassen der geschweiften Klammer . . . . . . . . . . . . . . . . . . . . . . . . . 146
A.8 Anmerkungen zur Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
A.8.1 Warnung Strichpunkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
A.8.2 Schleifeninvarianten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
A.8.3 Selektion als Spezialfall . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
A.9 Metasprache zur Darstellung der Grammatiken . . . . . . . . . . . . . . . . . . . 149
A.10 Syntax von Java-Subroutinen (Methoden) . . . . . . . . . . . . . . . . . . . . . 150
A.11 Überladen (Overloading) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
A.12 Stack (Stapel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
A.12.1 Das versteckte « return » . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
A.13 Java-Klasse (Kompilationseinheit) . . . . . . . . . . . . . . . . . . . . . . . . . 154
A.13.1 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
A.13.2 Members einer Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
A.14 Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
A.15 Nominale Werte ( enum ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
A.15.1 Darstellung als Ganzzahltyp . . . . . . . . . . . . . . . . . . . . . . . . . . 159
A.15.2 Variable oder Konstante . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
A.15.3 Konstante Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
A.15.4 Die technische Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
A.15.5 Enumerationstypen (Java- enum ) . . . . . . . . . . . . . . . . . . . . . . 161
A.16 Bit-Maskierung (Mengen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
A.17 Abfragen im Geek-Style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
A.18 Spezialitäten von Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
A.18.1 Anonyme Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
A.18.2 Implementierung von Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . 164
A.18.3 Arrays und Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
A.18.4 Tabellen mit Zeilen unterschiedlicher Länge . . . . . . . . . . . . . . . . . 165
A.19 Besonderheiten von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
A.19.1 Stringlänge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
A.19.2 Teilstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
A.19.3 Unveränderbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
A.19.4 StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
A.19.5 equals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
A.20 Java-Dateien (file-handling) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
A.20.1 Reader und Writer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
A.20.2 Abkürzung im while() -Header . . . . . . . . . . . . . . . . . . . . . . . 172
A.20.3 Anfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
A.20.4 Filterketten (Filter chaining) . . . . . . . . . . . . . . . . . . . . . . . . . 174
A.20.5 Klassisches Filter-Chaining . . . . . . . . . . . . . . . . . . . . . . . . . . 175
A.20.6 Datenströme (Streams) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
A.20.7 Randomaccess-Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
A.21 Java Collection Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
A.21.1 Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
A.21.2 Assoziative Arrays: Java- Map . . . . . . . . . . . . . . . . . . . . . . . . 182
A.21.3 Auffinden der richtigen Sammlung . . . . . . . . . . . . . . . . . . . . . . 183
A.21.4 Eigene Sammelobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
A.22 Eigene Sammelobjekte: Beispiel Kette (LinkedList) . . . . . . . . . . . . . . . . . 184
A.23 Eingabe via Kommandozeilen-Argument . . . . . . . . . . . . . . . . . . . . . . . 187
A.23.1 Typische Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
B Aufgabenverzeichnis / Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C Link-Verzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
D Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
E Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Präambel Eine geschlechtsneutrale Bezeichnung von Personen oder eine Bezeichnung verschie-
dener Geschlechter wurde weitgehend vermieden, um die Lesbarkeit des vorliegenden Dokuments
zu erleichtern. Alle Leser sind selbstverständlich gleichermaßen angesprochen.
9
Vorwort
Das Buch «Programmieren lernen» [GFG11] (S. Literaturliste auf Seite 197) ist weitgehend un-
abhängig von einer Programmiersprache. Glauben Sie jedoch nicht, dass Sie ohne eine Program-
miersprache des Programmierens mächtig werden; Sie lernen auch nicht Auto fahren, indem Sie
Fahrstunden ohne Wagen absolvieren; welche Automarke bzw. welche Programmiersprache Sie
dazu auswählen ist jedoch sekundär.
Damit die Übungen aus [GFG11] fürs Java-Selbststudium durchführbar sind, ist eine minimale
Einführung in Java nötig. Dies wird hiermit zur Verfügung gestellt.
Diese Java-Einführung zeigt diejenigen Syntaxelemente, welche es braucht, um einfache struk-
turierte Programme zu schreiben. Damit sollten die meisten Aufgaben aus
http://www.programmieraufgaben.ch lösbar sein.
Alles wird neu Die Grundkonzepte der Programmierung sind für Lehrlinge wie auch für alte
Hasen gleichzeitig unerlässlich. Da ich sowohl Anfänger wie auch Profis unterrichte, behaupte
ich folgendes: Je besser die Grundlagen sitzen, umso eher ist man in der Lage, sich auf Neues
einzustellen. Wer vorwiegend mit «copy & paste» programmiert1 und sich dann zufrieden gibt,
wenn «es läuft» und dabei nicht versucht, zu verstehen was wirklich passiert, hat wenig Chancen
weiterzukommen. Schlimmer: Solche Programmierer werden früher oder später von einer neuen
Technik überholt und ausrangiert. Dieses Buch richtet sich an Anfänger, die das Kunsthandwerk
der Computerprogrammierung von Grund auf lernen wollen, ebenso wie an langjährige Querein-
steiger, die nie die Gelegenheit hatten, sich mit den Grundlagen moderner Programmiersprachen
auseinander zu setzen und gleichzeitig interessiert sind, eine für sie neue Sprache (hier Java)
kennen zu lernen.
Ich kann mit meinen gut 30 Jahren Programmiererfahrung2 wohl noch nicht behaupten, dass
ich zu den wirklich alten Hasen gehöre. Etwas habe ich dennoch erfahren: Programmiersprachen
kommen und gehen. Von Assembler bis hin zu Python und Grails habe ich gesehen, dass alles im
Wandel ist. Doch etwas Wichtiges habe ich auch gelernt: Die Grundkonzepte von Program-
miersprachen haben sich nicht verändert! Auch heute denke ich oft noch in Anweisungen,
Variablen (Attributen und Entitäten), Selektionen, Iterationen, Methoden und Schnittstellen. Die
Sprachen der 3. Generationen (BASIC, C, Java) wurden immer mächtiger3 , die Fehlerquellen
minimiert, die Entwicklerwerkzeuge immer hilfreicher, die Fehlersuche immer ausgeklügelter; doch
die Grundlagen blieben dieselben. Ich versuche mit diesem Buch dem Leser diejenigen Konzepte
beizubringen, von denen ich überzeugt bin, dass sie noch einmal 40 Jahre überdauern werden.
1
Mit «copy & paste» zu arbeiten, ist im Übrigen nicht programmieren.
2
Die ersten Programme schrieb ich 1982.
3
Einige Sprachen sind hier ausgenommen. Sprachen höherer Generationen wie SQL und PROLOG haben
ihre eigenen speziellen Konzepte. Dennoch bin ich überzeugt, dass die Grundlagen von 3.-Generationsprachen
unerlässlich sind, um das Handwerk der Computerprogrammierung wirklich zu verstehen.
10 Strukturiert programmieren mit Java - Grundkonzepte

Über die Wichtigkeit von Grundlagen Es gibt in meinen Augen nichts Wichtigeres in einem
Ingenieurberuf, als die Grundlagen wirklich zu beherrschen. Goethe sagte schon in seinem Gedicht
«Katzenpastete»:
Bewährt den Forscher der Natur

Ein frei und ruhig Schauen
So folge Messkunst seiner Spur
Mit Vorsicht und Vertrauen...
So kann ich meinen Vorsprecher nur unterstützen in der Aussage, indem ich hier den ersten Insider
Tipp abgebe.
Geek Tipp 1
Wenn Du nicht wirklich verstanden hast, warum ein Programm läuft, dann läuft es nichta !
a
Warum sollte es dann nicht laufen? Natürlich läuft es; für einen Moment. Oft aber nur solange wir als Program-
mierer gerade dabei sind, dieses Programm zu testen. Sobald unser Programm in eine andere Umgebung kommt,
so ist ein Versagen gut möglich. Wenn wir jetzt versuchen, das Programm zu reparieren, oder noch schlimmer,
jemand anders versucht es zu verstehen und danach zum Laufen zu bringen, treten die wirklichen Probleme auf:
Das Programm ist nicht mehr wartbar!
In obigem Sinne möchte ich den Leser anweisen, mindestens zu versuchen, den ersten Teil dieses
Skripts (bis und mit Kapitel 7 «Zeichenketten» auf Seite 93) wirklich zu verstehen. Natürlich sind
wir nach dem Erlernen der Grundlagen noch lange keine guten Programmierer. Wir haben jedoch
das beste Werkzeug in der Hand, alle darauf aufbauenden Konzepte schneller zu erfassen und
mit sicherem Gefühl anwenden zu können. Sollte später etwas nicht so funktionieren, wie wir das
erhofft haben, so haben wir immer noch die Grundlagenwerkzeuge, die uns (meist) ermöglichen,
das entstandene Problem selbst zu lösen, oder aber gekonnt zu umgehen.
11
Und was heißt bitte schön «objektorientiert»?
Strukturiert programmieren mit Java? Geht das überhaupt? Java sei doch eine objektori-
entierte Sprache? Ja, auch für Dich, der schon viel mehr weiß, habe ich einen Antwortversuch
bereit:
Nun, formulieren wir es einmal so. Mit einer objektorientierten Sprache wie Java kann man
unten anderem:
• test-orientiert programmieren
• service-orientiert programmieren
• objektorientiert programmieren
• strukturiert programmieren
• unstrukturiert programmieren
• fehleranfällig programmieren
• überhaupt nicht programmieren
Die Art des Vorgehens hat nichts mit der Sprache zu tun. Auch wenn es in Assembler oder C viel
schwieriger ist, objektorientiert vorzugehen, so ist dies sehr wohl möglich. Jede objektorientierte
Sprache ist aber auch eine prozedurale Sprache und somit sind alle Konzepte, welche für die
strukturierte Programmierung nötig sind in Java auch vorhanden. Genau genommen sind mittels
return , break und continue sogar unstrukturierte Vorgehensweisen in Java zugelassen4 .
Ob es nicht sinnvoller wäre, in Java direkt objektorientiert mit der Kunst des Programmierens
einzusteigen, ist eine didaktische Grundsatzdiskussion. Es geht beides. Begonnen beim «Bit», wie
in diesem Buch, oder direkt begonnen bei «Fenstern», «Knöpfen» und der «Ereignisverarbeitung».
Wer schnell ein Ergebnis auf dem Schirm sehen will, ist mit diesem Lehrmittel wohl nicht gut
bedient. Wer jedoch möglichst alle Grundlagen kennen lernen will, fährt besser mit der in die-
sem Buch vorgeschlagenen «bottom up»-Methode; also derjenigen Vorgehensweise, bei der man
vom innersten Kern einer Programmiersprache (Datenstrukturen, Variable, Sequenzen, Ein- und
Ausgabe, ...) sich langsam in die große Welt der Computerprogrammierung hineinarbeitet.
Ein Gerüst, um in Java weitgehend strukturiert zu programmieren findet sich im Anhang
(s. Kap. A.4 auf Seite 137).
Aufruf Hier noch ein Aufruf an Programmierer anderer Sprachen: Bitte stellt uns solche Ein-
führungen auch für andere Sprachen zur Verfügung. Python ist der nächste Kandidat. C , Ruby
und VisualBASIC werden auch oft gewünscht. Wer sich an einer «Übersetzung» beteiligen will,
soll sich doch bitte mit mir in Verbindung setzen: Philipp Gressly Freimann ( [email protected] ).
4
Es sind sogar mittels else-if innerhalb einer Endlosschleife while mit einer «jump»-Variable beliebige
Sprünge denkbar. Somit braucht es gar keine Spezialbehandlungen, um mit einer «strukturierten»-Sprache eben
«nicht strukturiert» zu programmieren.

Dank
Ein spezieller Dank an Rémy Gressly, der sich die Mühe gemacht hat, sehr viele Tippfehler
aufzuspüren.
Ein weiteres Dankeschön gilt Bruno Keller, welcher die Vorabversion dieses Dokumentes mit einer
Schulklasse durchgearbeitet hatte. (Entschuldige Bruno, dass Du in einer weiteren Durchführung
die Seitennummern und einige Kapitel neu verweisen musst.)
13
| Ein erstes Java-Programm
Bevor wir mit den Themen (also den Kapiteln aus [GFG11]) beginnen, möchte ich alle Leser
ermuntern, ein erstes Java-Programm zu schreiben5 :
public class MeinErstes {
public static void main ( String [] args ) {
new MeinErstes (). top ();
}
void top () {
System . out . println ( " Hallo ␣ Welt " );
}
}
Dieses Programm wird
1. In einem Texteditor geschrieben und als MeinErstes.java gespeichert;
2. mit dem Java-Compiler kompiliert javac MeinErstes.java ;

es entsteht die Datei MeinErstes.class ;
3. und zuletzt mit der Java-virtuellen Maschine (JVM) ausgeführt:

java MeinErstes
Eine detaillierte Installationsanleitung und Tipps zur Fehlersuche finden Sie im Anhang (s. Kap.
A.1 auf Seite 129). Ein generisches strukturiertes Java-Programm ist im Kapitel über Abfolgen
zu finden (s. Kap. A.4 auf Seite 138).
Bemerkung
Die Anweisung System.out.println(...) bezeichnet in Java die Ausgabe einer Textzeile auf
der Konsole.
5
«Didaktischen Hinweis für Lehrer» Es ist natürlich genauso gut möglich, auf die schlecht erklärbare Instanzie-
rung new MeinErstes().top(); zu verzichten und danach bei jeder Subroutine und bei jeder globalen Variable
das Java-Schlüsselwort static anzufügen. Dies kann im Unterricht jedoch zu Fragen führen, die noch nicht
beantwortet werden können, denn das Gegenteil (nämlich der dynamische Code) wird – aus Zeitgründen – ja
allenfalls gar nie erklärt werden können.
Egal, wie wir es in Java drehen und wenden; in Java müssen wir uns immer auf die eine oder andere Weise
mit Objekten beschäftigen.
Wenn wir nun den Lernenden einfach sagen, dass obiger Starter (oder aber das Schlüsselwort static vor jeder
Funktion und vor jeder globalen Variable) einfach immer dazu gehört, so haben wir kritische Fragen nur von
denjenigen Kursteilnehmern, welche sich sowieso schon vertieft um die Materie gekümmert hatten, und für diese
kleine Gruppe ist eine Erklärung dann rasch gegeben.
15
1 | Ausdrücke und Datentypen
1.1 Ausdrücke und Operatoren
Beginnen wir doch gleich mit demselben Ausdruck wie in [GFG11]. Nur, dass wir diesmal den
Java-Code angeben6 :
x + 15 * len ( " Hallo ␣ Welt " )
Ein zusammengesetzter Ausdruck besteht stets aus einfacheren Ausdrücken. Die Grundbausteine
(Literal, Variable, Funktionsaufruf und Operator) werden ab der nächsten Seite erklärt.
6
Im Beispiel ist die Funktion len() keine Standardfunktion von Java! Dieses Beispiel zeigt lediglich den
Aufbau eines Ausdrucks.
17
1 Ausdrücke und Datentypen
1.1.1 Ausdrücke
Ausdrücke werden in vier Kategorien eingeteilt. Im Wesentlichen kann man es sich folgender-
maßen merken. Ein «Ausdruck» ist etwas, was einen Wert hat. Werte werden fast ausschließlich
einer Variable zugewiesen: Entweder geschieht dies mit einer Zuweisung («=» in Java) oder als
Argument in einem Subroutinen-Aufruf7 .
Ausdrücke sind
• Literale8 Zahlen, Buchstaben und Zeichenketten werden als Konstante (bzw. konstante
Werte) direkt in den Code geschrieben.
Beispiele: 5 , "Hallo" , ’c’ , -4.85 , true
• Variable bezeichnen Speicherstellen. An ihrer Stelle können (binär kodierte) Werte stehen.
Jede Variable hat einen Namen (Bezeichner), einen Datentypen und allenfalls einen Wert.
Beispiele: x , chfPer31Dez
• Funktionsresultat Jedes Unterprogramm, das einen Wert zurück liefert, kann als Aus-
druck angesehen werden.
Beispiele: random() , Math.abs(-3.75) , Math.sin(x)
• Zusammengesetzte Ausdrücke Ebenso können Ausdrücke mit speziellen Operatoren

zu neuen Ausdrücken zusammengesetzt werden.
So ist beispielsweise 5 + x + random() ein Ausdruck bestehend aus einem Literal ( 5 ),
einer Variable ( x ) und einem Funktionsresultat ( random() ). Solche zusammengesetzten
Ausdrücke werden wie ein Literal, eine Variable oder ein Funktionsresultat verwendet.
Beispiele: 9 * b , 3*(sin(45) + 44.0) - 8*(r/5.6) , ...
Aufgabe: Finden Sie alle zehn (Teil)ausdrücke im folgenden Ausdruck:

w + 3.2 * ( x + 2 * sin ( y ))
Lösung (s. Kap. B auf Seite 191).
7
Dieses Argument wird dabei dem entsprechenden Subroutinen-Parameter (also auch wieder einer Variable)
übergeben.
8
Literale werden auch als Konstanten bezeichnet. Ebenfalls als Konstanten bezeichnet werden aber auch Varia-
ble, deren Werte nicht verändert werden dürfen; daher verwende ich lieber den Namen «Literal», auch wenn der
Name nicht besonders üblich ist.

1.1.2 Operatoren
Einige Operatoren werden in Java mit den üblichen mathematischen Symbolen dargestellt.
Multiplikation verwendet hingegen einen Stern ( * ) und die Division eine Schrägstrich ( / ).
Die wichtigsten Operatoren in Java sind:
• Addition ( + )
• Subtraktion ( - )
• Vorzeichen ( - )
• Multiplikation ( * )
• Division ( / )
• Restbildung ( % )(s. Kap. 1.1.3 auf Seite 19)
1.1.3 Restbildung (Modulo %)
Die Restbildung wird in Java mit dem Zeichen % dargestellt. Wie wir alle wissen, geht nicht
jede Division «auf». Manchmal interessieren wir uns aber nicht für das Divisionsresultat, sondern
lediglich für den Divisionsrest, eben das, was beim ganzzahligen Dividieren übrig bleibt. Die
Modulo-Operation liefert diesen «Rest».
In den C-Sprachen (C, C++, Java, ...) wird hierzu der %-Operator verwendet:
18 % 7 ergibt 4 (denn 18 durch 7 gibt 2 Rest 4)
27 % 4 ergibt 3 (denn 27 durch 4 gibt 6 Rest 3)
1.2 Unär, binär, ternär

Operatoren wirken nicht immer auf zwei Operanden. Einige (auch unäre oder einargumentige
Operatoren genannt) wirken auf einen einzigen Operanden. Der klassische Vertreter ist das Vor-
zeichen. In Java gibt es auch noch einen ternären (dreiargumentigen) Operator, der jedoch selten
Verwendung findet.
Typ Beschreibung Beispiel
unär Einargumentig Vorzeichen ( - ), aber auch das NOT ( ! )
und die Bitweise Umkehrung( ~ )
binär Zweiargumentig, Summe +
wie die meisten
Produkt *
ternär Dreiargumentig a < b ? "kleiner ": "groesser "
19
1.3 Vorrangregeln
Java-Ausdrücke werden in der Regel von links nach rechts geklammert. So wird folgender Aus-
druck ...
a + b - c - 4.5 + a
... wie folgt geklammert:

(((( a + b ) - c ) - 4.5) + a )
Beim Auswerten von Ausdrücken gilt in auch in Java die «Punkt-Vor-Strich»-Regel. Operatoren
2. Stufe (Level) werden zuerst geklammert:
a * b - c - 4.5 * a
Obiger Ausdruck wird wie folgt geklammert:

(( a * b ) - c ) - (4.5 * a )
Eine vollständige Liste der Operatoren und deren Klammerung in Java finden wir hier:
http://www.santis-training.ch/java/javasyntax/operatoren.php

1.4 Datentypen und ihre Literale
Die wichtigsten fünf Datentypen in Java sind die folgenden:
boolean : Wahrheitswert : true / false
int : integer = ganz ; ganze Zahl ( positiv , negativ )
double : Dezimalbruch mit doppelter Genauigkeit (64 - Bit )
char : Einzelzeichen ( Character )
String : Zeichenkette
Bemerkung 1.1. Geroge Boole (1815-1864) begründete die nach ihm benannte Boole’sche Algebra,
die nur mit zwei Zuständen (0 = false, 1 = true) auskommt, daher der Name boolean .
Eine Zusammenstellung aller Datentypen in Java findet sich im Anhang (s. Kap. A.2 auf Seite
134).
1.4.1 Ganze Zahlen
Zahlen werden in Java im Binärsystem dargestellt. Java kennt die Ganzzahltypen byte ,
short , int und long , die sich lediglich in der Anzahl ihrer Bits9 unterscheiden. Ganzzahltypen
können in Java positive, wie auch negative ganze Zahlen darstellen. Wegen den negativen Zahlen
(Vorzeichen - ) nennen wir diese Datentypen auch «(mit) Vorzeichen behaftet».
1.4.2 Der Halbaddierer
Nun können wir uns fragen, wie denn ein Computer (Rechner) mit den Zahlen rechnen kann. Am
Beispiel des Halbaddierers soll gezeigt werden, wie dies funktioniert.
Ein Halbaddierer ist eine grundlegende elektronische Schaltung, die zwei Bit zusammenzählen
kann. Dabei werden Stromspannungen als Bit repräsentiert (z. B. 0 Volt = 0-Bit und 5 Volt =
1-Bit) und mit einem elektronischen AND (und) und einem elektronischen XOR (exklusives oder)
miteinander verknüpft:
A B Übertrag Summe
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0
Ein Halbaddierer kann einfach mit Relais oder Transistoren gebaut werden. Eine Nachbildung
befindet sich im SANTIS Museum of Computing History (SMOCH):
http://smoch.santis-basis.ch/index.php/halbaddierer
9
Bit = Binary Digit = Ziffer im Zweiersystem
21
1.4.3 Gebrochene Zahlen (metrische Daten)
Gebrochene Zahlen (Zahlen mit Nachkommastellen oder Brüche) werden in der Praxis an ver-
schiedensten Orten angetroffen. Meist handelt es sich dabei um Messgrößen (z. B. Volumen
[Liter], Längen [Meter, mm], Temperatur [Celsius], ...). In Java ist der Datentyp einer solchen
Variable mit double (oder float ) festgelegt. Beachten Sie insbesondere, dass es sich in Java
bei nicht abbrechenden Dezimalzahlen immer um eine Annäherung handelt. So ist es also nicht
möglich die Zahl Pi, oder 1/7 damit exakt darzustellen. Mehr noch: nicht einmal die Zahl 0.1
ist damit genau darstellbar, da die Zahlen im Binärsystem abgebildet werden. Dabei ist eben 0.1
(also ein Zehntel) ein nicht abbrechender «Binärbruch».
Wissenschaftliche Notation Erschrecken Sie nicht, wenn Zahlen wie folgt daher kommen
sollten:
• 5.7e6
• 4.35353535354e-2
• -3.66666666667e-20
Keine Angst: das Zeichen «e» bedeutet hier nichts esoterisches. Diese Schreibweise wird auch als
Exponentialschreibweise bezeichnet (daher wohl das «e»). Dies sagt einfach aus, um wie viele
Stellen der Dezimalpunkt nach rechts verschoben werden soll (bzw. links, falls die Zahl nach dem
«e» negativ ist). Somit sind die obigen Zahlen wie folgt zu lesen:
• 5.7e6 = 5 700 000 = 5.7· 106

• 4.35353535354e-2 = 0.0435353535354 = 4.353...· 10−2
• -3.66666666667e-20 = -0.0000000000000000000366666666667 = −3.66...· 10−20
Typumwandlung (Casting) In typisierten Sprachen wie Java muss oft zwischen gebroche-
nen und ganzen Zahlen umgeschaltet werden. Aus einer ganzen Zahl eine gebrochene zu erhalten,
ist in allen mir bekannten Sprachen trivial: Dies geschieht automatisch. Die Umwandlung in die
andere Richtung bedarf meist einer Zustimmung durch den Programmierer (Casting = expli-
zite Typumwandlung), da durch die Umwandlung in der Regle Information verloren geht. Was
geht verloren? Allfällige Nachkommastellen.
Beispiel:
int i;
double d ;
// Diese Umwandlung ist trivial :

i = 4;
d = i;
// Dies ist nur mit Casting erlaubt :

d = 3.1104 ;
i = ( int ) d ; // i hat nun der Wert 3

1.4.4 Beliebig große, bzw. beliebig genaue Zahlen
In Java existieren zwei weitere Datentypen, welche mit beliebiger Genauigkeit rechnen können:
BigInteger Ein BigInteger kann beliebig große ganze Zah-
len darstellen. Dabei sind 300stellige Zahlen keine
Seltenheit, aber auch kein Problem für Java.
BigDecimal Dagegen kann ein BigDecimal mit beliebig vie-
len Nachkommastellen umgehen. Die Zahl π auf
tausend Nachkommastellen zu berechnen ist mit
Java also gut möglich.
Im folgenden Beispiel wird die Zahl 10 durch 1.234 geteilt und 30 Nachkommastellen werden
ausgegeben:
BigDecimal bd = BigDecimal . TEN ;
bd = bd . setScale (30);
bd = bd . divide ( BigDecimal . valueOf (1.234) , BigDecimal . ROUND_UP );
System . out . println ( bd . toPlainString ());
1.4.5 Funktionsresultate
Funktionsresultate können in Java auch als Ausdrücke angesehen werden und werden wie Va-
riable und Konstanten (Literale) verwendet:
double y ;
y = Math . sin ( x ) + 2 * Math . cos ( Math . ln ( x ) + phi * Math . min (a , b ));
23
1.5 Variable
Es gibt im Umgang mit Variablen grundsätzlich zwei Arten von Programmiersprachen. Bei typi-
sierten Sprachen (C, Java, ...) können einer Variable nur Werte zugewiesen werden, die in einem
vorgegebenen Wertebereich (z. B. «ganze Zahl») liegen. Bei untypisierten Sprachen (PHP, Java-
Script, ...) kann einer Variable jeder mögliche Wert der Programmiersprache zugewiesen werden.
Beispiel in Java:
int x ;
x = 7 + 5 * 33;
Java ist eine typisierte Sprache. Die Variablen müssen daher vor dem ersten Gebrauch deklariert
werden. Deklarieren heißt hier: Wir geben dem Programm an, um welchen Datentyp es sich bei
der Variable handelt. Jeder Variable liegt also ein Datentyp zugrunde. Dies ist vorteilhaft damit
die Programmierer nicht versehentlich falsche Werte in die Variable einfüllen.
In Java wird eine Variable deklariert, indem zunächst der Datentyp angegeben wird, und danach
folgt der Name der Variable.
Beispiele:
boolean eingabeKorrekt ;
int anzahlTreffer ;
double blutMengeInLitern ;
char steuerzeichen ;
String name ;
In Java können pro Deklaration mehrere Variable angegeben werden, und Variable können in
der Deklarationsanweisung auch einen Initialwert erhalten.
Beispiele:
int x, y, z;
double abstandInMetern = 4.88 ;

String name = " Meier " ;

1.5.1 Beispiel short vs. char
Die folgende Tabelle veranschaulicht den Zusammenhang von Variablen und ihren Datentypen:
Eine Variable kann man sich als Kiste vorstellen. In diese Kiste
werden die Werte der Variable gelegt. Die Variable hat einen
Datentypen. Wir können uns eine Variable als Fernsteuerung
für die Inhalte vorstellen.
In unserem Beispiel wird das Bitmuster «1100 1010» in die Va-

riable s (vom Datentypen short ) gespeichert. Die Variable
können wir nun addieren, subtrahieren, vergleichen etc. Als gan-
ze Zahl ( short ) hat diese Variable den Wert 202. Ich habe den
Datentypen short gewählt, weil er aus 16 Bit besteht. Dies
sind genau so viele Bit, wie auch in eine Variable vom Datenty-
pen char passen. Beachten Sie, dass unser Bitmuster nur 8 Bit
benötigt. Die vorangehenden 8 Bit werden von Java automa-
tisch mit Nullen «0000 0000» aufgefüllt.
Betrachten wir nun die Variable ch (vom Datentypen char ), so
kann dasselbe Bitmuster eine ganz andere Bedeutung haben. Wir
können nun die Variable prüfen ( istZiffer() , istVokal() ),
aber auch verändern (z. B. kleinBuchstabe() ). Als Unicode
Zeichen hat das Bitmuster «1100 1010» den Wert Ê.
25
1.5.2 Bezeichner (identifier)
Variable werden mit sogenannten Bezeichnern referenziert. Bezeichner (en. identifier) sind Namen.
Diese Namen sind beinahe beliebig, müssen sich in Java jedoch an folgende Regeln halten:
• Bezeichner dürfen keine reservierten Wörter sein, z. B. double , class oder while (s. Kap.
A.5 auf Seite 139).
• Bezeichner dürfen Buchstaben, Ziffern, Währungssymbole und den Unterstrich ( _ ) enthal-

ten.
• Bezeichner dürfen nicht mit einer Ziffer beginnen.
Gut sind Bezeichner wie: x , aktuelleZeit , width , TAUSEND . . .

Verwendbar, wenn auch unglücklich: $_1 , länge , . . .
Ungültig sind: 1x , const , s# , . . .
Aufgaben aus «Programmieren lernen» [GFG11]

Zu den folgenden Beispielen aus der Aufgabensammlung «Programmieren lernen» [GFG11] exis-
tieren Java-Lösungen auf http://www.programmieraufgaben.ch :
• 1. 2 Berechnung von Ausdrücken (1) (Web-Code: 8kqe-uout)
• 1. 3 Berechnung von Ausdrücken (2) (Web-Code: mupd-pv9h)

27
2 | Sequenzen (Anweisungen und Abfolgen)
Ein einfaches Computerprogramm besteht aus einer Abfolge (= Sequenz oder Aneinanderreihung)
von Anweisungen (Befehlen). Nach dem Starten des Programms wird die Sequenz in Leserichtung
(also der Reihe nach von oben nach unten) verarbeitet.
Selbst in objektorientierten Sprachen muss der Prozessor stets wissen, welches die nächste aus-
zuführende Aktion ist. Somit ist auch in Java der Kontrollfluss ein elementares Konzept. Der
Kontrollfluss wird in Java mittels Sequenzen, Selektionen, Schleifen, Methoden, Events, Excep-
tions und Multithreading gesteuert.
So viel aufs Mal? Beginnen wir mit einfachen Abfolgen, auch Abläufe oder Sequenzen genannt.
2.1 Abfolgen (Sequenzen)

Java-Anweisungen werden in Leserichtung aufgeschrieben. Erst wenn ein Befehl ganz fertig
ausgeführt ist, wird mit der nächsten Anweisung begonnen10 . Mit anderen Worten: Mit einer
Anweisung in einer Sequenz wird erst begonnen, wenn die vorangehende Anweisung komplett
abgeschlossen ist.
Gegenüberstellung Java zu UML11 :
{
eingabe ( " Alter " );
berechne_Jahrgang ();
ausgabe ( " Jahrgang " );
}
Semikolon
Die UML-Notation wurde bereits teilweise in [GFG11] verwendet und eine Zusammenfassung der
wichtigsten UML-Elemente findet sich im Anhang des PDF-Buches [Fre15]. Hier ein Beispiel einer
einzelnen Anweisung in Java. Jede Anweisung in Java wird mit einem Strichpunkt (Semikolon
; ) beendet:
System.out.println("Hallo Welt");
Bemerkung 2.1. Die Subroutine println() gibt bekanntlich einen Text auf der Konsole aus.
10
Typischerweise schreibt man pro Zeile eine Anweisung (= Befehl).
11
UML = Unified Modelling Language
29
2 Sequenzen (Anweisungen und Abfolgen)
2.2 Anweisungen
Die wichtigsten vier Arten von Anweisungen12 sind:
• Deklarieren von Variablen:
int x, y ;
char zeichen ;
String begruessung ;
• Zuweisen von Werten an Variable (s. Kap. 2.5 auf Seite 33):
– Zuweisen von Literalen (Konstanten):

x = 4;
– Zuweisen von zusammengesetzten Ausdrücken und Funktionsresultaten (z. B. Aufruf
mathematischer Funktionen):
begruessung = "Hallo" + "Welt";
y = x + 3 * Math.max(5, x);
– Einlesen von Text und Zahlen von der Tastatur:
Scanner sc = new Scanner ( System . in );

int x = sc . nextInt ();
– Hilfsfunktionen (Kalender, Ausgabeformat, ...):
Calendar cal = new GregorianCalendar () ;

int jahr = cal . get ( Calendar . YEAR ) ;
• Prozeduraufruf :
Ausgabe von Text und Zahlen auf die Konsole:
System.out.println("Hallo Welt");
Warten auf das Beenden eines anderen Prozesses:
threadXY.join();
Setzen von (System)eigenschaften:
setDate("2015-02-05");
• Kontrollflusssteuerung:
Selektion ( if / else ) (s. Kap. 3 auf Seite 37) und Iteration ( while / for ) (s. Kap. 4 auf
Seite 55).
12
Synonyme: Anweisung, Befehl, Statement

2.2.1 Weitere Anweisungen in Java
Neben den soeben erwähnten vier häufigsten Anweisungen der prozeduralen Programmierspra-
chen (Deklaration, Zuweisung, Prozeduraufruf, Kontrollflusssteuerung) gibt es in Java weitere
Anweisungen:
• Variableninkrement bzw. -dekrement (z. B. ++i; , x--; )
• Return Anweisung ( return; )
• Objekterzeugung (z. B. new JFrame(); )
• try - catch -Block
• throw -Anweisung
2.3 Deklarationen
Die standardmäßige Variablendeklaration in Java ist ein Datentyp gefolgt von einem Bezeichner,
welcher als Variablennamen dient:
int plz ;
String eingabe ;
double masse ;
Bemerkung 2.2. Durch Komma abgetrennt, können in Java pro Deklaration mehrere Variable
angegeben werden:
int plz , jahrgang ;
String vorname , familienname ;
2.3.1 Initialisierung
Bemerkung 2.3. Es ist gestattet, wie bereits im Kapitel über Variable erwähnt, Variable gleich
bei ihrer Deklaration zu definieren, also mit einem Initialwert zu versehen. Die beiden folgenden
Code-Blöcke sind identisch:
String begruessung ; // <- Deklaration
begruessung = " Hallo " ; // <- Definition
Abkürzend kann die Deklaration und die Definition in einem Schritt, der sog. Initialisierungs-
anweisung angegeben werden:
String begruessung = " Hallo " ;
31
2.4 Prozeduraufrufe
Bei einem Prozeduraufruf (z. B. println() )13 wird eine andere Stelle im Programm ausgeführt,
von wo nach beenden ebendieser Prozedur wieder an dieselbe Stelle im Ablauf zurückgekehrt
wird.
Neben bereits besprochenen vorgegebenen Subroutinen gibt es in JDK14 1.7 mehr als 7000 Modu-
le mit beinahe 40 000 Hilfsfunktionen. Zum Beispiel existieren dutzende von Kalenderfunktionen,
Funktionen für Zufallszahlen und trigonometrische Funktionen, Funktionen für die Computersi-
cherheit und fürs Verschlüsseln und Entpacken von Daten, Funktionen fürs Erstellen von graphi-
schen Benutzerschnittstellen, für den Zugriff aufs Internet und Datenbanken, für die Bearbeitung
und Formatierung von Text, Erstellen und Lesen von XML-Dateien, Behandeln von regulären
Ausdrücken, und und und.
13
Subroutinen sind: Prozeduren, Unterprogramme, Funktionen, Methoden (s. Kap. 5 auf Seite 65).
14
JDK = Java Developers Kit

2.5 Zuweisung
Die wohl am häufigsten eingesetzte Anweisung ist die Zuweisung. Variable erhalten ihre Werte
durch Zuweisung via Ausdruck.
Java-Beispiel:
x = 2010 + j;
Die Zuweisung wird mathematisch mit einem ’:=’ oder mit dem Sym-
bol. ’←’ geschrieben. In Java hingegen wird die Zuweisung durch ein
einfaches Gleichheitszeichen «=» dargestellt.
Bemerkung: Das einfache Gleichheitszeichen ist keine Gleichheit im mathematischen Sinne. Dabei
bedeutet x = 9*x + 3; keinesfalls, dass eine Gleichung in der Variable x zu lösen ist (Einige
Sprachen tun dies und x erhält den Wert -0.375)! In Java wird hier als erstes der Wert rechts
des Gleichheitszeichens berechnet und dieser Wert wird danach in die Variable gespeichert.
Beachten Sie den folgenden Code:

a = 4;
b = a;
a = 5;
Zuerst erhält a den Wert 4. Danach erhält b den Wert 4, also den
Wert der Variable a . Zuletzt wird a auf 5 gesetzt. Beachten Sie, dass
b immer noch den Wert 4 hat, auch wenn die Variable a und b ver-
meintlich gleich gesetzt wurden. Merke: Die Java Zuweisung bedeutet
«Variable wird zu Wert» und nicht «Variable wird zu Ausdruck».
Zur Ein- und Ausgabe von Werten über die Tastatur siehe Anhang A.6 über die Ein- und Ausgabe
auf Seite 140.
33

• 2. 1 Hello World (Web-Code: hr5f-yysf)
• 2. 3 Variablenwert nach einer Sequenz (Web-Code: pi2t-72oe)
• 2. 4 Ohm’sche Gesetze (Web-Code: po9n-fjn6)
• Satz von Pick (Web-Code: hpaj-dw3x)
• 2. 5 Abbildungsgleichung (Web-Code: 2v7c-bobb)
• Eisenwarenhändler (Web-Code: ranc-fuh0)
• 2. 6 Runden (1) (Web-Code: gs4u-sre7)
• Noten Runden (Web-Code: u3kp-4ffh)
• 2. 7 Runden (2) «schwierig» (Web-Code: z296-j92g)
• 2. 8 Stunden, Minuten, Sekunden (Web-Code: deeb-acqv)
• 2. 9 Ganzzahlarithmetik (Kommutativgesetz) (Web-Code: rdhf-4kvg)
• 2.10 Gleitkommaarithmetik (Assoziativgesetz) (Web-Code: kwhz-einv)
• Quadratische Gleichung (Web-Code: dk4s-3aeg)
• Zubringerbus (Web-Code: uzib-jyek)
• Hitzeindex (Web-Code: w680-nfkr)
• Truhen aus Plexiglas (Web-Code: kimn-4b4h)
• Tausche (Web-Code: ecu8-pdg7)
Aufgabe 2.1 « int » Hier noch eine kleine Übung zu den Java-Datentypen. Programmieren
Sie die folgende Sequenz und erklären Sie das Ergebnis:
int x ;
x = 2 _147_483_647 ;
x = x + 1 ;
System . out . println ( " x : ␣ " + x );

35
3 | Selektion (Verzweigung)
3.1 Einführungsbeispiel
Ein Stück Code (hier Schneeketten) soll nur unter gewissen Umständen ausgeführt werden:
int temperatur ;
temperatur = new Scanner ( System . in ). nextInt ();
System . out . println ( " Einsteigen ␣ und ␣ anschnallen ! " );
if ( temperatur < -10)
{
System . out . println ( " Schneeketten ␣ obligatorisch ! " );
}
System . out . println ( " Losfahren ! " );
3.1.1 Die allgemeine if -Anweisung
Neben der sequenziellen Ausführung von Anweisungen ist die Selektion15 ein elementares Kon-
zept der Programmierung. Eine Selektion steuert den Verlauf eines Programms. Bestimmte Teil-
sequenzen werden nur unter einer gegebenen Bedingung ausgeführt.
Die Selektion wird in Java durch das Schlüsselwort if eingeleitet. So wird in folgendem Beispiel
die 2. Sequenz ( sequenz2() ) nur ausgeführt, wenn die Bedingung ( bedingung ) wahr ist. Die
sequenz1() am Anfang und die sequenz3() am Schluss werden jedoch immer ausgeführt.
sequenz1 ();
if ( bedingung )
{
sequenz2 ();
}
sequenz3 ();
Der Bedingungsblock (hier sequenz2() ) wird in Java mit geschweiften Klammern ( { , } )

eingeschlossen.
15
Selektion wird auch Verzweigung, Entscheidung oder Auswahl genannt.
37
3 Selektion (Verzweigung)
3.1.2 Syntax
Die generelle Syntax der Selektion in Java lautet:

if ( < BEDINGUNG >) < BLOCK >
[ else < BLOCK > ]
Dabei bezeichnet der <BLOCK> eine Sequenz mit beliebig vielen Anweisungen. Ein Block sollte
in Java immer in geschweifte Klammern (« { »,« } ») gestellt werden.
Der else -Teil ist optional (daher habe ich ihn in eckige Klammern gestellt; diese eckigen Klam-
mern sind in Java natürlich nicht einzugeben).
3.2 Boole’sche Ausdrücke

Die Bedingungen werden durch Wahrheitsausdrücke (Boole’sche Ausdrücke) angegeben. Solche
Ausdrücke erhalten beim Auswerten entweder true oder false .
Boole’sche Ausdrücke kennen ebenfalls die vier bereits behandelten Typen (s. Kap. 1.1.1 auf Seite
18):
• Literale: true und false
• Variable: boolean ok; ok = true; if(ok) { ... }
• Funktionsresultat: if(eingabeKorrekt()) { ... }
• Zusammensetzungen: (4 < x) && !(x >= 6)

3.3 Das Bit
Die wohl einfachste aber in meinen Augen auch überwältigendste Datenstruktur ist das Bit (binary
digit). Mit einem Bit kann einer von zwei binären Zuständen dargestellt werden.
Andere Wörter bzw. Vorsilben für binär sind: Zwei, Duo, dual, Boole’sch, stereo, sekund-, doppel-,
zwie-, bi-, di-, . . . 16
Physikalisch wird dieser Zustand verschieden dargestellt:
Zustand 1 Zustand 2 Datenträger
Finger gebogen Finger gestreckt Hand beim digitalen Zählen (lat. digitus=Finger;
digitalis = zum Finger gehörig)
Magnetischer Nordpol Magnetischer Bei Disketten, Harddisks, Magnetbändern, . . .
Südpol
Kein Strom (z. B. < Strom (z. B. >3 Datenübertragung zwischen Komponenten (Bus)
0.5 Volt) Volt) des PCs
Papier Loch Lochstreifen
Keine Ladung Ladung Flipflops (Transistoren) im Speicher (RAM),
MOSFET, Flash, Relais, ...
Reflexion des Lasers Streuung des La- CD-ROM, DVD, Blu-ray
sers
tiefer Ton hoher Ton Akustikkoppler / Modem
Diode ist dunkel Diode leuchtet Statusanzeige für Harddisk Aktivität / Feststell-
taste, Batteriestatus, . . .
... ... ...
Ein Bit kann in der realen Welt nun die verschiedensten Bedeutungen haben:
Zustand 1 Zustand 2 Bedeutung
Falsch (false) Wahr (true) In verschiedenstem Kontext
Nein Ja Wahrheitswert auf eine Aussage
0 1 als Zahlen
nicht archiviert archiviert als sog. Flag (Markierung) einer Datenstruktur
Rot Grün bei einer Signalsteuerung
Geschlossen Offen Bei Barrieren / Türen / . . .
Schwarz Weiß Als Figurenfarbe im Go-Spiel
Feststelltaste nicht ak- Feststelltaste Diodenanzeige «CAPS-LOCK»
tiv eingeschaltet
... ... ...
16
Zürich unterscheidet darüberhinaus die Geschlechter im Wort “Zwei”: “zwoo Fraue”, “zwee Mane”, “zwei
Chinde”
39
3.3.1 Beispiele zu Boolean
boolean offen ; // false = geschlossen

boolean archiviert ; // false = nicht archiviert
boolean weiss_am_Zug ; // false = schwarz_am_Zug
boolean one ; // false = zero ( Eins und Null )
Das Bit kann aber nicht nur Gegenteile darstellen. Nehmen wir zur Verdeutlichung ein Trinkglas.
Sein Zustand kann auf zwei Arten modelliert werden, und es ist wichtig, dass wir die beiden Fälle
Unterscheiden:
Variante 1:
boolean voll ; // false = leer
Variante 2:
boolean voll ; // false = nicht voll
Im ersten Fall kann ich mich auf den Standpunkt stellen: Ein Trinkglas, das noch etwas darin
hat, ist voll. Ein solches Glas darf z. B. vom Kellner noch nicht abgeräumt werden.
Im zweiten Fall interessiert mich wohl eher, ob ein Glas ganz voll ist. ¾-voll wäre in diesem Umfeld
eben nicht mehr voll. Mit anderen Worten: Das Gegenteil von «voll» ist eben nicht immer ganz
«leer»; sicher aber immer «nicht voll»!
Es ist auf dieser Ebene die Aufgabe von uns Programmierern die reale Welt sinnvoll abzubilden.
Wir müssen abklären, ob «nicht voll» gleich «leer» ist, ob «nicht rot» gleich «grün» ist etc.
3.3.2 Vergleichsoperatoren
Vergleichsoperatoren vergleichen numerische Werte miteinander und liefern als Resultat entweder
true (bei Zutreffen) oder false (bei Nicht-Übereinstimmung).
Operator in Java Bedeutung
< < ist kleiner als
≤ <= kleiner oder gleich
> > ist größer als
≥ >= größer oder gleich
= == identisch, gleich
6= != ungleich

3.3.3 Logische Operatoren
Logische Operatoren werden benötigt, um logische Ausdrücke (z. B. Vergleiche) miteinander zu

kombinieren.
Die wichtigsten logischen Operatoren sind:
Operator C/Java - Symbol Beschreibung
= == Gleichheit
6= != Verschiedenheit
AND & , && Und
OR | , || inklusives, mathematisches Oder
NOT ! Verneinung, Umkehrung, Negation
XOR ˆ exklusives Oder
Die Operatoren && und || sind im mathematischen Kontext zu verstehen. && heißt, dass beide
Operanden links und rechts wahr sein müssen, damit der Gesamtausdruck wahr wird; wohingegen
bei || verstanden wird, dass mindestens einer der beiden Operatoren wahr sein muss. Sprachlich
ist dies je nach Formulierung aber genau umgekehrt und manchmal wollen wir nur ein exklusives
Oder, was in Java mit ˆ bewerkstelligt wird.
Hier ein Beispiel, bei dem in der Umgangssprache ein && oder ein || steht, je nach der Satz-
stellung:
Ein «Kind» ist ein Mädchen oder ein Junge.
Mädchen und Jungen sind somit beides Kinder.17
Bemerkung 3.1. «Abkürzungsoperatoren»

Im vorigen Kapitel habe ich erwähnt, dass für AND && oder & geschrieben werden kann. Analog
gilt dies für OR.
Verwenden wir den Doppeloperator ( && , || ) anstelle der einfachen Operatoren ( & , | ), so
verwenden die C-Sprachen (und dazu gehört auch Java) eine Abkürzung. Falls nämlich beim
Betrachten des linken Operanden das Resultat schon klar ist, wird der rechte Operand gar nicht
mehr ausgewertet, was oft auch einen Zeitgewinn (Performance) bringt. Ist nämlich beim &&
der linke Operand false , so ist der Gesamtausdruck auch false und zwar unabhängig vom
rechten Operanden (Analog bei || ).
Nichts verstanden? Da es in den allermeisten Fällen keine Rolle spielt, ob sie & oder && als
logischen Operator verwenden, gewöhnen Sie sich lieber gleich den Doppeloperator && an.
17
Das Beispiel ist aus [Knu97] und dort in englisch formuliert; es zeigt aber, dass es in deutsch genau dieselben
sprachlichen Unklarheiten gibt.
41
3.3.4 Zusammensetzen von Vergleichen mit logischen Operatoren
In der Praxis werden Vergleichsoperatoren ( <= , > , ...) oft mit logischen Operatoren ( && , ˆ ,
...) verknüpft. Ein klassisches Beispiel ist die Eingrenzung eines Zeichens (z. B. Buchstabe oder
Ziffer) in untere und obere Schranken:
if (( ’a ’ <= ch ) && ( ch <= ’z ’ ))
{
System . out . println ( " Kleinbuchstabe " );
}

Weitere Beispiele
• if(isOK) {...}
• if((! eingabeKorrekt) || eingabeLeer) {...}
• if((alter < 19) && inAusbildung) {...}
In obigem Beispiel sind isOK , eingabeKorrekt , eingabeLeer und inAusbildung Variable

vom Datentyp boolean . Die Variable alter hingegen ist eine ganze Zahl ( byte , short , int
oder long ).
Weitere Beispiele in den Aufgaben am Ende des Kapitels.
3.3.5 De Morgan’sche Regeln
Oftmals ist es einfacher in einem AND, statt in einem OR zu denken. Gerade, wenn eine Bedingung
verneint werden soll.
So gelten die beiden folgenden De Morganschen Regeln18 :
! ( a & b ) == (! a ) | (! b )
! ( a | b ) == (! a ) & (! b )
Beachten Sie die Vertauschung von & und | bei der Verneinung.
18
Die beiden Regeln werden nach Augustus De Morgan (1806-1871) benannt, obschon diese bereits vor dessen
Lebzeiten bekannt waren.
43
3.4 else
Alternativ auszuführender Code kann meist mit der folgenden Erweiterung der if -Struktur
erreicht werden. Ein else bezeichnet einen Block, der genau dann ausgeführt werden soll, wenn
die if -Bedingung falsch ist. Wir können somit zwei alternative Code-Blöcke schreiben, ohne die
Bedingung explizit zu verneinen.
sequenz1 ();
if ( bedingung )
{
sequenz2A ();
}
else
{
sequenz2B ();
}
sequenz3 ();
Bemerkung: In Java darf die geschweifte Klammerung (im if - sowie im else -Teil) unter
gewissen Umständen weggelassen werden. Mehr dazu im Anhang (s. Kap. A.7 auf Seite 146).

3.5 Mehrfachselektion
Führen bei einer Auswahl mehrere Entscheidungen in verschiedene Wege, so kann mit der folgen-
den Mehrfachselektion entschieden werden, welcher Code denn nun ausgeführt werden soll:
if ( bedingung1 )
{
< BLOCK 1 >
}
else if ( bedingung2 )
{
< BLOCK 2 >
}
else if ( bedingung3 )
{
< BLOCK 3 >
}
else
{
< STANDARD - BLOCK >
}
Dabei wird <BLOCK 1> genau dann ausgeführt, wenn die bedingung1 wahr ist, <BLOCK 2>
genau dann, wenn bedingung1 falsch war, jedoch bedingung2 stimmt etc. Der letzte Block
( <STANDARD-BLOCK> ) wird dann ausgeführt, wenn keine der Bedingungen zutrifft.
45
3.5.1 switch
Eine Code-Auswahl aufgrund eines Variablen-Wertes kann mit der switch() -Anweisung verein-
facht werden.
Beispiel:
int note ; /* Leistungsbeurteilung */
...
switch ( note )
{
case 1:
print ( " sehr ␣ schwach " );
break ;
case 2:
print ( " schwach " );
break ;
case 3:
print ( " ungenuegend " );
break ;
case 4:
print ( " genuegend " );
break ;
case 5:
print ( " gut " );
break ;
case 6:
print ( " sehr ␣ gut " );
break ;
default :
print ( " unbekannte ␣ Note " + note );
}
Beachten Sie die break -Anweisung. Diese verlässt den switch -Block augenblicklich. Eine gän-
gige Fehlerquelle ist es, diese break -Anweisung zu vergessen.
Die letzte case -Marke19 wird hier von einer default -Marke gefolgt. Hier werden alle Fälle
behandelt, zu denen es kein explizites case gibt.
19
Sprungmarken werden oft auch Labels genannt.

Gefährliche Abkürzungen
Einige trickreiche Programmierer machen sich das Weglassen der break -Anweisung zu Nutze um
weniger Code schreiben zu müssen. Wird, wie im folgenden Programm, die break -Anweisung
weggelassen, (wie hier im Fall 1, 3 und 6), so wird einfach beim nächsten case -Block weiterge-
fahren.
int note ; /* Leistungsbeurteilung */
...
switch ( note )
{
case 1:
print ( " sehr ␣ " ); /* falls through */
case 2:
print ( " schwach " );
break ;
case 3:
print ( " un " ); /* falls through */
case 4:
print ( " genuegend " );
break ;
case 6:
print ( " sehr ␣ " ); /* falls through */
case 5:
print ( " gut " );
break ;
default :
print ( " unbekannte ␣ Note " + note );
}
Dies mag auf den ersten Blick verwirren, auf den zweiten Blick genial erscheinen. Beachten Sie
jedoch, dass dieser Code aus mehreren Gründen gefährlich ist: Das Programm später abzuän-
dern, ist heikel, denn es können dabei diverse Fälle in Vergessenheit geraten. Eine Übersetzung
in die meisten Sprachen ist hier gar unmöglich. Ich rate allen davon ab, nicht derart abartigen
Programmcode zu produzieren.
Geek Tipp 2
Schreiben Sie Ihren Code in erster Linie ohne gefährliche Tricks!
47
3.6 Gebrochene Zahlen

3.6.1 Vergleiche mit Dezimalbrüchen
Vergleichen Sie gebrochene Zahlen nie auf ihre Identität (in Java also nie mit "==" ). Denn
zwei Zahlen können unter Umständen dasselbe Resultat bedeuten, sich durch Rundungsfehler
aber auf den letzten Binärstellen unterscheiden. Fragen Sie sich beim Vergleich immer, wie genau
sollen die beiden Zahlen beieinander liegen? Normalerweise sucht man sich eine sehr kleine Zahl
(z. B. epsilon = 0.00001 )20 und schaut, ob sich die beiden ursprünglichen Zahlen um maximal
diese kleine Zahl unterscheiden. Ist der Unterschied kleiner als dieses Epsilon, so kann davon
ausgegangen werden, dass die Zahlen dieselben Resultate bedeuten:
Wie werden die beiden double Zahlen zahl_1 und zahl_2 nun miteinander verglichen? Etwa
so?
if ( zahl_1 == zahl_2 )
{
// beide Zahlen sind gleichwertig ???
...
Nein, bitte nicht. Streichen Sie obigen Block rot durch. Ein Vergleich von reellen Zahlen sollte
Rundungsfehler auf den letzten Stellen berücksichtigen. So ist’s
BRAV21 :
double epsilon = Math . max ( zahl_1 , zahl_2 ) * 0.00001;
double differenz = Math . abs ( zahl_1 - zahl_2 ) ;
if ( differenz < epsilon )
{
// beide Zahlen sind gleichwertig
...
3.6.2 Prüfe auf Ganzzahligkeit
Wie auch bei Vergleichen mit gebrochenen Zahlen kann in der Regel von einer Variable nicht
einfach gesagt werden, ob diese eine ganze Zahl darstellen soll. Rundungsfehler auf den letzten
Binärziffern machen uns das Leben schwer. Wir können jedoch wieder eine Genauigkeit angeben,
um damit auf Rundungsfehler zu prüfen. Verwenden Sie die folgende Funktion, um eine gebrochene
Variable mit großer Wahrscheinlichkeit auf Ganzzahligkeit zu prüfen:
double bruch = ... ;
double epsilon = 0.00001;
if ( Math . abs ( bruch - Math . round ( bruch )) < epsilon )
{
... // Der bruch ist wohl ganzzahlig
20
Der Variablenname epsilon geht hier auf die sog. Epsilontik zurück, welche mit beliebig kleinen positiven
Zahlen arbeitet.
21
BRAV = Brüche rücksichtsvoll mit Abstandsfunktion vergleichen.

3.7 Funktionale Gebundenheit Boole’scher Ausdrücke
Boole’sche Ausdrücke sind Ausdrücke, wie andere auch. Sie liefern jedoch als Resultat immer nur
entweder wahr ( true ) oder falsch ( false ). Mit diesem Wissen können wir sofort verstehen,
warum die beiden nachfolgenden Codestücke äquivalent sind. Der erste Code ist a) schlechter zu
lesen, b) fehleranfälliger und somit c) schlechter wartbar. Immer Köpfchen einschalten und mit
LOGIK22 arbeiten:
Erst ohne LOGIK:
boolean bedingung = ...;
if ( bedingung )
{
doSomething ( true );
}
else
{
doSomething ( false );
}
Und nun das selbe mit LOGIK:

boolean bedingung = ...;
doSomething ( bedingung );
Betrachten Sie auch die folgende Grafik: Die obere if/else -Variante ist absolut identisch mit
dem unteren direkten Aufruf (Dabei handelt es sich beim blauen Ausdruck um irgendeinen Boo-
le’schen Ausdruck und bei der roten Teilanweisung um einen beliebigen Code-Ausschnitt):
22
LOGIK = Löse offensichtliche Gebundenheit im Kontext.
49
Beispiel Dazu gleich noch ein klassisches, immer wieder auftauchendes Beispiel aus der Praxis.
Dabei geht es um eine Maske, bei der sich der Benutzer anmelden kann. Es hat zwei Textfelder.
Im ersten Feld username kann der Benutzer seinen Namen ein-
geben und im zweiten Feld passwd kann er sein Passwort ein-
tippen. Darunter sind zwei Knöpfe (Buttons). Der erste (reset)
ist dazu da, die Felder zurückzusetzen; mit anderen Worten, den
Inhalt der Textfelder wieder zu löschen. Der zweite Knopf, der
login-Button, wird gedrückt, um sich am System anzumelden.
Dabei ist der reset-Button immer aktiv, wenn mindestens eines
der beiden Felder einen Text enthält; der login-Button hingegen
ist nur dann aktiv, wenn beide Felder Text enthalten. Betrachten
Sie nun die folgenden beiden Codestücke (zunächst wieder ohne
LOGIK):
// username UND passwort eingetragen :
if ( filled ( username ) && filled ( passwd ))
{
reset . setEnabled ( true );
login . setEnabled ( true );
}
// nur passwort leer gelassen :
if ( filled ( username ) && ! filled ( passwd ))
{
login . setEnabled ( false );
}
// nur username leer :
if ( ! filled ( username ) && filled ( passwd ))
{
}
// beide Felder leer :
if ( ! filled ( username ) && ! filled ( passwd ))
{
reset . setEnabled ( false );
}
Doch nun besser (Streichen Sie obigen Code bitte rot durch!), diesmal mit LOGIK. Ist dieser
Code nicht DUFTE23 ?
// mind . ein Feld ist eingetragen ( ODER ):
reset . setEnabled ( filled ( username ) || filled ( passwd ) );
// beide Felder sind eingetragen ( UND )
login . setEnabled ( filled ( username ) && filled ( passwd ) );
23
DUFTE = Direkt Unverändert False/True-Werte eingesetzt.

3.8 Selektionsinvariante
Betrachten wir folgenden Code, so fällt auf, dass einige Aufrufe doppelt vorkommen:
if ( A )
{
f ();
x ();
g ();
}
else
{
f ();
y ();
g ();
}
Der Code kann kürzer und effektiver wie folgt geschrieben werden, denn f() und g() sind
unabhängig (also invariant) im Bezug auf die die Selektion ( if ); dies nenne ich «selektionsinva-
riant».
Betrachten und diskutieren Sie nun den korrigierten Code:
f (); // pre - Code
if ( A )
{
x ();
}
else
{
y ();
}
g (); // post - Code
3.9 int , diesmal Bitweise
Eine spannende Möglichkeit, jedes Bit innerhalb eines int -Wertes als Wahrheitswert anzusehen
ist die Bit-Maskierung (s. Kap. A.16 auf Seite 162).
51
3.10 Aufgaben
Aufgabe: Die richtige Wahl

Welches ist die richtige Wahl, wenn es darum geht, einen Wahrheitswert abzufragen. Im Beispiel
wollen wir nur tränken, wenn das Kamel durstig ist. Dazu gebe es eine Variable durstig vom
Datentyp boolean (Wahrheitswert). Betrachten Sie den folgenden Code:
boolean durstig ;
durstig = ...;
/* A */ if ( durstig && true ) { traenken (); }
/* B */ if ( true && durstig ) { traenken (); }
/* C */ if ( durstig = true ) { traenken (); }
/* D */ if ( true = durstig ) { traenken (); }
/* E */ if ( durstig == true ) { traenken (); }
/* F */ if ( true == durstig ) { traenken (); }
/* G */ if ( durstig ) { traenken (); }
/* H */ if ( false != durstig ) { traenken (); }
Beantworten Sie die drei folgenden Fragen:
• Welche der obigen Abfragen können kompiliert werden?
• Welche der obigen Abfragen (die kompilieren) erfüllen die geforderte Bedingung?
• Welche Abfrage ist die beste? (Nur eine Wahl!)
Lösung im Anhang (s. Kap. B auf Seite 191).

• 3. 1 If-Formulierungen (Web-Code: gxi7-afay)
• 3. 2 Boolesche Ausdrücke (Web-Code: tby9-5gzh)
• 3. 4 Selektionsinvariante (Web-Code: 3t94-v5nz)
• 3. 5 Bedingte Zuweisung (Web-Code: 2ib4-q6ax)
• 3. 6 AHV (Web-Code: yo4o-3stj)
• 3. 7 Body-Mass-Index (Web-Code: 4du5-ufpz)
• 3. 8 Hundert Binärzahlen (Web-Code: an5r-qqzp)
• 3. 9 Kilobyte (Web-Code: nk4t-g9hc)
• 3.10 Elektrische Spannung (Web-Code: 43b5-76us)
• Ausflugsplanung (Web-Code: 54d5-o0ns)
• Schneidbretter (Web-Code: a8nn-9r92)
• Alter aus zweistelligem Jahrgang und Jahr (Web-Code: 694e-e26d)
• Tischdecken (Tischtücher) (Web-Code: tzf7-vh3p)
• Windrichtung bestimmen (Web-Code: ibbn-2e7d)
• Differenz (Web-Code: q225-nepr)
53
4 | Schleifen
Eines der wesentlichen Konzepte der Programmierung überhaupt ist die Möglichkeit ein Stück
Code beliebig oft ausführen zu lassen. In der Maschinensprache wird dies mit einem sog. Sprung
(Jump) an eine vorangehende Programmzeile gelöst. In Java wird dies generell durch eine
while -Schleife (manchmal auch durch eine for -Schleife24 ) vollzogen.
Wir hatten mit der Selektion (s. Kap. 3 auf Seite 37) ein Verfahren kennengelernt, bei dem ein
Stück Programmcode nur bei Eintreffen einer gegebenen Bedingung ausgeführt wird. Man könnte
dies als bedingten Sprung nach vorn auffassen, bei dem ein Stück Code eventuell ausgelassen
wird. Analog gibt es den «Sprung zurück», mit dem sich abbrechende oder nicht abbrechende
Schleifen erzeugen lassen.
Für eine Wiederholung steht in Java i. d. R. das Schlüsselwort while . In folgendem Beispiel
wird die 2. Sequenz ( sequenz2() ) so lange ausgeführt, wie die Bedingung ( bedingung ) wahr
ist.
Wieder gilt: Die sequenz1() wird immer ausgeführt. Die sequenz3() hingegen erst, wenn die
Bedingung nicht mehr erfüllt ist.
sequenz1 ();
while ( bedingung )
{
sequenz2 ();
}
sequenz3 ();
Die Bedingung steuert also Häufigkeit des Durchlaufs bzw. den Abbruch. Die bedingung ist ein
boolescher Ausdruck (der als Resultat true oder false aufweist). Einige Sprachen erlauben
auch Zahlen und werten diese verschieden aus. Die Programmiersprache «C» z. B. kann als Be-
dingung eine ganze Zahl entgegennehmen und führt die Anweisungen nur dann aus, wenn die
Zahl nicht Null (0) ist; Null bedeutet also «falsch», alles andere bedeutet «wahr». Nur wenn die
Bedingung wahr ( true in Java) ist, so werden die Anweisungen ausgeführt. Beim Teil, der mit
sequenz2() gekennzeichnet ist, kann es sich um beliebig viele Anweisungen handeln (also auch
keine oder eine).
24
Schleifen werden in der Schweizer Mundart oft auch Schlaufen genannt, was den Vorteil hat, es nicht mit einer
Schleifmaschine oder einer Rutschbahn zu verwechseln ;-)
55
4 Schleifen
Die Schleife ist in allen Programmiersprachen der 3. Generation25 vorhanden. Die while() -
Schleife ist die grundlegendste Ablaufsteuerung in Java. Alle anderen ( if , do , for ; ja sogar
switch und break , . . . ) ließen sich damit simulieren.
25
Java ist eine objektorientierte Programmiersprache der 3. Generation. Höhere Generationen (wie z. B. Pro-
log oder SQL) verwenden Schleifen zur Lösungsfindung implizit, also ohne, dass sich der Programmierer darum
kümmern müsste.

4.1 Anwendungen
Der wahre Geek versucht, die stumpfsinnigste Arbeit am PC zu minimieren[Him01]. Dazu gehört
vor allem die Tipparbeit. Wenn wir ein Stück Code wieder benötigen, so sollten wir es unter
keinen Umständen abtippen. Jede Tipparbeit ist fehleranfällig. Jedoch ist natürlich auch das
Kopieren bösartig. Mit hintereinander kopieren kann nicht erreicht werden, dass eine Sequenz
beliebig oft abgespielt wird. Wenn ich als Programmierer von vornherein nicht weiß, wie oft ein
Code durchlaufen werden wird, so bin ich mit dem Kopieren von Code sowieso auf dem Holzweg.
Wozu werden nun Schleifen in der Praxis eingesetzt?
• Zählen und Summen bilden
• Suchen
• Anwenden einer Operation auf alle Elemente einer Datensammlung
• mehrere Eingabezeilen (ab User-Input, Files oder Netzwerk) lesen und verarbeiten
• Endlosschleifen (z. B. Simulatoren oder das Betriebssystem selbst.)
Geek Tipp 3
Wir tippen nichts zweimal. Wir kopieren niemals Code innerhalb eines Projektes!
Kopierter Code ist böse: Er verbreitet Mühsal, Verderbnis und Tod!
4.2 Syntax
Die generelle Syntax der Java- while() -Schleife lautet:

while ( < BEDINGUNG >)
< BLOCK >
Dabei ist die <BEDINGUNG> ein boolescher Ausdruck. Der <BLOCK> beinhaltet wie bei der
Selektion ( if ) beliebig viele in geschweiften Klammern eingeschlossene Anweisungen.
Ebenso existiert in Java eine Fuß-gesteuerte Schleife, die in der Praxis aber selten Anwendung
findet:
do
< BLOCK >
while ( < BEDINGUNG > );
Diese Bedingung muss genau gleich wie bei der kopfgesteuerten while() -Schleife den Wert
false aufweisen um den Zyklus zu durchbrechen. Es handelt sich also nicht um eine Ab-
bruchbedingung sondern auch um eine Wiedereinstiegsbedingung.
57
4 Schleifen
4.2.1 Beispiel
Hier das Zinseszinsbeispiel aus dem Buch [GFG11] Seite 45; diesmal in Java:
int anzahljahre = 5;
int jahr = 0;
double kapital = startkapital ;
while ( jahr < anzahljahre )

{
zins = kapital * zinssatz / 100;
kapital = kapital + zins ;
jahr = jahr + 1 ;
}
endkapital = kapital ;
Beachten Sie, dass eine Division ein Risiko mit sich bringt. Sind beide Zahlen ganzzahlig (wie z. B.
7/3 ), so wird in Java eine ganzzahlige Division durchgeführt: 7 / 3 = 2 . Soll ein Dezimal-
bruch errechnet werden, so ist der Dividend oder der Divisor auch als Dezimalbruch anzugeben:
7.0 / 3 = 7 / 3.0 = 2.333...

4.3 Zählervariable
Sehr oft wird in einer Schleife ein Zähler benötigt, um den Abbruch steuern zu können (wie jahr
im Beispiel «Zinseszins» auf Seite 58).26
Meist wird dazu eine ganze Zahl verwendet; welche in einer sog. Zählervariable (im Folgenden
int i ) gespeichert wird:
int i = 0;
while ( i < 20)
{
...
i = i + 1;
}
Weil solche Zähler-Schleifen so häufig sind, benutzt Java hier die Konstruktion aus der Pro-
grammiersprache C:
for ( int i = 0; i < 20; i = i + 1)

{
...
}
Bemerkung: Anstelle von i = i + 1; wird abkürzend meist i++; verwendet (s. Kap. 2.2.1 auf
Seite 31).
Aber Achtung: Verwenden Sie den ++ -Operator entweder nur in die-
sem Zusammenhang, oder aber erst dann, wenn Sie ihn vollständig ver-
standen haben, denn i++ ist eine Anweisung und gleichzeitig ein Aus-
druck mit dem Nebeneffekt, den Wert der Variable zu erhöhen. Probieren
Sie einmal folgendes aus, staunen Sie und lernen Sie daraus:
int i = 5;
i = i ++;
System . out . println ( " Neues ␣ i : ␣ " + i );
Lösung: Als Anweisungen sind i++; und i = i+1; zwar iden-

tisch. Genau genommen bezeichnet i++ als Ausdruck jedoch
((i = i + 1) - 1) , was in obigem Beispiel dem i wieder den alten
Wert – nämlich 5 – zuweist.
26
Natürlich kann die Abbruchbedingung auch ganz anders definiert sein: Ziel erreicht, Maximum überschritten,
Benutzereingabe, Spielende, ...
59
4 Schleifen
Geek Tipp 4
Abkürzungen in Programmiersprachen sind für Fortgeschrittene. Verwenden Sie solche erst, wenn
Sie sie vollständig verstanden haben und sicher gehen, dass auch niemals Anfänger Ihren Code
jemals warten (also verstehen) müssen. Mit anderen Worten: Verzichten Sie so oft als möglich auf
Abkürzungen.

4.3.1 Die for -Schleife
Die allgemeine Syntax der for -Schleife ist links gegeben und entspricht 1:1 der while -Schleife
rechts:
for while
< INIT >

for ( < INIT >; < BEDINGUNG >; < NEXT >) while ( < BEDINGUNG >)
{
< BLOCK > < BLOCK >
< NEXT >;
}
Gleich ein Beispiel (hier werden die ersten zehn Quadratzahlen berechnet und ausgegeben):
Mit for Mit while
int i = 1;
for ( int i = 1; i <= 10; i = i + 1) while ( i <= 10)
{ {
System . out . println ( i + System . out . println ( i +
" : ␣ " + ( i * i )); " : ␣ " + ( i * i ));
i = i + 1;
} }
61
4 Schleifen
4.4 Sichtbarkeit (Scope)

In früheren Programmiersprachen waren Variable meist global. Das hat dazu geführt, dass die
Programmierer ständig aufpassen mussten, dass Sie den Variablen Namen gaben, die im ganzen
Projekt eindeutig waren. Moderne Sprachen verwenden eine Variable nur gerade in ihrem unmit-
telbaren Kontext (Modul oder Funktion). Die Sichtbarkeit von Variablen geht aber meist noch
etwas weiter. So sind in Java Variable nur innerhalb des Blocks (normalerweise zwischen auf-
und zugehender geschweifter Klammer) sichtbar.
Beispiel:
1. int a = 2; // ueberall im folgenden sichtbar
2. while ( a < 4)
3. {
4. int b = 6; // sichtbar bis zur Zeile 12
5. b = b - a;
6. a = a + 1;
7. if (5 == a ) {
8. int x = 6; // a , b und x sichtbar
9. x = x - b;
10. } // ab hier ist x nicht mehr sichtbar
11. a = a + 1;
12. } // nur noch a sichtbar ab hier .
13. a = 10;
Bemerkung 4.1. Weitere Spezialitäten von Java-Schleifen finden sich im Anhang (s. Kap. A.8
auf Seite 147).

• 4. 1 Iterationen (Web-Code: vrft-w7zr)

• 4. 2 Hundert Quadratzahlen (Web-Code: rnuy-razx)
• 4. 3 Kleines Einmaleins (Web-Code: 86my-ifu5)
• 4. 4 Fahrenheit (Web-Code: kcyy-2mt8)
• 4. 5 Domino (Web-Code: 3ika-8b3t)
• 4. 6 Wertetabelle (Web-Code: smw6-u9sy)
• 4. 8 Selektion vermeiden (Web-Code: c75n-hpo8)
• 4.10 Zahlensumme (1) (Web-Code: 3uy9-4fbo)
• 4.11 Multiplikation (Web-Code: a82k-ofbb)
• 4.12 Fakultäten (Web-Code: neh4-hqjt)
• 4.13 Zahlensumme (2) (Web-Code: 8thj-ygxd)
• 4.16 Mondlandung (Web-Code: y4qj-nv2g)
• 4.17 Bienenflug (Web-Code: jgjj-c8uv)
• 4.18 Das Buch der Weissagungen (Web-Code: 95ew-4rif)
• 4.19 Parallelschaltung Ohm’scher Widerstände (Web-Code: eisv-86s7)
• 4.20 Anzahl Ziffern (Web-Code: qgf8-hnro)
• 4.21 Ziffernfolge umdrehen (Web-Code: 6s3s-xoyx)
• 4.22 FizzBuzz (1) (Web-Code: pf6d-wqtr)
• 4.23 FizzBuzz (2) (Web-Code: 8sax-at2x)
• 4.24 Waage (Web-Code: d57z-se4g)
• Anstoßende Partygäste (Web-Code: b2jr-q8pb)
• Anna lernt lesen (Web-Code: oukh-6gbt)
• Der faule Lehrer (Web-Code: 5t2t-ux7e)
• Ablaufdatum (Web-Code: ytso-8p8h)
• Schuldtilgung (Web-Code: 2f3t-o59h)
• Äthiopisches Multiplizieren (Web-Code: 064f-kdm4)
63
5 | Unterprogramme (Subroutinen)
Neben der Selektion und der Iteration bietet sich mit Unterprogrammen (Subroutinen) eine dritte
Möglichkeit an, den Kontrollfluss zu steuern.
Bereits im Kapitel über Anweisungen (s. Kap. 2.2 auf Seite 30) sind uns Unterprogramme begeg-
net. Wir hatten dort vorgegebene Systemfunktionen aufgerufen:
• System.out.println("...") )
• Math.sqrt(...)
Neu ist in diesem Kapitel, dass wir solche Teilprogramme auch selbst definieren können.
Ein Unterprogramm27 ist eine mit einem Namen versehene Sequenz. Eine Unterprogramm kann
später aus beliebigen Stellen des Programmes aufgerufen werden.
Unterprogramme sind der Kern der «Strukturierten Programmierung». Damit werden komplexe
Abläufe in fassbare kleine Problemstellungen aufgeteilt. Dies macht den Code überblickbar und
besser wartbar.
Der Begriff Divide et Impera ist lateinisch und steht für Teile und Herrsche28 . Wir verwenden
das Prinzip von kleinen Teilprogrammen, um ein größeres Problem in den Griff zu bekommen29 .
Das Konzept ist auch bekannt unter dem Namen funktionale Dekomposition. In der Praxis spricht
man von schrittweiser Verfeinerung oder einfach vom Verwenden von Unterprogrammen. Diese
kommen in verschiedenen Sprachen mit diversen «Möglichkeiten» vor:
• Subroutinen ohne Rückgabewerte nennt man auch Prozeduren.
• Subroutinen mit Rückgabewerten nennt man meistens Funktionen.
• Subroutinen, die auf Objekten wirken, nennen wir auch Methoden.
Ist die Ausführung der Unterprogramm-Sequenz abgeschlossen, so wird das Programm dort wei-
tergefahren, woher der Unterprogramm Aufruf stattgefunden hat. Unterprogramme brauchen nur
einmal definiert zu werden, auch wenn sie an verschiedenen Stellen aufgerufen werden, oder wenn
sie innerhalb einer Schleife mehrmals aufgerufen werden.
27
Ich werde im folgenden den Begriff Unterprogramm synonym zu Subroutine verwenden.
28
Der Begriff wird Ludwig XI (1423-1483) zugeschrieben. Streue Zwietracht unter die Feinde und herrsche
ungestört. Doch bereits 2000 Jahre zuvor ergänzt Jia Lin das Buch von Sun Tzu [Tzu00] um Methoden, die dem
Feind schaden; insbesondere: «Säe Zwiespalt zwischen dem (gegnerischen) Herrscher und seinen Ministern».
29
Schon Sun Tzu rät in seinem Buch «Die Kunst des Krieges», die Armeen aufzuteilen, um eine große Streitmacht
zu führen. In dieser Bedeutung war der Begriff «Divide et Impera» definitiv schon im römischen Reich - wenn
vielleicht auch nicht unter diesem Namen bekannt.
65
5 Unterprogramme (Subroutinen)
5.1 Vor- und Nachteile von Unterprogrammen

Vorteile:
• Das Programm ist einfacher zu lesen und dadurch auch besser wartbar und veränderbar.
• Einzelne Subroutinen können auch an anderen Stellen und sogar in anderen Programmen
unverändert eingesetzt werden.
• Programme, die in Subroutinen aufgeteilt werden, sind weniger fehleranfällig und somit
robuster.
• Gewisse Berechnungen stehen nun an einer wohl definierten Stelle im Code.
• Fehlerprüfungen können einfacher eingebaut werden.
• Kürzere Entwicklungszeiten bei häufiger Nutzung der selben Subroutine. Ebenso kann die
Zeit zur Fehlersuche reduziert werden.
Nachteile:
• Mehr Tipparbeit
• Programme werden (wenn auch meist kaum messbar) langsamer in der Ausführung (Per-
formanz).
Geek Tipp 5
Wer komplizierten Code schreibt, wird oft zu Unrecht bewundert: Es ist weitaus schwieriger
verständlichen Code zu schreiben.
Die Krux der Applikationsentwickler ist die Entscheidung, ob komplizierter, unverständlicher
Code geschrieben wird, damit man im Projekt unentbehrlich wird, oder ob man besser – und dies
ist weitaus schwieriger – sauberen verständlichen Code schreibt, mit der Tatsache im Auge, dass
man nun jederzeit ersetzbar ist.
Tun Sie sich selbst den Gefallen und schreiben Sie verständlichen Code!

5.2 Arten von Unterprogrammen
Wir werden in den folgenden Kapiteln vier Kategorien von Unterprogrammen kennenlernen:
Die vier Arten von Unterprogrammen

Prozeduren Funktionen
Prozeduren haben keinen Rückgabewert. Funktionen haben wie Variable einen
(Ausdrucks-)Wert.
Unterprogramme ohne Argumente

Einfaches Unterprogramm Abfragefunktion
(s. Kap. 5.2.1 auf Seite 68) (s. Kap. 5.2.4 auf Seite 71)
Beispiele
• beep(); • currentTimeMillis()
• exit(); • getUserName()
• logTimestamp();
• pause();
Unterprogramme mit Argumenten

Prozedur mit Argumenten Funktion mit Argumenten
(s. Kap. 5.2.2 auf Seite 69) (s. Kap. 5.2.5 auf Seite 72)
Beispiele
• println("Hallo"); • sin(360)
• wait(millisecods); • dreiecksflaeche(3, 4, 5)
• printFibonacciNumbers(25);
Aufruf ist jeweils...

... als Anweisung ... als Ausdruck
Beachten Sie, dass die Prozeduren mit einem Strichpunkt ( ; ) beendet wurden. Dabei handelt
es sich in aller Regel um eine Anweisung, wohingegen die Funktionen als Ausdrücke verwendet
werden (sollten) und somit nicht als Anweisungen stehen werden.
67
5.2.1 Primitive Unterprogramme
Unterprogramme ohne Argumente und ohne Rückgabewerte werden eingesetzt, um Programmteile

zu kennzeichnen (einen Namen zu geben) und um das Programmstück aus verschiedenen Stellen
im Hauptprogramm auszurufen.
Beispiele
• Beep: Einen Warnton ausgeben.
• Exit: Programm verlassen.
• Pause: Die Programmausführung um eine Sekunde blockieren.
• Log: Den aktuellen Zeitpunkt (Timestamp) in Erfahrung bringen und diesen z. B. in einer
Log-Datei ausgeben (z. B. zur Geschwindigkeitsprüfung).
• ...
Geek Tipp 6
Teile den Code in überblickbare Teilprogramme. Ein Maximum von sieben Codezeilen ist ein
guter Richtwert.

5.2.2 Parameter und Argumente
In Java können bei einer Subroutine beliebig viele30 Parameter deklariert werden. Jeder Para-
meter hat einen Datentypen und einen formalen Parameternamen.
Beispiel 5.1. Hier einige Funktionsköpfe (Prototypen) mit keinem, einem oder mehreren Parame-
tern:
void mainLoop ()
void println ( String text )
void wait ( long milliseconds )
void wait ( long milliseconds , int nanoseconds )
void : Prozeduren, also Subroutinen, welche keinen Wert zurückgeben, werden in Java mit
dem Schlüsselwort void gekennzeichnet.
Beim Aufruf der Subroutinen geben wir den Parametern Werte mit. Diese aktuellen Werte der
Parameter nennt man auch «Argumente».
Hier einige Prozeduraufrufe:
mainLoop () ; // Ohne Argumente
println ( " Hallo ␣ Welt " ); // Argument ist der String " Hallo Welt "
wait (2000) ; // Argument ist "2000 ( Millisekunden )"
wait (2000 , 500 + x ) ; // Argumente sind hier zwei Zahlen
x = 5200 ;
wait ( x ) ; // Argument ist die Zahl 5200 ( nicht die Variable x !)
Beispiel 5.2. Das folgende Beispiel soll einfach die ersten Quadratzahlen auf der Konsole ausgeben.
Dazu ist lediglich die Zahl max wichtig, welche angibt, bei welcher Quadratzahl dann das Ende
des Programmes erreicht sein soll:
void zeigeQuadratzahlen ( int max )
{
for ( int i = 0; i <= max ; i ++)
{
System . out . println ( " i ␣ : ␣ " + ( i * i ));
}
return ;
}
Bemerkung 5.1. Subroutinen können denselben Namen, aber eine andere Anzahl formaler Para-
meter aufweisen. Diesen Sachverhalt nennen wir entweder «statischen Polymorphismus» oder das
überladen von Subroutinen (s. Kap. A.11 auf Seite 151).
Bemerkung 5.2. Der Befehl return auf der letzten Zeile sagt dem Prozessor, dass die Subroutine
beendet ist, und dass die Kontrolle zum aufrufenden Programm zurückkehren (re-turn) muss. Die
meisten Sprachen (so auch Java) setzen dieses « return » automatisch ein, sodass es mittlerweile
von allen Programmiererinnen und Programmierern weggelassen wird.
30
Beliebig viele heißt hier aber auch: Eine Subroutine kann ohne Parameter auskommen.
69
5.2.3 Unveränderbarkeit (keine variable Parameter)
Wie erwähnt, nennen wir die übergebenen Werte31 Argumente. Argumente sind in Java-
Unterprogrammen nicht veränderbar. Ob ein Parameterwert mittels Literal, Variable, Funk-
tionsresultat oder als zusammengesetzter Ausdruck mitgegeben wird, kann die Funktion nicht
unterscheiden, auch dann nicht, wenn die aufrufende Variable denselben Namen hat:
Beispiel 5.3. Gegeben ist die folgende Funktion:
void change ( int x )
{
System . out . println ( " start ␣ x : ␣ " + x );
x = x + 1;
System . out . println ( " end ␣ ␣ ␣ x : ␣ " + x );
return ;
}
Aufrufe:
int i = 6;
int x = 4;
// Ausgabe :
change (6); // -> 6, 7
change ( i + x * 2); // -> 14 , 15
change ( x ); // -> 4, 5
change ( x ); // -> 4, 5 !! x wird NICHT veraendert !
Beachten Sie: Die Variable x aus dem Aufruf (zweiter Programmblock), wird innerhalb der
Methode change() niemals verändert! Es handelt sich dort um eine andere Variable x , welche
zufällig denselben Namen trägt.
Bemerkung 5.3. Die Parameterwerte (Attribute) und Werte der lokalen Variablen32 liegen in der
Maschine auf dem sog. Stack (Stapel)33 und haben nur während der Ausführung der Subroutine
ihre Gültigkeit.
Bemerkung 5.4. Auch hier ist das Schreiben der return -Anweisung optional;
Bemerkung 5.5. Zur Syntax von Java-Subroutinen siehe hier (s. Kap. A.10 auf Seite 150).
Aufgabe 5.1 «Name und Alter» Schreiben Sie eine Subroutine

nameUndAlterAusgeben(String name, int jahrgang) , welche eine persönliche Begrüßung und
das Alter ausgibt. Achtung: Das Alter wird der Subroutine nicht mitgegeben; nur der Jahrgang!
31
Java übergibt immer die Werte der Ausdrücke, niemals die Variablen, auch dann nicht, wenn ein Ausdruck
genau aus einer Variable besteht. Ein sog. Variablenparameter ist in Java also nicht möglich.
32
Für lokale Variabel Siehe Seite 76
33
Stack Siehe Anhang auf Seite 152

5.2.4 Rückgabewerte (Parameterlose Funktionen)
Subroutinen können nicht nur Attributwerte als Parameter entgegen nehmen; sie können auch
Werte zurückgeben.
Unterprogramme, welche einen Wert zurückgeben nennen wir auch Funktionen.
Beispiel:
currentTimeMillis() liefert die Systemzeit in Millisekunden (gezählt ab dem 1. Januar 1970).
getUserName() liefert den Namen des aktuell eingeloggten Benutzers34 .

Rückgabewerte werden verwendet, wie jeder andere Ausdruck auch. Funktionen werden nie als
void deklariert. Es ist bei der Deklaration der Funktion immer ein Datentyp anzugeben. Mittels
return wird bei der Funktionsdefinition stets ein Wert von diesem Datentyp zurückgegeben.
Beispiel:
Obige Funktion berechnet die Differenz zwischen zwei Jahreszahlen. Diese Differenz wird als
alter() zurückgegeben.
Gleich ein zweites Beispiel, welches den Jahrgang via Konsole erfragt und als int zurückgibt:
int jahrgang () {
System . out . println ( " Bitte ␣ Jahrgang ␣ eingeben : ␣ " );
String jahrString = new Scanner ( System . in ). nextLine ();
int jahr = Integer . parseInt ( jahrString );
return jahr ;
}
Bemerkung 5.6. Beachten Sie, dass in Java bei Funktionsresultaten die return -Anweisung
angegeben werden muss!
34
Leider unterscheidet sich hier der Java-Funktionsname je nach Betriebssystem. Unter MS-Windows lautet
der Befehl getName() .
71
5.2.5 Klassische Funktionen
Eine klassische Funktion berechnet einen Wert abhängig von einer Eingabe nach dem EVA-
Prinzip. EVA bezeichnet hier Eingabe-Verarbeitung-Ausgabe. Bei Java-Funktionen ist die Ein-
gabe die Werteliste der Argumente, die Verarbeitung wird durch den Funktionsrumpf (Body)
erreicht und die Ausgabe ist der Wert, welcher dem aufrufenden Programm zurückgegeben wird.
Beispiel 5.4.
Das folgende Unterprogramm berechnet das Volumen eines Quaders:
double volumen ( double breite , double hoehe , double tiefe )
{
return breite * hoehe * tiefe ;
}
Aufgerufen wird dies dann ganz natürlich:

double vol1 = volumen (2.0 , 3.8 , 1.5);
double b = 6 ;
double h = 5.9;
double vol2 = volumen ( b , h , 3.0 + 4.8);
Für die Rückgabe steht der Java virtuellen Maschine nur ein Register (4 Byte) zur Verfügung35 .
Dies reicht für Zahlen und Zeichen. Die Rückgabe in Java erfolgt mit dem Schlüsselwort return .
Da Java eine typisierte Sprache ist, muss der zurückgegebene Wert denjenigen Datentypen
aufweisen, der im Prototypen der Funktion (also in der Kopfzeile) angegeben wurde:
Beispiel 5.5. Die folgende Funktion halbiert Zahlen und muss somit auch gebrochene Werte (De-
zimalbrüche) zurückgeben können:
double halbieren ( int zahl ) {
double haelfte ;
haelfte = zahl / 2.0;
return haelfte ;
}
Der Aufruf eines selbst geschriebenen Unterprogrammes ist identisch mit den vorgegebenen Sys-
temfunktionen (s. Kap. 1.4.5 auf Seite 23). Auch hier kann die Subroutine wie ein Ausdruck
verwendet werden:
double d ;
d = halbieren (4) + halbieren (3) +
halbieren (3*8 + (( int ) halbieren (6)));
35
Ausnahmen: für double und long werden 8 Byte benötigt, also zwei Register. Andere Programmiersprachen
(z. B. Python oder Ruby) können via return gleich mehrere Werte zurückgeben.

Für kompliziertere oder zusammengesetzte Funktionsresultate verwendet man Referenzen auf
Objekte. Es sind Objekte, die man bereits mitgibt und deren Werte verändert werden, oder aber
man erzeugt innerhalb der Subroutine ein neues Objekt. Dazu mehr im Band «Objekte und
Klassen» [Fre15].
Das folgende Beispiel zeigt, dass jeder Wert eines Ausdrucks direkt mit return zurückgegeben
werden kann. Einzig der Datentyp muss übereinstimmen.
Beispiel 5.6. In der folgenden Subroutine istGerade() wird im Parameter p eine ganze Zahl
entgegengenommen. Es wird geprüft, ob der Zweierrest (MOD 2) den Wert Null (0) ergibt. Ist
der Zweierrest 0, so ist p gerade und es wird dem aufrufenden Programm true zurückgegeben
(return), ansonsten false .
boolean istGerade ( int p ) {
return 0 == p % 2;
}
73
Beispiel 5.7. Das Unterprogramm nextFibo() (rechter Teil der Grafik) berechnet aus einer
Fibonacci-Zahl seinen Nachfolger in der Fibonacci-Reihe. 36
Aufrufendes Programm: Unterprogramm:

int y1 , y2 , y3 ; int nextFibo ( int fib ) {
double PHI = 1.618033988749894;
y1 = 55; double res ;
y2 = nextFibo ( y1 );
y3 = y1 + y2 ; res = PHI * ( fib + 0.4);
return ( int ) res ;
print ( y3 ); }
36
Die Fibonacci-Reihe beginnt mit 1, 1, 2, 3, ... Jeder Nachfolger wird aus der Summe der beiden letzten Zahlen
der Reihe berechnet. Beachten Sie auch die rekursive Berechnung aus [GFG11] dort: Aufgabe 11.2 auf Seite 143
und beachten Sie weiter die Bemerkungen in diesem Skript (s. Kap. 11.1 auf Seite 123). Die direkte Berechnung
(also ohne Iteration oder Rekursion) ist sicher die rascheste Berechnung für große Werte.

5.3 Ausdrücke 2. Teil
Neben den bereits gelernten Ausdrücken (s. Kap. 1.1.1 auf Seite 18) können wir nun auch selbst
Funktionen schreiben, die als Ausdrücke verwendet werden können. Dabei ist einzig darauf zu
achten, dass es sich um Funktionen mit Rückgabewert (also keine void -Methoden) handelt.
Gleich ein Beispiel: Die linke Methode kann nun verwendet werden, als wäre es ein «Built-In»,
also eine vorgegebene, Funktion.
long kubik ( int s ) void top () {

{ System . out . println ( " Kubik ␣ von ␣ 8 ␣ : ␣ "
int a , b , c , d ; + kubik (8));
a = 6; System . out . println ( " Kubik ␣ von ␣ 6 ␣ : ␣ "
b = 12; + kubik (6));
c = 7; }
d = 1;
while ( s > 1)
{
d = d + c;
c = c + b;
b = b + a;
s = s - 1;
}
return d ;
}
5.3.1 Zusammenfassung der wichtigsten Anweisungen und der Ausdrücke
wichtigste Anweisungen Ausdrücke

Deklaration Literal
int breite; , char niveau; , ... 5 , ’c’ , "Hallo Welt" , 3.7e5f , ...
Zuweisung Variable
breite = 4; , ... breite
Prozeduraufruf Funktionsresultat
beep(); , println("Hallo"); , ... getDate() , sin(x + 45) , ...
Ablaufsteuerung Zusammengesetzte Ausdrücke
if()... , while()... , ... x + sin(45 + p) , ...
Beachten Sie nochmals: Anweisungen werden in Java immer mit einem Semikolon (Strichpunkt)
beendet – Ausdrücke hingegen nicht!
75
5.4 Lokale und globale Variable

Innerhalb von Unterprogrammen existiert wie bereits erwähnt ein eigenständiger Speicherbereich
(Stapel bzw. stack 37 ). Damit ist es möglich, Variable zu deklarieren, die nur während der Ausfüh-
rung des Unterprogramms Gültigkeit haben. Diese Variable werden lokale Variable genannt. Sie
können dieselben Namen tragen, wie Variable im aufrufenden Programm, ohne mit diesen in Kon-
flikt zu geraten. Sobald zum aufrufenden Programm zurückgekehrt wird, verlieren lokale Variable
ihre Werte, d. h. die lokalen Variable können nur innerhalb der entsprechenden Unterprogramme
verwendet werden. Damit ein Unterprogramm auch Werte von Variablen im Hauptprogramm ver-
ändern kann, verwendet man entweder globale Variable, die aus allen Programmteilen sichtbar
sind, oder man übergibt den Unterprogrammen Referenzen (Speicheradressen) auf Variable, die
im aufrufenden (Haupt-)Programm deklariert sind (Referenzvariable oder «variable Parameter»
genannt).38
Lokale Variable liegen auf dem Stack und werden vernichtet, sobald die Routine (das Unter-
programm) seinen Dienst erfüllt hat. Globale Variable liegen auf dem Heap und werden erst
vernichtet, sobald kein Unterprogramm mehr darauf zugreifen kann.
Code:
class Test {
int a = 3; // global : in allen Unterprogrammen sichtbar
void top () {
int b = 4; // lokal
a = fct1 ( b );
System . out . println ( " A = " + a + " ␣ B = " + b );
}
int fct1 ( int x ) { // Parameter sind auch nur lokal

return (3 + x ) * x + a ;
}
}
Geek Tipp 7
Lokale Variable sind globalen vorzuziehen!
37
S. S. 152
38
Natürlich können wir Werte im Hauptprogramm auch mittels Funktionsrückgabe verändern, indem wir diese
als Ausdrücke verwenden; doch hier geht es im Moment ausschließlich um das Verändern von Variablen.

5.5 Geringschätzung...
Jedes Funktionsresultat ist ein Ausdruck und keine Anweisung. Ausdrücke sollten wenn immer
irgendwo verwendet werden. So erstaunt dieser ignorierende Code jeden erfahrenen Programmie-
rer:
int x ;
x = 4;
x = x * 6;
doppelDecker ( x ); // *** ??? ***
x = x + 2;
bei der folgenden gegebenen Methode:
int doppelDecker ( int a )

{
int resultat ;
resultat = 2 * a + 2;
return resultat ;
}
Die Methode doppelDecker() hat eine Aufgabe zu erfüllen. Sie berechnet eine Zahl (hier
resultat genannt). Dieses Resultat wird der aufrufenden Programmsequenz übergeben, aber ...
oh Wunder ... dort (an der mit *** ??? *** bezeichneten Stelle) nicht verwendet. Der Program-
mierer, der die Funktion doppelDecker() aufruft, vernichtet geringschätzig (oder mangels Ver-
ständnis des Funktionsresultates) die Arbeit derjenigen Person, die die Methode doppelDecker()
implementiert hatte. Mit demselben Resultat39 hätte unser Ignorant folgendes schreiben können:
int x;
x = 4;
x = x * 6;
50;
x = x + 2;
Programmiersprachen, die das Vernichten von Funktionsresultaten überhaupt nicht erlauben sind
hier hoch zu loben. In den wenigen Fällen, wo das Resultat tatsächlich nicht verwendet wird, ist
das mit einem Kommentar zu erklären. Ein call -Schlüsselwort wie in anderen Programmier-
sprachen gibt es in Java leider nicht!
39
Natürlich wird an der mit ***???*** markierten Stelle die Funktion als Anweisung ausgeführt. Dadurch
wird der Prozessor aufgewärmt. Doch mehr als heiße Luft produziert es nicht, wenn wir eine Funktion nicht als
Ausdruck, sondern als Anweisung verwenden!
77
Geek Tipp 8
Verwenden Sie Prozeduren stets als Anweisungen!
Verwenden Sie Funktionen stets als Ausdrücke!

5.6 Wächter
Ein Aufruf von return beendet die aktuelle Methode sofort. Dieses Wissen kann verwendet
werden, um sog. Wächterabfragen in den Code einzubauen, ohne dass der Code bei jeder Abfrage
um eine Einrückung weiter geschoben werden muss.
Gehen wir einmal von der folgenden bekannten Subroutine aus, welche den Schalttag zurückgibt.
Ist ein Jahr ein Schaltjahr, so wird Eins ( 1 ) zurückgegeben, in allen anderen Fällen die Null
( 0 ):
int schalttag ( int jahr ) {
if ( jahr % 4 != 0) { return 0; }
if ( jahr % 400 == 0) { return 1; }
if ( jahr % 100 == 0 && jahr > 1582) { return 0; }
return 1;
}
Nun wollen wir den letzten Tag in einem Monat berechnen und benötigen dazu sogar noch das
Jahr; nämlich für den letzten Tag jeweils im Februar. Um mögliche fehlerhafte Eingaben zu
vermeiden, müssen wir sowohl das Jahr, wie auch den Monat auf Gültigkeit prüfen.
int letzterTagImMonat ( int monat , int jahr ) {
if ( jahr != 0)
{
if ( monat >= 1 && monat <= 12)
{
if (4 == monat || 6 == monat || 9 == monat || 11 == monat )
{
return 30;
} else {
if ( monat != 2) {
return 31;
}
}
return 28 + schalttag ( jahr );
}
}
// Fehler :
return 0;
}
79
Doch mit etwas GRIPS40 könnten wir Wächterabfragen einbauen, welche die Fehler von vornherein
ausschließen und den Code doch einiges besser lesbar machen:
int letzterTagImMonat ( int monat , int jahr ) {
// Fehlerbehandlung ( Waechter )
if ( jahr == 0) return 0;
if ( monat < 1 || monat > 12) return 0;
// Hauptteil
if (4 == monat || 6 == monat || 9 == monat || 11 == monat )
{
return 30;
}
if ( monat != 2)
{
return 31;
}
return 28 + schalttag ( jahr );
}
Bemerkung: Streng genommen unterwandern wir mittels return aus einer Kontrollstruktur ( if ,
while ) die «Strukturierte Programmierung». Es handelt sich hier lediglich um eine Fehlerbe-
handlung, welche nach Funktionsende zum selben Punkt zurück gelangt, wie wenn der Fehler
nicht aufgetaucht wäre. Somit können wir hier ein Auge zudrücken.
Bemerkung 5.7. Die vorab gegebene Funktion schalttag() hatte sich dieses Wissen bereits zu
nutze gemacht.
Geek Tipp 9
Schreiben Sie Ihren Code wenn immer möglich mit etwas GRIPS.
40
GRIPS = Generelles Return Im Prozedur-Start.

5.7 Leseaufgaben
5.7.1 a, b oder c zum Ersten
Was ist die Ausgabe (c = ...) des folgenden Programmes?

{ // aufrufender Block ( Hauptprogramm )
int a = 4;
int b = 5;
f (a , a , b );
}
// aufgerufene Methode f ()
void f ( int a , int b , int c )
{
a = a + b;
b = b + c;
c = a + b;
print ( " c ␣ = ␣ " + c );
}
5.7.2 x, y oder z
Was ist die Ausgabe des folgenden Programmes?

int x = 6;
int y = 8;
f (x , y , x );
}
// aufgerufene Methode f ()
void f ( int z , int y , int x )
{
int r ;
x = x + y;
y = x + 2* z ;
r = x + y + z;
print ( " r ␣ = ␣ " + r );
}
81
5.7.3 a, b oder c zum Zweiten
Was ist die Ausgabe des folgenden Programmes?

int a = 7;
int b = 4;
f (a , a , b );
}
// aufgerufene Methoden f () und g ()

void f ( int a , int b , int c )
{
int x , y , z ;
x = g (b , b , c );
y = g (a , b , b );
z = g (c , c , a );
print ( " x = " + x );
print ( " y = " + y );
print ( " z = " + z );
}
int g ( int b , int a , int c )

{
return b + 2* a + 3* c ;
}
Lösungen im Anhang (s. Kap. B auf Seite 191).

• «Viele Programme vor allem aus Kap. 2 lassen sich nun als Funktionen lösen (Sinusfunktion,
Satz von Pick, Abbildungsgleichung, ...»
• 4.14 Sinusfunktion (Web-Code: g5cx-nzxg)
• Satz von Pick (Web-Code: hpaj-dw3x)
• 5. 1 Ungerade Zahlen (Web-Code: jsju-e6xd)
• Liste von Suchresultaten (Web-Code: rqte-f27b)
• 5. 2 RGB (1) (Web-Code: 829e-g8uz)
• 5. 3 RGB (2) (Web-Code: 4zn2-dxzd)
• 5. 4 Quersumme (Web-Code: wvfg-ndmx)
• 5. 5 Abstand (Web-Code: tybn-j6zi)
• 5. 6 Dreiecksflächen (Web-Code: 4hpi-tuo2)
• 5. 7 Geometrie (Web-Code: ma5m-oj6k)
• 5. 8 ggT nach Euklid (Web-Code: 7k49-32v7)
• 5. 9 Exponenten (Web-Code: 6i5m-xtvw)
• 5.10 Bremsweg (Web-Code: dh44-7qtd)
• 5.11 Schaltjahre (Web-Code: 4xw9-mhjm)
• 5.12 Plausibilität eines Kalenderdatums (Web-Code: fa38-e9da)
• 5.13 Ewiger Kalender (Web-Code: m2g9-636g)
• 5.15 Frankengewinnspiel (Web-Code: qnfv-rirb)
• 5.16 Parameter vs. globale Variable (Web-Code: 58wm-7x5h)
• Notenberechnung ab Klausur (Web-Code: 25gz-jfjo)
• Gültigkeit eines Passwortes (Web-Code: xy54-zafk)
• Letzter Tag im Monat (Web-Code: d5pm-hf8p)
83
6 | Felder (Arrays)
Arrays (selten auch Felder, Reihungen oder Vektoren genannt) sind eindimensionale Tabellen
von Variablen mit gleichem Typ. Auf die Elemente eines Arrays wird wahlweise mit Hilfe eines
ganzzahligen Indexes zugegriffen. Wir sprechen von einem «random access41 ».
Einführungsbeispiel
Eine Methode printDatum(tag, monat, jahr) , welche ein Kalenderdatum in lesbarer Form
ausgibt, könnte wie folgt aussehen:
void printDatum ( int tag , int monat , int jahr ) {
print ( tag + " . ␣ " );

if (1 == monat ) { print ( " Januar " ); }
else if (2 == monat ) { print ( " Februar " ); }
else if (3 == monat ) { print ( " Maerz " ); }
else if (4 == monat ) { print ( " April " ); }
else if (5 == ...
...
else if (12 == monat ) { print ( " Dezember " ); }
print ( " ␣ " + jahr );
Für solche Fälle sind mit Vorteil Arrays zu benutzen:

String [] monatsNamen = { " Januar " , " Februar " , " Maerz " , ...};
void printDatum ( int tag , int monat , int jahr ) {
print ( tag + " . ␣ " + monatsNamen [ monat - 1] + " ␣ " + jahr );
}
Beachten Sie den um 1 verminderten Monatsindex (monat - 1). Dieser ist in Java wichtig, denn
in Java werden Arrays immer von Null (0) an indexiert. Der Monat mit der Nummer 1 soll in
diesem Beispiel (und nach allgemeinem Verständnis) jedoch der Januar sein.
Die erste Zeile erzeugt eine Liste (Feld, Array) von String s. Dies wird mit dem Symbol []
hinter dem Datentypen bezeichnet. Ein Array von Ganzzahlen würde also wie folgt deklariert:
int [] groesse ;
Um auf die Felder zuzugreifen (Zuweisen oder Auslesen) wird der sog. Indexoperator benutzt:
[ ... ] .
41
«random» bezeichnet hier nicht «zufällig» sondern eher «nach beliebiger Wahl».
85
6 Felder (Arrays)
Buch Beispiel
Das Beispiel aus dem Buch ([GFG11] dort Seite 74) wird hier nochmals aufgegriffen. Zum besseren
Verständnis nenne ich die Variable hier wotage (statt einfach x ).
Index wotage[0] wotage[1] wotage[2] wotage[3] wotage[4] wotage[5] wotage[6]

Wert Montag Dienstag Mittwoch Donnerstag Freitag Samstag Sonntag
Zugriff
Der Zugriff auf die einzelnen Komponenten geschieht mittels Index in eckigen Klammern (’[’, ’]’).
Obiger Array kann in Java auf zwei Arten initialisiert werden:

a) durch direkte Array-Zuweisung
String [] wotage = { " Montag " , " Dienstag " , " Mittwoch " ,
" Donnerstag " , " Freitag " , " Samstag " ,
" Sonntag " };
b) schrittweise (einzeln)
String [] wotage ;
wotage = new String [7];
wotage [0] = " Montag " ;

wotage [1] = " Dienstag " ;
wotage [2] = " Mittwoch " ;
wotage [3] = ...
...

Syntax von Arrays
Deklaration
Deklariert werden Arrays indem eckige Klammern hinter den Datentypen gestellt werden:
int [] s ;
Achtung: In diesem Beispiel wird für die int -Elemente noch kein Speicherplatz geschaffen! Es
wird erst deklariert, dass die Variable s später mit einem int -Array gefüllt werden darf.
Definition
Bevor wir die einzelnen int -Werte abfüllen können, müssen wir vom Betriebssystem Speicher
anfordern. Dies geschieht mit dem new -Operator:
s = new int [5];
Mit dieser Definition wird Speicher für fünf int -Werte angelegt.
Defaultwerte
Im Gegensatz zu anderen Sprachen werden Arrays von Zahlen (hier int ) je mit Null initialisiert.
Es gilt unmittelbar nach dem Definieren des Arrays s also:
0 == s [0]
0 == s [1]
0 == s [2]
...
Indexieren
Der kleinste Index ist in Java immer 0 (Null). Somit ist beispielsweise der höchste Index des
obigen Arrays s gleich 4.
Beispiele:
s [0] = 17;
s [1] = 9 * s [0];
s [4] = s [1] + s [2]; // s [2] == 0 ( Defaultwert )
s [5] = 77; // FEHLER : s indexiert nur von 0 bis 4!
Die einzelnen Komponenten ( s[0] , s[1] , ...) werden je wie eigene Variable behandelt.
87
6 Felder (Arrays)
Länge
Arrays können ihre Länge (Anzahl der Elemente) mit dem Attribut length bekannt geben. In
unserem Beispiel ist « s.length == 5 ». Die Länge wird oft in Schleifen verwendet:
for ( int i = 0; i < s . length ; i ++) {
s [ i ] = i * i ; // z. B. Quadratzahltabelle
}
6.1 Arrays und Schleifen (Iteration)

6.1.1 «for-each»
Java kennt eine sog. «for-each»-Schleife, mit folgender Syntax:

for ( < Typ > < variable > : < Sammlung >) {
< BLOCK > // mache etwas mit " variable "
}
Um zu zeigen, wie damit Arrays verwendet werden, können wir sogleich die Daten (Wochentage)
aus den beiden obigen Einführungsbeispielen (s. Kap. 6 auf Seite 85) ausgeben:
for ( String w : wotage ) {
System . out . println ( w );
}
6.1.2 Index
Manchmal benötigt man den Index, also die Position des Elementes. Dies ist nun bei Arrays (aber
auch bei ArrayLists und Lists) dank der bekannten Länge einfach zu bewerkstelligen:
int letzterIndex = wotage . length - 1;
for ( int i = 0; i <= letzterIndex ; i ++) {
System . out . println ( i + " : ␣ " + wotage [ i ]);
}

6.2 Tabellen
Tabellen sind mehrdimensionale Arrays. Meistens handelt es sich um zweidimensionale Felder,
wie wir sie von Tabellenkalkulationen kennen.
Am Einfachsten verstehen wir Tabellen mit Hilfe eines Beispiels.
Die Umsätze der drei Abteilungen (X, Y und Z) werden pro Quartal (Q1, Q2, Q3 und Q4) in
einer Tabelle abgespeichert.
Umsätze in Tabellenform:
Obiges wird in Java nun wie folgt implementiert:

int [][] umsaetze ; // Tabelle = Array aus Arrays
// 4 Zeilen , 3 Spalten anlegen :

// Zeile = vier Quartale
// Spalten = drei Abteilungen
umsaetze = new int [4][3];
// Indizes beginnen auch hier bei Null (0):

// Betrachten wir nun Q3 von Abteilung Y.
// 3. Zeile hat Index 2: Q3
// 2. Spalte hat Index 1: Abt . Y
umsaetze [2][1] = 1900;
Wie Java dies intern technisch umsetzt, finden wir im Anhang (s. Kap. A.18.2 auf Seite 164).
Weitere Spezialitäten und Eigenheiten von Arrays und Tabellen im Anhang (s. Kap. A.18 auf
Seite 164);
89
6 Felder (Arrays)

• 6. 1 Feldelemente aufsummieren (Web-Code: pgez-dr6b)
• Zähle vorkommen in Array (Web-Code: 07oi-q7s2)
• Suche Element in Array (Web-Code: t2hd-0qw5)
• Häufigstes Element in Array (Feld) suchen (Web-Code: qurd-eugv)
• 6. 3 Feld filtern (1) (Web-Code: zxku-89hw)
• 6. 4 Feld filtern (2) (Web-Code: 3hiq-vtfi)
• Rotation (Web-Code: r5bd-t6kt)
• 6. 5 Feld filtern (3) (Web-Code: gtmt-n6b2)
• 6. 7 Transponieren einer Matrix (Web-Code: wmjo-fn97)
• 6. 9 Schriftsetzer (Web-Code: p8vk-9x7k)
• 6.10 n-ter Tag im Jahr (Web-Code: gqsc-8u29)
• 6.11 Freitag, der 13. (Web-Code: bomo-xjx6)
• 6.12 Waschautomat (Web-Code: vyyu-vu3u)
• 6.13 Geldbetrag (Web-Code: 6juh-7y3z)
• 6.14 Maximale Teilsumme (Web-Code: sypi-dsoh)
• 6.15 Tic-Tac-Toe (Web-Code: imhb-6pb8)
• 6.16 Springer auf dem Schachbrett (Web-Code: o9zn-pwdy)
• 6.17 Exponententabelle (Web-Code: n2gz-2e3u)
• 6.18 Gleichungssystem (Web-Code: k43i-8vjt)
• Schraubensack (Web-Code: uk54-0btd)
• Es lebe der König (Web-Code: i33b-cg32)
• Magisches Quadrat (Web-Code: 5veq-pt02)
• Rang (Ranking) nach Punktezahl (Score) (Web-Code: qwjb-jg40)

91
7 | Zeichenketten
Die Verarbeitung von Zeichenketten kommt in den meisten Applikationen vor. Sei dies, z. B. um
Resultate aus einer Datenbank anzuzeigen, eine Datei zu öffnen oder einfach, um eine Schaltfläche
genauer zu spezifizieren.
Strings (also Zeichenketten) sind in der Regel nichts anderes als Arrays von Zeichen. In Java
handelt es sich um Arrays auf dem Datentyp char . Da dies so häufig verwendet wird, existiert
für Zeichenketten in Java ein eigenes Literal – wir schreiben z. B. einfach
String nameA = " Ali " ;
String nameB = " Pedro " ;
String nameC = " Aisha " ;
7.1 Die Klasse String
Zeichenketten werden in Java mit der String -Klasse umgesetzt. Das String-Literal ist nichts
anderes als eine Zeichenkette, die in (doppelten) Apostrophen ( " ) als Begrenzungszeichen ein-
gefasst ist:
" Hallo ␣ Welt "
Wie man Zahlen einer int -Variable zuweisen kann, so kann man Strings auch String -Variablen
zuweisen oder ganz generell als Ausdrücke (s. Kap. 1 auf Seite 17) verwenden:
String a , b ;
a = " Hallo " ;
b = " Welt " ;
System . out . println ( a + " ␣ " + b );
93
7 Zeichenketten
7.2 Verarbeitung von Zeichenketten in Java

Die Beschreibungen zu den folgenden standard-Problemstellungen finden Sie in «Programmieren
lernen» [GFG11] in Kap. 7.1 auf Seite 88.
Literal "Hallo Welt"
Variable
name = " Meier " ;
Ausgabe System.out.println("Hallo Welt");

Einlesen
String eingabe ;
eingabe = sc . next ();
Länge
String txt = " Hallo ␣ Welt " ;
int len ;
len = txt . length ();
Zeichen ermitteln
char ch = txt . charAt (5);
Strings sind wie Arrays ab 0 (Null) indexiert.

Zusammenfügen
String a = " Hallo " ;
String b = " Welt " ;
String c = a + " ␣ " + b ;
Kopieren
String a = " Hallo ␣ Welt " ;
String b = new String ( a );

Suchen Zunächst können wir nach einem einzelnen Zeichen suchen:
String txt = " Hallo ␣ Welt " ;
int pos = txt . indexOf ( ’W ’ );
Eine andere Möglichkeit ist es, nach Teilstrings zu suchen.

if ( txt . contains ( " Welt " )) { ... }
Prüfen Einfach ist es in Java zu prüfen, ob ein String auf eine vorgegebene
Endung aufhört:
if ( txt . endsWith ( " Welt " )) {...}
Komplexe reguläre Ausdrücke sind mit Java auch möglich: Beginnt

der Text mit "H" , enthält er (mind.) ein Leerzeichen und endet auf
"t" ?
if ( txt . matches ( " H [^ ␣ ]* ␣ .* t " )) {...}
Extrahieren
txt . substring (2 , 5); -> " llo "
Achtung: Bei substring() ist die erste Position inklusive jedoch die
zweite Position exklusive!
Den Code eines Zei- ...einfach einer int -Variable zuweisen:
chens zu ermitteln ist
char zeichen = ’x ’;
in Java geschenkt...
int code = zeichen ;
Zeichen des Codes:

Hier ist ein Casting nö- zeichen = ( char ) code ;
tig.
Ziffernfolgen in Zahlen
verwandeln String zahlStr1 = " 2012 " ;
String zahlStr2 = " 3.14 " ;
int zahl1 = Integer . parseInt ( zahlStr1 );

double zahl2 = Double . parseDouble ( zahlStr2 );
Zahlen in Ziffernfolgen
(Strings) verwandeln int zahl = 2012;
String zahlString = " " + zahl ;
95
7 Zeichenketten
7.3 Zeichenketten und Dateien

Hier die wichtigsten Java Befehle, um mit Dateien umzugehen42 :
• Auffinden von Dateien im Verzeichnisbaum:

File halloFile = new File("Hallo.txt");
if(halloFile.exists()) { ... }
• Öffnen, Schließen von Dateien und Zeilenweise daraus lesen:
try ( BufferedReader br =
new BufferedReader ( new FileReader ( halloFile )))
{
String line ;
line = br . readLine (); // vorausgehendes Lesen
while ( null != line ) {
System . out . println ( " Gelesen : ␣ " + line );
line = br . readLine (); // wiederholtes Lesen
}
} catch ( IOException iox ) {
System . err . println ( " Fehler : ␣ " + iox );
}
Zum doppelten Lesen (vor-Lesen/nach-Lesen) gibt es in Java Abkürzungen, welche im

Anhang beschrieben sind (s. Kap. A.20.2 auf Seite 172).
• Zeilenweise Schreiben in eine Datei:

Mit dem Kommando write(); können Strings, aber auch einzelne Zeichen geschrieben
werden. Um eine Zeile zu schreiben, wird am Ende des Strings einfach das Zeilen-Ende-
Symbol \n angefügt.
File out = new File ( " Ausgabe . txt " );
try ( FileWriter fw = new FileWriter ( out )) {
fw . write ( " Eine ␣ Zeile .\ n " );
fw . write ( " Und ␣ noch ␣ eine ␣ Zeile .\ n " );
} catch ( IOException e ) {
e . printStackTrace ();
}
• Zeichenweise Lesen und Schreiben in Java funktioniert analog mit den Befehlen read()
und write() .
• Das Anfügen an eine bestehende Datei ist im Anhang beschrieben (s. Kap. A.20.3 auf Seite
173).
42
Weitere Infos im Anhang: (s. Kap. A.20 auf Seite 169)

7.4 Vergleichen von Strings in Java
Ein gängiger Fallstrick ist der Vergleich von Zeichenketten in Java. Wenn auch ganze Zahlen
mit dem == -Operator verglichen werden, so funktioniert dies mit Zeichenketten nur bedingt. Der
== -Operator für Zeichenketten (und andere Objekte) besagt in Java lediglich, ob es sich um
die identischen Objekte handelt. Es sagt aber nichts aus, wenn zwei verschiedene Strings dieselbe
Sequenz aus Zeichen aufweisen. So sind Kurt Müller, Zürich; Entlisbergstr. und Kurt Müller,
Zürich; Gottfried Kellerstr. zwar weitgehend gleich, doch es sind nicht dieselben!
Strings werden in Java mit der Methode equals() auf inhaltliche Gleichheit untersucht:
String a , b ;
a = ...;
b = ...;
if ( a . equals ( b )) {
...
}
Beachten Sie jedoch, dass die folgenden Vergleiche unterschiedliche Resultate liefern:
String a = " xy " ;
String b1 = " xy " ;
String b2 = new String ( " xy " );
if ( a == b1 ) --> true
if ( a == b2 ) --> false
if ( a . equals ( b2 )) --> true
Weitere Infos im Anhang (s. Kap. A.19.5 auf Seite 168).
7.5 Plus Operator für String Objekte
Der + -Operator (Plus) auf Zahlen oder char angewendet, zählt die (binären) Werte zusammen.
Ist jedoch mindestens einer der beiden Operanden ein String, so wird auch der andere als String
betrachtet und die beiden Strings werden aneinandergereiht:
’# ’ + 4 + 2 + " ␣ != ␣ " + ’4 ’ + 2
liefert nicht etwa « #42 != 42 » sondern «41 != 42»

denn das Zeichen «#» hat den ASCII-Wert 35, 35 + 4 + 2 = 41 und der Plus-Operator assoziiert
von links nach rechts! Das heißt, erst ab dem Auftreten des ersten Strings wird das Resultat in
einen String umgewandelt. Der Datentyp char wird in Java nicht wie ein String , sondern
wie ein int behandelt, wenn es ums Rechnen geht ( + , - , * , / ).
97
7 Zeichenketten
7.6 Unicode
Java verwendet für Strings den Datentypen char (16 Bit) um Unicode43 Zeichen zu speichern.
Damit können bis 65 000 Zeichen unterschieden werden44 .
Unicode 6= UTF-8
Da in Files meist UTF-8 oder Latin (also 8-Bit-Zeichen) zur Textkodierung verwendet wird, so
muss man sich trotz Unicode45 bewusst sein, dass es zum Lesen bzw. Schreiben von Zeichen eine
Umkodierung braucht.
7.6.1 char -Literale
Zu den Literalen ist noch zu erwähnen, dass die char-Literale auch für Strings eingesetzt werden.
Die folgenden Escape-Sequenzen sind unterstützt:
• \n (new Line)
• \b (backspace)
• \f (formfeed)
• \uABCD (Unicode, «u» gefolgt von 4 Hex-Ziffern)46
• \t (tabulator)
• \r (carriage return)
• \\ (backslash)
• \' (single quote)
• \" (double quote)
Merksatz für die existierenden Escape-Sequenzen:

Nur Beherrschung f ormatiert unseren Text richtig.
7.7 Bemerkung
Weitere Besonderheiten von Zeichenketten im Anhang (s. Kap. A.19 auf Seite 166).
43
http://www.unicode.org
44
Mit Escape-Sequenzen und diakritischen Zeichen («˜ », «ˆ» , ...) können noch viele weitere daraus zusammen-
gesetzt werden.
45
Auch wenn sich (im Falle von LATIN bzw. ASCII) diese Umkodierung z. B. lediglich auf das Weglassen der
ersten 8 (bzw. 9) Bit beschränken kann!
46
\u leitet eine 4-Stellige Hex-Zahl ein (= 16 Bit). Diese werden aber oft nicht als Escape-Sequenzen bezeichnet,
sondern einfach als char-Literale.

• Die Lösungen zur Aufgabe 7. 1 aus «Programmieren lernen» sind oben abgedruckt (s. Kap.
7.2 auf Seite 94).
• 7. 3 Wortweise umkehren (Web-Code: q3bk-4ekq)
• 7. 5 Schriftlich addieren (Web-Code: oh4f-nrsz)
• 7. 7 Cäsar (Web-Code: kb99-fe5k)
• 7. 8 Sekunden-Umwandlung (Web-Code: sxmw-sks3)
• 7. 9 IP-Adressen (1) (Web-Code: 8zmd-r65m)
• 7.11 Dreiersystem (1) (Web-Code: kwsx-k6s4)
• 7.12 Dreiersystem (2) (Web-Code: 8ghq-ywrr)
• 7.13 Nachkommastellen im Binärsystem (Web-Code: ozvv-txgt)
• 7.14 Deutsche Zahlnamen (Web-Code: s8y6-rqfn)
• 7.15 Taschenrechner (Web-Code: 6nmz-eiot)
• 7.16 7-Segment-Displays (Web-Code: m8xi-kzq3)
• 7.17 ISBN/EAN (Web-Code: gg7a-xaou)
• 7.18 File-Statistik (Web-Code: gcx8-7ud7)
• 7.20 Wortliste filtern (Web-Code: pomd-oige)
• 7.21 Wörter raten (Web-Code: o2wh-jaz5)
• 7.22 Palindrome (Web-Code: brfr-qbyf)
• Kontrabass (Web-Code: xk5w-4mq7)
• Lefelsprache (Web-Code: 03w7-wetg)
• Liste von Zeichen in einem String (Web-Code: orwc-nq7i)
99
8 | Datenstrukturen und Sammelobjekte
Eigene Datentypen können aus den vorgegebenen Standardtypen (s. Kap. A.2 auf Seite 134)
zusammengesetzt werden. Links sehen Sie die Attribute, rechts die zugehörige UML47 -Notation.
Ein Clubmitglied weist z. B. die fol- UML-Notation:
genden Attribute auf :
• Name, Vorname, Adresse, Ort:

String
• Postleitzahl, Eintrittsjahr, Geburts-

jahr: integer (in Java int )
• Ehrenmitglied: boolean
In Java sieht diese Datenstruktur wie folgt aus:

public class Clubmitglied {
String name ;
String vorname ;
String adresse ;
String ort ;
int postleitzahl ;
int eintrittsjahr ;
int geburtsjahr ;
boolean ehrenmitglied ;
}
Neue Clubmitglieder (Objekte) werden mit dem new -Operator geschaffen. Dieser holt sich vom
System (Heap) genügend Speicher, um die Attributwerte festhalten zu können:
Clubmitglied c1 , c2 , c3 ;
c1 = new Clubmitglied ();

47
UML=Unified Modelling Language [Fre15].
101
8 Datenstrukturen und Sammelobjekte
8.1 Neuer Datentyp

Datentypen, welche wie oben beschrieben wurden, können nun genauso als Variable verwendet
werden, wie alle anderen auch. Im folgenden Beispiel wird eine Adresse gleich bei einer Person
als Datentyp eingesetzt:
public class Adresse {
String strassenname ;
int nr ;
}
public class Person {

String name ;
String vorname ;
int jahrgang ;
Adresse adresse ;
}
8.1.1 Zugriff
Auf die Attribute ( name , vorname , ...) wird nun analog zu den bekannten Attributen ( .length ,
...) mit dem . -Operator zugegriffen:
Person p ;
p = new Person ();
p . name = " Freimann " ;
System . out . println ( " Familienname : ␣ " + p . name );
Details zum . -Operator finden Sie in [Fre15]; dort im Kapitel 13.4.
Aufgabe 8.1 «Personen Erfassen» Schreiben Sie hierzu ein Java-Programm, das zwei Personen
erfasst und deren Daten inklusive alter (nicht Jahrgang) ausgibt.

8.2 Sammelobjekte
Spannend ist es, solche Objekte in Sammelobjekten – sog. Containern – zu speichern. Hier gibt
es natürlich die Arrays. Doch Arrays haben trotz ihrer Effizienz doch einige Nachteile48 . Daher
bietet Java im Paket java.util weitere Sammelobjekte an, von denen die wichtigsten hier
aufgelistet sind.
Collections werden verwendet, um Elemente hinzuzufügen um diese später wieder zu suchen oder
Operationen auf allen Elementen durchzuführen. Die wichtigsten Methoden von Collections sind
add() , contains() , remove() und size() .
• List: Die Elemente einer List sind linear geordnet, d. h. in der Reihenfolge, wie sie eingefügt
wurden. Meist wird die ArrayList verwendet.
List < String > namen ;
namen = new ArrayList < String >();
namen . add ( " Meier " );
namen . add ( " Mueller " );
namen . add ( " Keller " );
Beispiel einer List ist die ArrayList (s. Kap. 8.2.2 auf Seite 106).
• LinkedList: Geordnete Liste, bei der am Anfang und am Ende hinzugefügt, abgeholt und
gelöscht werden kann. Somit kann eine LinkedList auch als Queue (First-in/First-out War-
teschlange) oder Stack (First-in/Last-out Kellerspeicher) verwendet werden. Das Einfügen
in der Mitte geht sehr rasch, da nur zwei Referenzvariable (Pointer) gesetzt werden müssen.
Zugriff via Index und das Auffinden einzelner Elemente ist jedoch zeitaufwändig.
Im folgenden Beispiel wird ein Element am Anfang der Liste gelöscht:

List < String > spiele ;
spiele = new LinkedList < String >();
spiele . add ( " Fang ␣ den ␣ Hut " );
spiele . add ( " Go " );
spiele . add ( " Dame " );
spiele . add ( " Poker " );
spiele . add ( " Schach " );
spiele . remove (0); // -> geht rasch !
// nun alle ausgeben :

for ( String spiel : spiele ) {
System . out . println ( spiel );
}
48
Der größte Nachteil von Arrays ist die Unveränderbarkeit seiner Länge.
103
• (Hash)Map (Assoziative Arrays): Speichern der Objekte und Auffinden mit einem Schlüssel
(Key).
Beispiel Bücherliste:
978-3-280-04066-9 Programmieren lernen

3-411-04011-4 Die deutsche Rechtschreibung
0-201-89683-4 The Art of Computer Programming
3-8266-0883-6 Shell-Skript Programmierung
Details zur Java- HashMap : (s. Kap. 8.2.3 auf Seite 106)
• Tree: Baumstrukturen erlauben ein rasches, sortiertes Einfügen und Suchen. Zugriff via
Index ist ähnlich aufwändig wie bei Listen.
• Set = Menge: Elemente können nur einmal angefügt werden.
In Java bieten sich die beiden Sammelcontainer TreeSet und HashSet an. TreeSet
fügt die Elemente automatisch sortiert ein (implementiert also SortedSet ). Details (s. Kap.
8.2.4 auf Seite 107).

8.2.1 Beispiel Listen
Als konkretes Beispiel von Sammelobjekten wird hier die abstrakte Liste aus Java angegeben
( java.util.List ):
List < String > lst ;
lst = Arrays . asList ( " Montag " , " Dienstag " , " Mittwoch " ,
" Donnerstag " , " Freitag " , " Samstag " ,
" Sonntag " );
Listen werden in Schleifen auf die Selbe Weise wie Arrays (s. Kap. 6.1 auf Seite 88) durchaufen:
for ( String w : lst ) {
System . out . println ( w );
}
105
8.2.2 ArrayList
Der am häufigsten verwendete Sammelcontainer (Collection) in Java ist die ArrayList . Die
ArrayList hat im Gegensatz zu Arrays den Vorteil, dass Sie dynamisch erweiterbar sind. Mit
anderen Worten: Der Programmierer muss sich nicht von vornherein auf eine Maximalgröße fest-
legen.
Eine Liste von Punkten ( Point ) kann z. B. mit einem ArrayList -Objekt folgendermaßen kurz
und robust geschrieben werden:
ArrayList < Point > points = new ArrayList < Point >();
.... // Eintragen der Elemente in de Liste ...
while ( hatNochPunkte ()) {
points . add ( naechsterPunkt ());
}
8.2.3 HashMap
Als weiteres Beispiel wollen wir alle versicherten Personen einer mittleren49 Versicherungsgesell-
schaft in einer Datenstruktur speichern. Die AHV Nummer als Index bietet sich an und soll gleich
als Suchschlüssel verwendet werden. Arrays sind hier eine ganz schlechte Alternative. ArrayLists
sind besser, jedoch das Suchen kann sich als zeitaufwändig herausstellen. Mit ArrayLists könn-
te man die Elemente nach Suchschlüssel (hier der AHV Nummer) sortieren und dann eine binäre
Suche starten.
Das Einfügen von Elementen am Anfang oder in der Mitte wirkt sich bei ArrayLists ungünstig
auf die Performance aus.
Eine Lösung zu obigem Problem ist die Map .
HashMap map = new HashMap ();
map . put ( ahv1 , person1 );
map . put ( ahv2 , person2 );
// ...
p = ( Person ) map . get ( " 407.266.244.44 " );
Die HashMap speichert die Objekte in kurzen und rasch auffindbaren linearen Listen.
49
1 000 000 mittelgroße Datensätze können problemlos im RAM eines modernen Laptops verarbeitet werden.

8.2.4 Set
Ersetzen Sie in folgendem Code «ArrayList» durch «TreeSet» und besprechen Sie die Verände-
rungen in der Ausgabe. Zur Erinnerung: Ein Set (zu Deutsch eine Menge) kann jedes Element
nur einmal enthalten.
import java . util .*;
public class NamensListe {

new NamensListe (). top ();
}
Collection < String > namensListe = new ArrayList < String >();
void top () {
einlesenNamen ();
ausgabeNamensListe ();
}
void ausgabeNamensListe () {
for ( String str : namensListe ) {
System . out . println ( str );
}
}

private void einlesenNamen () {
while ( true ) {
System . out . println ( " Bitte ␣ Namen ␣ eingeben ␣ ( od . ␣ ENDE ): ␣ " );
String name = sc . nextLine ();
if ( " ENDE " . equals ( name )) {
return ; // Abbruch , falls Anwender " ENDE " eintippt .
}
namensListe . add ( name );
}
}
} // end of class NamensListe
Weitere Infos zum Java Collection Framework findet sich im Anhang (s. Kap. A.21 auf Seite
181).
107

• 8. 3 Fünfzehner-Spiel (Web-Code: 4ksp-tn54)
• 8. 4 Personen sortieren (Web-Code: bkqq-ryq7)
• 8. 5 Ringpuffer mit Arrays (Web-Code: yui8-z5du)

109
9 | Algorithmen
Algorithmen werden vorwiegend unabhängig von einer Programmiersprache formuliert. Hier zeige
ich einzig die Möglichkeit die Aufgabe «Heron» mit Java zu lösen:
float zahl = 5.0 f ;
float wurzel ;
wurzel = Math . sqrt ( zahl );
Wie Sie erkennen, ist der Algorithmus zum Wurzelziehen in Java bereits implementiert.
Viele Algorithmen, welche Programmierer immer und immer wieder selbst gelöst hatten, sind
heute in die Programmiersprachen eingebaut. Dazu gehören nicht nur die mathematischen Be-
rechnungen wie obige Wurzel, trigonometrische Funktionen und dergleichen. Auch das Sortieren
von Objekten, das Erstellen von Eingabefeldern bis hin zum Schattenwurf dreidimensionaler Ob-
jekte gehört heute zum besseren Programmiergerüst.
Bemerkung 9.1. Wir lösen hier (in vergangenen und folgenden Aufgaben) vorwiegend Probleme,
welche schon gelöst sind. In der Praxis wird dies wohl kaum getan. Viele dieser Problemstellungen
sind einfacher mit einer Tabellenkalkulation oder mit einem Taschenrechner lösbar.
Dennoch: Zum Lernen gehört es dazu, viel zu üben und zu erkennen, welche Denkarbeit und
welche Konzepte hinter einer bestehenden Lösung stecken.
Wir lernen im Mathe-Unterricht das Ziehen einer Wurzel oder das Auflösen eines Gleichungs-
systems mit mehreren Unbekannten ja auch nicht nur zum Spaß von Hand.50 Es geht darum,
bestehende Verfahren zu kennen und daraus zu lernen; nur so ist es möglich, neue, bessere Algo-
rithmen zu entwickeln.
50
Wurzelziehen und Gleichungssysteme Lösen können Computer heute viel schneller; mehr noch: Ha-
ben wir keine Fehler in der Eingabe, so sind die Computerlösungen meistens auch fehlerfrei. Siehe z. B.
http://www.wolframalpha.com .
111
9 Algorithmen
9.1 Leseaufgaben
Das Lesen von Programmcode fördert das exakte Vorgehen und – sofern der Code sauber ge-
schrieben ist – zeigt gleichzeitig auf, wie Code geschrieben werden sollte.
Die folgenden Übungen (9.1.1 - 9.1.7) sind immer nach demselben Muster zu lösen:
• Wählen Sie einfache Parameter (z. B. 0, 1, 2, -1).
• Zeichnen Sie immer eine Wertetabelle.
• Gehen Sie Schrittweise und exakt vor. Der Zeigefinger der linken51 Hand dient hier als
Programmzeiger, also dieses Register, das auf den nächsten auszuführenden Befehl zeigt.
Die rechte Hand verwenden Sie, um die Wertetabelle nachzuführen.
• Machen Sie eine erste Aussage, was das Programm tun könnte.
• Wählen Sie komplexere Parameter (z. B. 7, 11, 16, -0.5, 3.844, . . . ).
• Überprüfen Sie (in gleichem Schrittweisen Vorgehen), ob Ihre Hypothese zutrifft.
• Optional: Belegen Sie die Hypothese.
9.1.1 Selektion
int was ( int a , int b , int c )

{
int d = a ;
if ( b < d ) {
d = b;
}
if ( d > c ) {
d = c;
}
return d ;
}
51
Für Linkshänder: «Der Zeigefinger der rechten Hand»

9.1.2 Iteration (Schleife)
int was ( int a )

{
int i = 0;
int j = 1;
int k = 0;
while ( i < a ) {
k = k + j;
j = j + 2;
i = i + 1;
}
return k ;
}
9.1.3 Selektion und Iteration
int was ( int a )

{
if ( a < 0)
{
print ( " Fehler , ␣ a ␣ muss ␣ >= ␣ Null ␣ sein " );
return 0;
}
int b = 0;
while ( a > 0)
{
b = (10 * b );
b = b + ( a % 10); // %: bedeutet hier modulo = Divisionsrest
a = a / 10; // Ganzzahlige Division (64 / 10 ergibt 6).
}
return b ;
}
113
9 Algorithmen
9.1.4 Zahlenspielerei
int was ( int a )

{
int b = 0;
int c = 1;
int d = 0;
while ( a > 0) {
// % == Divisionsrest
// (z. B. 243 % 10 == 3):
d = a % 10;
b = c * 11 * d + b ;
c = 100 * c ;
a = ( a - d ) / 10;
}
return b ;
}
9.1.5 Fuß-gesteuerte Schleife
int was ( int a )

{
int b = 2;
int c ;
if (0 == a ) {
return a ;
}
do {
c = a % b;
if (0 == c ) {
return b ;
}
b = b + 1;
} while ( b < a );
return a ;
}

9.1.6 Nur für Spieler ;-)
boolean was ( int arr []) { // Array aus 5 Integers [0..4]

int r1 = arr [0];
int r2 = r1 ;
for ( int i = 1; i < 5; i ++) {
if ( arr [ i ] != r1 ) {
r2 = arr [ i ];
}
}
if ( r1 == r2 ) {
return false ;
}
int c1 = 0;
int c2 = 0;
for ( int i = 0; i < 5; i ++) {
if ( arr [ i ] == r1 ) {
c1 ++;
}
if ( arr [ i ] == r2 ) {
c2 ++;
}
}
return (2 == c1 && 3 == c2 ) || (3 == c1 && 2 == c2 );
}
115
9 Algorithmen
9.1.7 Ein sehr alter Algorithmus
double was ( double a ) {

double aj , d , dx ;
double ai = a ;
if ( a <= 0.0) {
System . out . println ( " Nur ␣ positive ␣ Zahlen ! " );
return 0.0;
}
do {
aj = ai ;
d = ( aj * aj - a ) / 2.0 / aj ;
ai = aj - d ;
dx = aj - ai ;
} while (( dx * dx ) > 0.00001);
return ai ;
}
Die Lösungen zu diesen Aufgaben finden wir im Anhang (s. Kap. B auf Seite 191).

• 9. 1 Heron (Web-Code: kugc-tg53)
• 9. 2 Gray Code (Web-Code: gtwa-psr3)
• 9. 3 Primzahlen (Web-Code: 6yqz-4y5k)
• 9. 4 Primzahlsieb des Eratosthenes (Web-Code: tmx9-wf4j)
• 9. 5 Römische Zahlen (Web-Code: sv9k-jktq)
• 9. 6 Wörter suchen (Web-Code: 9nz3-nf8o)
• 9. 7 Lexikographisch sortieren (Web-Code: t42p-7sny)
• Wortlisten-Generator (Web-Code: ankq-6hca)
• Syntaxtest (Web-Code: qref-kf3p)
• Defiziente Zahl (Web-Code: 33hu-hrjs)
• Rechendreieck (Web-Code: 7kgw-uozz)
• Kürzester Weg (Web-Code: inyb-yc9q)
• Das Tortenproblem (Web-Code: 8ijp-jc7u)
• Ernö Rubiks Zauberwürfelalgorithmen (Web-Code: vymw-b4k7)
117
10 | Simulationen
Java wurde nicht wegen seiner Syntax bekannt. Java machte sich dank seiner Hilfsklassen und
seiner enorm großen API populär. Für alle gängigen Probleme hat Java eine Lösung bereit, wie
auch z. B. für das Erzeugen sog. Pseudozufallszahlen:
10.1 Random
Wer seine eigenen Pseudozufallszahlen braucht, kann Aufgabe 10.1 aus [GFG11] lösen. Das dort
beschriebene Verfahren der «linearen Kongruenzmethode» funktioniert in allen Programmierspra-
chen. Doch Java bringt schon mächtige Zufallszahl-Implementationen mit sich:
Pseudozufallszahlen können in Java auf zwei Arten gefunden werden. Die einfache und schnelle
Art ist die Methode Math.random() , die eine Zahl zwischen 0 und 1 liefert52 .
Um z. B. Prüfungsnoten zu simulieren kann ein Lehrer nun wie folgt vorgehen:
int note = ( int ) ( Math . random () * 6 + 1);
Eine zweite Variante ist das Verwenden eines Objektes der Klasse java.util.Random . Hiermit
können häufig verwendete Zufallsgrößen ( int , long , boolean ) einfach erzeugt werden.
Ein weiterer Vorteil der Klasse Random ist die Methode setSeed() . Diese erlaubt es, in Test-
simulationen immer wieder dieselbe Zufallssequenz zu erzeugen. Die Methode nextGaussian()
liefert eine normal verteilte Zufallszahl mit Mittelwert 0.0 und Standardabweichung 1.0.
52
Null ist dabei eingeschlossen, 1 ist ausgeschlossen. Mathematisch: [0, 1)
119
10 Simulationen

• 10. 1 Lineare Kongruenzmethode (Web-Code: qqrc-bps2)
• 10. 2 Ganze Zufallszahlen (Web-Code: 8v6n-j82y)
• 10. 3 Würfel (1) (Web-Code: r2hn-k3om)
• 10. 4 Casino (Würfel 2) (Web-Code: 5n2a-jfjb)
• 10. 5 Web-Code (Web-Code: d2rh-rur6)
• 10. 6 Farbstiftspitzen (Web-Code: i7ox-fcxf)
• 10. 7 Nummern-Ratespiel (Web-Code: 4i5d-58ws)
• 10. 9 Poker verteilen (Web-Code: i4si-4ts5)
• 10.10 Geburtstagszwillinge (Web-Code: aadv-mxmq)
• 10.12 Reisegruppe (Web-Code: aoy8-chnm)
• 10.13 25 im Quadrat (Web-Code: ydd3-8ozc)
• 10.14 Magisches Quadrat (Web-Code: cmi5-4vwv)
• 10.15 Socken (Web-Code: rs4y-t2k2)
• 10.16 Quintenzirkel (Web-Code: v8mr-dw3x)
• 10.17 Neuweltkamele (Web-Code: jsqi-792x)
• 10.19 Umschütten (Web-Code: dob2-r5tp)
• 10.20 Monte-Carlo-Methode zu Bestimmung von Pi (Web-Code: rvf2-f92q)
• 10.21 Räuber-Beute-Verhalten (Lotka/Volterra) (Web-Code: 47gv-shif)
• 10.22 Conways Game of Life (Web-Code: ch5c-67pm)
• 10.24 Testdaten mit Reservoir (Sampling) (Web-Code: x8kv-r9ij)
• Mit dem Auto, dem Zug, dem Fahrrad oder zu Fuß? (Web-Code: tfod-exee)
• Schülernoten (Web-Code: aj6w-74tw)
• Code-Knacken (Web-Code: d4ko-cgvt)
• Schiffsglocke (Glasen) (Web-Code: jwpg-qcth)

121
11 | Rekursion
Subroutinen, die sich selbst direkt oder indirekt aufrufen, nennt man rekursiv.
Zur Veranschaulichung habe ich zwei spezielle Beispiele herausgepickt.
11.1 Beispiel Fibonacci

Als Beispiel soll (auch in dieser Einführung) die Folge von Fibonacci53 herhalten. Jedes neue Glied
der Folge wird aus der Summe der beiden letzten Glieder gebildet (z. B. 8 = 3 + 5).
Der Anfang der Folge lautet wie folgt:
1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 , 89 , ...
Natürlich kann das mit einer Schleife (iterativ) programmiert werden. Die Funktion fib() soll
das Element an einer vorgegebenen Position ausgeben (z. B. fib(7) = 13).
Iterative Lösung
public int fib ( int pos )
{
if ( pos < 3)
{
return 1;
}
int a = 1 , b = 1;
for ( int i = 2; i < pos ; i ++)
{
int next = a + b ;
a = b;
b = next ;
}
return b ;
}
Erklärung: In obigem Code bezeichnen a , b und next drei aufeinander folgende Glieder der
Fibonacci-Reihe. Nach dem Berechnen von next werden a und b entsprechend neu «abgefüllt»,
sodass next jeweils nur als temporäre Variable einen gültigen Wert aufweist.
53
Leonardo «Fibonacci» von Pisa (ca. 1180 – 1241) über das Wachstum einer Kaninchenpopulation (S. Wikipe-
dia)
123
11 Rekursion
Rekursive Lösung
Rekursiv ist das Programm aber einfacher, intuitiver und somit weniger fehleranfällig und besser
wartbar (leider aber auch weniger performant).
{
if ( pos < 3)
{
return 1;
}
return fib ( pos - 2) + fib ( pos - 1);
}
Wir sehen, dass die rekursive Programmierung viel weniger fehleranfällig ist. Der Code wird kurz
und verständlich. In diesem Fibonacci-Beispiel hingegen ist der rekursive Code nicht wirklich
performant (= rasch in der Ausführung). Die iterative Lösung (Beispiel davor) ist hier immens
schneller, denn jede Zahl wird nur einmal berechnet. Wird in einer Rekursion die Funktion – wie
hier – gar doppelt aufgerufen, so wächst die Laufzeit quadratisch an.
Lösung mit Formel
Am schnellsten (wenn auch am wenigsten verständlich) ist eine (geschlossene) mathematische
Formel.
double phi = 1 . 6 1 8 0 3 3 9 8 8 7 4 9 8 9 4 8 4 8 2 0 45 8 6 8 3 4 3 6 5 6 3 8 1 1 7 7 2 0 3 0 9 1 7 98 ;
double wurzel5 = 2 . 2 3 6 0 6 7 9 7 7 4 9 9 7 8 9 6 9 6 4 0 9 1 7 3 6 6 8 7 3 1 2 7 6 2 3 5 4 4 0 6 1 8 3 5 9 6 ;
{
double result ;
result = Math . pow ( phi , pos ) / wurzel5 ;
// Runden und zurueckgeben :
return ( int ) ( result + 0.5);
}

11.2 Beispiel Ebene zerschneiden
Das zweite Beispiel teilt eine Ebene mit beliebigen (also nicht parallelen) Geraden in Teilebenen.
Eine einzige Gerade teilt die Ebene in zwei Teilebenen, zwei Geraden teilen die Ebene bereits
in vier Teile, und kommt eine dritte Gerade hinzu, so kommen drei Teilebenen hinzu; die Ebene
wird also insgesamt in sieben Teile geschnitten (s. obige Grafik).
Begründen Sie, warum bei der n-ten Gerade genau n Teilebenen hinzukommen.
Begründen und implementieren Sie die folgenden Algorithmen (iterativ, rekursiv, mit Formel):
Iterative Lösung
int teilebenen ( int geraden )
{
int teilebenen = 1;
for ( int i = 1; i <= geraden ; i ++)
{
teilebenen = teilebenen + i ;
}
return teilebenen ;
}
Rekursive Lösung
{
if (0 == geraden )
{
return 1;
}
return geraden + teilebenen ( geraden - 1);
}
Lösung mit Formel

{
return 1 + geraden * ( geraden + 1) / 2;
}
125
11 Rekursion
11.3 Vor- und Nachteile der Rekursion

Vorteile Nachteile
• weniger Code • evtl. sehr langsam in der Ausführung

(Laufzeitverhalten nicht intuitiv)
• dadurch weniger Fehleranfällig
• möglicher Stack-Overflow (bei Vergessen
• verständlicher der Abbruchbedingung)
• dadurch wartbarer • schwer zu debuggen

• 11. 1 Merge Sort (Web-Code: puyx-no2s)
• 11. 2 Fibonacci (Web-Code: xqh4-mv36)
• 11. 3 ggT rekursiv (Web-Code: ctnh-j2cr)
• 11. 4 Lotto (Web-Code: epsk-xisf)
• 11. 5 Unterverzeichnisse ausgeben (Web-Code: udy5-egzz)
• 11. 6 Türme von Hanoi (Web-Code: fk8y-npoa)
• 11. 7 Kamele beladen (Web-Code: 6gdd-r4zm)
• 11. 8 Schnurlängen (Web-Code: acgo-5ap7)
• 11. 9 Dichtestes Punktepaar (Web-Code: a93s-2si4)
• 11.10 Malermeister Malcom (Web-Code: durv-de6t)
127
A | Anhang
«Was ich sonst noch alles sagen wollte»
A.1 Installation und erstes Java-Programm

Die Java-virtuelle Maschine (kurz JVM) ist heutzutage auf fast allen Rechnern vorinstalliert.
Doch um Java zu programmieren, muss auch ein Übersetzungsprogramm, der sog. Compiler
verwendet werden, der aus den Java-Quelltexten (dem eigentlichen Programmtext) den Java-
Maschinencode produziert.
Der Java-Compiler, wie auch die JVM, sind Teile des «Java Developer Kits», kurz JDK.
129
A Anhang
A.1.1 Installation
Laden Sie den Java-Compiler ab der Webseite des Anbieters herunter:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Starten die das Installationsprogramm für Ihr Betriebssystem.
Die Installation kann einfach in einer Konsole (command-line, cmd, shell, BASH) überprüft wer-
den. Dazu öffnen Sie die Konsole (Windows: Start -> Ausführen -> cmd; Mac/Unix/Linux:
Terminal oder xterm).
Tippen Sie nun folgendes in die Konsole
javac
und bestätigen Sie die Eingabe mittels der Enter-Taste.

Ist Java korrekt installiert, so erscheint eine Meldung wie folgt:
Usage : javac < options > < source files >
where possible options include :
-g Generate a ...
...
Sollte Java nicht korrekt installiert sein, so erscheint ein Meldung im folgenden Stil:
Der Befehl " javac " ist entweder falsch geschrieben oder
konnte nicht gefunden werden .
oder
No command ’ javac ’ found , did you mean :
...
Falls Java nicht korrekt installiert ist, so könnten die folgenden Tipps weiterhelfen:
• Neustart des Computers nach der Installation von Java.
• Aufsuchen des Programms javac und den gefundenen Pfad in die Systemvariable %PATH%
zu verankern. Danach Neustart der Konsole ( cmd ).
• Neuinstallation des JDK (evtl. wurde JVM anstelle JDK installiert).
• Suche im Internet nach «Installation JAVA PATH». Und geben Sie dabei noch den Namen
Ihres Betriebssystems an (z. B. Linux, Ubuntu, MacOS, Windows, ...).

A.1.2 Erstes Programm
Tippen Sie das erste Programm aus dem Einleitungskapitel (S. Seite 15) mit einem Texteditor
ab und speichern Sie dieses unter dem Namen « MeinErstes.java ».
Öffnen Sie die Konsole und springen Sie mit dem Kommando cd 54 ins Verzeichnis, wohin sie die
Quelldatei MeinErstes.java gespeichert hatten.
Tippen Sie nun
javac MeinErstes . java
Sollte gleich wieder die Kommandozeile (Eingabeaufforderung) erscheinen, so ist alles gut gelau-
fen.
Bei Erfolg gibt der Java-Compiler ( javac ) keine Meldung aus. Allfällige Fehlermeldungen
werden ausgegeben und müssen zuerst verbessert werden (s. Kap. A.1.3 auf Seite 132).
Werden keine Fehler gemeldet, so können Sie nun mit dem Befehl
java MeinErstes
das Programm starten. Nun sollte « Hallo Welt » in der Konsole erscheinen. Geschieht dies nicht,
versuchen Sie auch:
java - cp . MeinErstes
Sollte « Hallo Welt » immer noch nicht erscheinen, lesen Sie auf der nächsten Seite weiter im
Kapitel «Fehlerbehandlung».
54
cd bedeutet so viel wie «change directory» oder eben «wechsle das Verzeichnis».
131
A Anhang
A.1.3 Fehlerbehandlung
Wie überall, wo die Gattung «Homo» am Werk ist, können Fehler passieren. Die folgende Aufzäh-
lung zeigt, welche Fehlermeldungen bei den ersten Java-Programmen auftauchen können und
wie diese zu beheben sind.
• javac: file not found : Java wurde nicht korrekt installiert.
• cannot find symbol : Ein Name wurde falsch geschrieben. Zum Beispiel string statt
String . (Achtung: Java unterscheidet zwischen Groß- und Kleinschreibung).
• package system does not exist : system wurde klein statt groß geschrieben.
• reached end of file while parsing : Könnte eine fehlende geschweifte Klammer sein.
• ; expected : Es wird ein Strichpunkt erwartet. Oft wird dieses Ende einer Anweisung
vergessen.
• Hello.java:1: class Hallo is public,

should be declared in a file named
Hallo.java : Der Dateiname entspricht nicht dem Klassennamen (Hello ist nicht gleich
Hallo). Beachten Sie auch Groß- und Kleinschreibung bei Filenamen.
• Exception in thread "main" java.lang.Error: Unresolved compilation problem :

IDE-Fehler z. B. eclipse. Es wurde versucht, das Programm zu starten, obschon es noch Feh-
ler aufweist.

Eine häufige Fehlermeldung ist hier
Exception in thread "main" java.lang.NoClassDefFoundError: ... Das bedeutet, dass
die virtuelle Maschine zwar richtig installiert wurde, aber dass die kompilierte Klasse (bzw. das
MeinErstes.class -File) nicht gefunden werden konnte. Stellen Sie sicher, dass das aktuelle
Verzeichnis die Datei Hello.class enthält (dies ist mit dem Kommando ls bzw. dir zu
testen).
Ein weiterer häufiger Fehler ist die Meldung
Exception in thread "main"
java.lang.NoSuchMethodError: main"
Dies wiederum bedeutet, dass die main() Methode entweder falsch geschrieben wurde, nicht
static ist oder falsche Parameter aufweist: Korrekt ist:
public static void main ( String [] args )
Bei Problemen lesen Sie dieses Kapitel nochmals durch bzw. suchen Sie im Internet nach der
exakten Fehlermeldung. Bei “www.google.com” wird man meistens fündig. Sollte es jedoch in
dieser Anleitung Fehler haben, so melden Sie dies bitte direkt dem Autor [email protected] .
133
A Anhang
A.2 Datentypen
Java kennt die folgenden Datentypen55 : Streng objektorientierte Sprachen kennen keine «pri-
mitive Datentypen»: Java wählte diesen Weg aufgrund der Performance (also der Rechenge-
schwindigkeit).
Datentyp Beschreibung Beispiele zugehöriger Java-Literale
(Konstanten)
boolean wahr oder falsch true , false
byte ganze Zahl -128 bis 127 55 , -83
short ganze Zahl (2 Byte), 1000 , -4000
-32 768 bis 32 767
int ganze Zahl (4 Byte) -200_000 , 1_500_000_000
long ganze Zahl (8 Byte) 7_000_000_000_000_000
float Dezimalbruch (4 Byte) 4.3f , 3.882f , -2.8e3f
double Dezimalbruch (8 Byte) Doppelte -3.141592653589793 , 3.48e-150
Genauigkeit
char Zeichen ’x’ , ’7’ , ’@’ , ’-’ , ’#’ , \n , \uCAFE ,
...
String Zeichenkette, Wort "Hallo Welt"
55
In Java sind alle Zahlen positiv oder negativ darstellbar; mit anderen Worten handelt es sich um «Vorzeichen
behaftete» Zahlen

Bemerkungen:
• Java verwendet für die Ganzzahltypen ( byte , short , int , long ) das so genannte Zwei-
erkomplement (S. [GFG11] Aufgabe 1.9). Die Zahl -2 wird also im Bitmuster ...11 1111 1110
dargestellt.
• Große Zahlen 2_000_000 dürfen in Java, der verbesserten Leserlichkeit zuliebe, mit Un-
terstrichen ( _ ) versehen werden.
• Bemerkung zu float und double : Diese beiden Datentypen unterscheiden sich lediglich
durch die Genauigkeit. float ist weniger genau, benutzt auch weniger Speicher und ist in
der Regel auch schneller bei Berechnungen als der double . Sowohl bei float , wie auch bei
double kann mit einem hinten angestellten f (bzw. d ) der Datentyp spezifiziert werden.
• Ein Java- char ist ein Unicode-Zeichen, das mit 16 Bit kodiert ist. Mit \n wird das
«Neue-Zeile» Symbol geschrieben, was für einen Zeilenumbruch sorgt. Unicode-Werte kön-
nen auch Hexadezimal eingegeben werden. Dabei wird ein \u vorne hin gestellt. Beispiel
\u03C6 = ϕ
• Bemerkung zum String : der String ist kein primitiver Java-Datentyp. Dabei han-
delt es sich um eine Klasse, welche den Regeln der Objektorientierung folgt. Ich habe den
String dennoch aufgeführt, denn auch der String besitzt in Java eigene Literale (z. B.
"Hallo Welt" ).
135
A Anhang
A.3 Die Kommandozeile (Shell bzw. CMD)

Wollen wir Java-Programme ohne eine integrierte Entwicklungsumgebung (wie eclipse oder
netbeans) schreiben, so können wir auf ein Terminal (Linux: shell, MS-Windows: Kommandozei-
leneingabe (CMD)) zurückgreifen. Hier die wichtigsten Kommandos:
Titel Linux Windows Beschreibung
(BASH) (CMD)
Laufwerk cd /x/y c: Unter Linux muss das Laufwerk bereits ein-
wechseln gebunden sein, damit in ein anderes Lauf-
werk gewechselt werden kann. Viele Distri-
butionen binden Laufwerke im Verzeichnis
/media ein. In diesem Beispiel ist /x/y
mit dem aktuellen Namen des Verzeich-
nisses auszutauschen. Unter Windows wer-
den Laufwerksbuchstaben verwendet, ge-
folgt von einem Doppelpunkt ( a: , b: , ...).
Verzeichnis cd <pfad> cd <pfad> Mit cd (= change directory) wird in ein Un-
wechseln terverzeichnis gewechselt. <pfad> ist hier
mit dem Namen des gewünschten Verzeich-
nisses auszutauschen. Sowohl Unix, wie
auch Windows erlauben eine Ergänzung mit
der TAB-Taste: Es reicht, die ersten Buch-
staben einzugeben und danach die TAB-
Taste zur Befehlsergänzung zu tippen.
Top Verzeichnis cd / cd \ Wechselt ins oberste Verzeichnis (root).
Übergeordnetes cd .. cd.. Wechselt ins übergeordnete Verzeichnis; al-
Verzeichnis so ein Verzeichnis «hinauf».
List ls dir Stelle den Inhalt des aktuellen Verzeichnis-
ses als Liste dar.
Löschen rm <abc> del <abc> Lösche die Datei <abc> .
Verzeichnis mkdir <abc> mkdir <abc> Erstelle ein Verzeichnis mit Namen <abc> .
erstellen
Stopp CTRL-c CTRL-c Halte die CTRL (STRG)-Taste und drücke
gleichzeitig den Buchstaben «c». Unterbre-
che die aktuelle Ausführung (z. B ein nicht
endendes Java-Programm).
Ende exit exit Verlasse die Kommandozeile.
Hilfe man <cmd> help <cmd> Hilfe zum Kommando <cmd> anzeigen.
man steht hierbei für «manual».

A.4 Strukturierter Java Code
Java ist eine weitgehend objektorientierte Sprache. Dass damit aber auch Software nach dem
strukturierten Paradigma geschrieben werden kann, sollte nach der Lektüre dieses Büchleins klar
sein (Java unterstützt alle fünf56 prozeduralen Konzepte). Java macht es einem hier aber nicht
leicht, denn für alles wird sofort eine Klasse und ein Objekt erwartet. Der folgende «JavaStarter»
(Codebeispiel nächste Seite) kann benötigt werden, um kleine strukturierte Programme wie in
[GFG11] zu schreiben.
Vergessen Sie aber nicht, den Namen « JavaStarter » durch Ihren Programmnamen zu ersetzen.
Dies muss an drei Stellen geschehen: a) Der Filename, b) der Klassenname und c) im der main() -
Methode beim Erstellen des Objektes mit new() .
56
1. Sequenz, 2. Selektion, 3. Iteration, 4. Unterprogramme, 5. alle Programmabläufe sind ohne «goto» (also
«Jumps») möglich.
137
A Anhang
/* *
* Java Starter , damit Sie rein strukturiert loslegen koennen ,
* ohne sich um Objekte kuemmern zu muessen .
* Aendern Sie den Filenamen ,
* den Klassennamen und
* den top () - Aufruf .
* " Ihre Dokumentation kommt hier ... "
*/
public class JavaStarter { // <- hier anpassen
{
new JavaStarter (). top (); // <- hier anpassen
}
// Hier gehoeren die globalen Variablen hin :

String anrede ;
// Ebenso werden Funktionen hier definiert :

void hallo ()
{
System . out . println ( " Hallo ␣ " + anrede );
}
// Hier ist der Haupt - Einstiegspunkt :

void top ()
{
// Hier ist Platz fuer lokale Variable :
String temporaer = " Welt " ;
// Hier folgen die Anweisungen :

anrede = " Universum " ;
System . out . println ( " Hallo ␣ " + temporaer );
hallo ();
}
} // end of class JavaStarter
Tippen Sie diesen Code ab, oder laden Sie ihn ab

http://www.gress.ly/javastarter herunter.

A.5 Reservierte Wörter
Als Namen (Variable, Subroutinen, Klassen, ...) können Sie beinahe jedes Wort verwenden. Groß-
buchstaben, Kleinbuchstaben, der «Underscore» (Bodenstrich), sogar Währungssymbole ($, £,
...) und Ziffern sind erlaubt, wenn letztere nicht an erster Position stehen.
Die folgenden Wörter heißen Schlüsselwörter. Diese haben in Java jedoch eine spezielle Bedeu-
tung und dürfen nicht als Bezeichner eingesetzt werden:
abstract default if private throw
assert do implements protected throws
boolean double import public transient
break else instanceof return try
byte enum interface short void
case extends int static volatile
catch finally long strictfp while
char final native super
class flat new switch
const for null synchronized
continue goto package this
Die Bedeutungen finden Sie hier:
http://www.santis-training.ch/java/javasyntax/keywords
139
A Anhang
A.6 Ein- und Ausgabe

A.6.1 Ausgabe
Die Ausgabe von Werten in Java auf der Konsole ist relativ einfach:
System.out.println(...);
Texte und Zahlen werden in der Regel so formatiert, wie wir es gerne hätten. Um Ausgaben
aneinander zu fügen, verwenden wir den Plus-Operator:
int x;
String s ;
x = 4;
s = " Hallo ␣ Welt " ;
System . out . println ( " Ausgabe : ␣ " + x + s );
Zur Erinnerung ans Kapitel «Zeichenketten» (s. Kap. 7.5 auf Seite 97)
sei hier nochmals ein einfacheres Zahlenbeispiel gegeben.
Da der Plus Operator (+) auch für Zahlen verwendet wird, ist beim
ersten Betrachten nicht klar, was hier ausgegeben wird:
int x , y ;
x = 4;
y = 5;
System . out . println ( x + y + " ␣ ist ␣ " + x + y );
Zunächst werden die Zahlen (von links nach rechts) als Zahlen zusammen-
gezählt und danach wird die Zeichenkette " ist " angefügt. Schließlich
wird x und y je in eine Zeichenkette verwandelt und dem bestehenden
hinzugefügt. Resultat: 9 ist 45 !
Erinnern Sie sich an die Klammerungsreihenfolge von Links nach rechts.
Der «+»-Operator fügt genau dann Zeichenketten zusammen, wenn einer der beiden Operanden
eine Zeichenkette ist. Ansonsten werden einfach die Zahlen zusammengezählt.

A.6.2 Eingabe
Daten für die Programmausführung werden entweder aus persistenten Speichern (Datenbanken,
Files, . . . ) geladen, sie werden beim Programmstart mitgegeben, oder der Benutzer kann sie zur
Laufzeit eingeben oder laden lassen.
Alle Texte und Zahlen, die in einem Programm verwendet werden, gehören nicht in den Quellcode.
Texte und Zahlen können sich bei einer weiteren Ausführung des Programmes verändern. Somit
müsste ja das Programm angepasst werden
Hier einige Beispiele von Texten und Zahlen, die nicht in den Quellcode gehören:
• Beschriftungen von Buttons (Knöpfen) und Labels (Diese müssen Sprachunabhängig gehal-
ten werden.)
• Ausgabetexte (z. B. «sehr gut» für Schülernote 6).
• Konstanten (z. B. Die Zahl π besser aus java.lang.Math verwenden statt 3.1415926 in
den Code fix eingeben.)
Geek Tipp 10
Nur die Zahlen Null (0) und Eins (1) bzw. die Literale false und true dürfen im Code auf-
tauchen. Andere Zahlen oder sprachabhängige Zeichenketten im Quelltext stören die Programm-
entwicklung permanent.
Persistente Daten werden aus Datenbanken oder Eigenschaftsdateien (sog. Property-Files) gele-
sen. Transiente Daten werden zur Laufzeit z. B. vom Anwender erfragt.
141
A Anhang
Das Einlesen von Text aus der Konsole gestaltet sich schon schwieriger. Gleich ein Beispiel:
import java . util . Scanner ;
public class Eingabe {

{
new Eingabe (). top ();
}
String name ;
int alter ;
void top ()
{
System . out . print ( " Geben ␣ Sie ␣ Ihren ␣ Namen ␣ ein : ␣ " );
name = new Scanner ( System . in ). nextLine ();
System . out . println ( " Hallo ␣ " + name );
System . out . print ( " Wie ␣ alt ␣ sind ␣ Sie : ␣ " );

alter = new Scanner ( System . in ). nextInt ();
System . out . println ( " Gratuliere ␣ im ␣ Nachhinein ␣ zum ␣ "
+ alter + " . " );
}
} // end of class Eingabe
Zu bemerken ist einerseits die «import»-Anweisung. import java.util.Scanner sagt sowohl

dem Compiler, wie danach auch der Java-virtuellen Maschine, wo die Klasse Scanner zu finden
ist.

Achtung: Je nach Konsole können nicht zwei int (also ganze Zahlen) hintereinander eingelesen
werden, denn dazwischen befindet sich i. d. R. noch ein «Newline»-Zeichen. Es bietet sich hier an,
immer nur den nextLine() -Ausdruck zu verwenden und die Inhalte (ob Zahl, ...) im Nachhinein
zu unterscheiden. Dies ermöglicht auch eine saubere Fehlerbehandlung:
String eingabe ;
int x = 0 ;
eingabe = new Scanner ( System . in ). nextLine ();

try {
x = Integer . parseInt ( eingabe );
} catch ( NumberFormatException nfe ) {
System . out . println ( " Fehler ␣ in ␣ Zahl : ␣ " + eingabe );
}
Ein komplexeres Beispiel wie dies gemacht werden könnte, finden Sie hier:
https://github.com/pheek/javaInput/blob/master/Input.java
143
A Anhang
A.6.3 Eingabe- und Ausgabeumlenkung
Die Ausgabe System.out , sowie die Eingabe System.in können leicht in Dateien umgeleitet
werden.
Betrachten wir eine kleine Modifikation des vorangehenden Programmes (Beachten Sie, dass der
Scanner nun nur einmal mit new erstellt wird):
import java . util . Scanner ;
public class EinAus {

{
new EinAus (). top ();
}
String name ;
String alterString ;
int alter ;
void top ()
{
System . out . print ( " Geben ␣ Sie ␣ Ihren ␣ Namen ␣ ein : ␣ " );
name = sc . nextLine ();
System . out . println ( " Hallo ␣ " + name );
System . out . print ( " Wie ␣ alt ␣ sind ␣ Sie : ␣ " );

alterString = sc . nextLine ();
alter = Integer . parseInt ( alterString );
System . out . println ( " Gratuliere ␣ im ␣ Nachhinein ␣ zum ␣ "
+ alter + " . " );
}
} // end of class EinAus
Erstellen Sie zudem die folgende Datei ( daten.txt )mit den gewünschten eingaben:
James Gosling
60

Starten Sie nun das obige Java-Programm aus der Konsole:
java EinAus < daten . txt
Die Daten werden nun nicht mehr aus von der Konsole, sondern aus der Datei daten.txt gelesen.
Natürlich können die Resultate auch in eine Datei umgeleitet werden, anstatt auf der Konsole
ausgegeben zu werden:
java EinAus < daten . txt > ausgabe . txt
145
A Anhang
A.7 Weglassen der geschweiften Klammer
Die geschweiften Klammern (« { », « } ») bei if , else und while können in Java weggelassen
werden, sofern es sich im auszuführenden Anweisungsblock um genau eine einzige Anweisung
handelt.
Eine ausführliche Beschreibung dieser «Falle» habe ich hier veröffentlicht:
http://www.santis-training.ch/java/pitfalls.php#c
(Siehe dort im Kapitel «Iteration, Selektion und Strichpunkte».)

A.8 Anmerkungen zur Iteration
A.8.1 Warnung Strichpunkte
Implementieren Sie folgendes in Java und erklären Sie das Resultat:

int x = 5;
if (10 == x );
{
System . out . println ( " if : ␣ x ␣ = ␣ " + x );
}
while ( x >= 5);
{
x = x - 1;
System . out . println ( " while : ␣ x ␣ = ␣ " + x );
}
Java kennt – im Gegensatz zu anderen Sprachena – keinen Strichpunkt

nach der Bedingung. Dies gilt sowohl für die Selektion ( if ), wie auch
für die Iteration ( while ). Ein Strichpunkt an dieser Stelle entspricht in
Java einer leeren Anweisung.
Obiges if zwar als falsch ausgewiesen, jedoch wird die Print-Anweisung
trotzdem ausgeführt (sie kommt ja erst nach dem if -Block).
Ebenso schlittert die while -Schleife in eine sog. Endlosschleife. Denn
der angegebene Block wird nie durchlaufen, sondern es wird lediglich
permanent die leere Anweisung ( ; ) ausgeführt.
a
Die Sprache PL/I verlangt nach der Bedingung einen Strichpunkt.
147
A Anhang
A.8.2 Schleifeninvarianten
Als Schleifeninvariante oder Iterationsinvariante bezeichnen wir Programmanweisungen innerhalb

von Programmschleifen, falls diese ebenso gut außerhalb der Schleife geschehen könnten. Betrach-
ten Sie folgenden Code:
int i = 1;
int k = 17;
while ( i <= 10)
{
int r = 5 * k + 3;
int z = r + i ;
print ( z );
}
In obigem Code wird die Zahl r jedes Mal neu berechnet, obschon sie von den Schleifenvaria-
blen ( i und z ) unabhängig also invariant ist. Der Code kann klarer und auch performanter
(=schneller in der Ausführung) wie folgt geschrieben werden:
int i = 1;
int k = 17;
int r = 5 * k + 3; // von i unabhaengig
while ( i <= 10)
{
int z = r + i;
print ( z );
}
Bemerkung: Ein guter Compiler kann das optimieren, sodass unter Umständen beide obigen
Programmteile gleich schnell ablaufen werden – gehen Sie jedoch nicht ungeprüft davon aus!
A.8.3 Selektion als Spezialfall
Die Selektion kann als Spezialfall der Iteration aufgefasst werden. Zusammen mit der while() -
Schleife und dem Konzept von Variablen kann ein if() wie folgt erzeugt werden:
boolean firstTime = true ;
while ( firstTime && bed ())
{
doSomething ();
firstTime = false ;
}
Obiger Code ist identisch mit:

if ( bed ())
{
doSomething ();
}

A.9 Metasprache zur Darstellung der Grammatiken
Ich verwende hier eine vereinfachte EBNF57 -Notation, um die Java-Syntax darzulegen. Die hier
benutzte Notation ist zwar nicht mehr ganz korrekt, dafür jedoch etwas einfacher.
Die folgenden Symbole werden verwendet und beziehen sich auf das Zeichen oder den eben ver-
wendeten Klammerausdruck:
* Das Feld darf mehrfach verwendet werden, darf aber auch weggelassen werden.
+ Das Feld darf mehrfach verwendet werden, muss aber mindestens einmal auf-
geführt werden.
[...] Der Ausdruck innerhalb der eckigen Klammern ist optional.
? Alternative Schreibweise für optional: Feld kommt maximal einmal vor, kann
aber auch wegfallen.
| Entweder das Symbol links oder das Symbol rechts des Striches wird eingesetzt.
<> Der Textblock innerhalb der spitzen Klammern muss durch den effektiven
Wert ersetzt werden. Beispiel Person :== «<Name>» « <Vorname>» wird
zu «Hans» «Meyer».
(. . . ) Klammerausdruck. Die obigen Symbole werden rechts des Ausdrucks geschrie-
ben und gelten dann für den gesamten Klammerausdruck.
fett Muss exakt so abgeschrieben werden (z. B. <MODIFIER>+ class . . . ).
Beispiele
a* : " " , " a " , " aa " , " aaa " , ...
( xy )+ : " xy " , " xyxy " , " xyxyxy " , ...
x * y ? : y , xx , xxxxy , ...
57
Erweiterte Backus-Naur-Form (s. Wikipedia)
149
A Anhang
A.10 Syntax von Java-Subroutinen (Methoden)

[ < modifier >]* <return - type > < name > ( [ < parameter >]* )
[ throws < exception >+ ]
{
< Block >
}
(Die Syntaxstruktur findet sich hier: (s. Kap. A.9 auf Seite 149))
Dabei haben die Felder folgende Bedeutungen:
<modifier> :== Modifizierer: public, protected, private, static, strictfp, native, abstract,
final, synchronized.
<return-type> :== Rückgabewert: void | <Datentyp>
<name> :== Identifier: Name der Methode
<parameter> :== Übergabewerte: [final] <Datentyp> <Name>
Mit Kommata (,) getrennt.
<exception> :== Exception Type: Name der Exceptionklassen
Auch mit Kommata (,) getrennt.
<Block> :== Anweisungen
Bemerkung: In Java können Subroutinen nur innerhalb von Klassen stehen. Es gibt keine De-
klaration von Subroutinen außerhalb von Klassen, aber auch nicht direkt innerhalb von anderen
Subroutinen.

A.11 Überladen (Overloading)
In Java (wie den meisten modernen Sprachen) können Methodennamen mehrfach definiert wer-
den.
Dabei werden die Methoden alleine durch die Anzahl und Datentypen ihrer Parameter unterschie-
den. Dieses Verfahren ist unter dem Konzept «Überladen (Overloading)» oder auch «statischer
Polymorphismus» bekannt.
Beispiel:
void loeschen ( File f );
void loeschen ( Verzeichnis v );
void loeschen ( Kundendaten kd , Kundenkartei k );
void loeschen ( Durst d );
151
A Anhang
A.12 Stack (Stapel)

Was geschieht denn eigentlich genau bei einem Subroutinen-Aufruf. Die technische Lösung bildet
der Stapel (engl. Stack).
void sub ( int a )

{
String s = " a ␣ ist ␣ gleich ␣ " + a ;
System . out . println ( s );
return ;
}
Beim Aufruf einer Subroutine ...
• ... werden die Parameterwerte (also die Argumente) auf den Stack kopiert und sind via
Parameter (hier die Parameter-Variable a ) zugreifbar,
• ... wird Platz für die lokalen Variable (hier s ) geschaffen, damit die Subroutine auch
temporäre Zwischenresultate speichern kann und
• ... wird zudem auch die Rücksprungadresse auf den Stack gelegt. Dies ist wichtig, damit
das Programm bei Beenden der Subroutine auch weiß, wo im Hauptprogramm weitergefah-
ren werden muss.

A.12.1 Das versteckte « return »
Die folgenden beiden Subroutinen sind absolut identisch:

void sub ( int a )
{
String s = " a ␣ hat ␣ den ␣ Wert ␣ " + a ;
}
void sub ( int a )

{
String s = " a ␣ hat ␣ den ␣ Wert ␣ " + a ;
return ;
}
Denn: Wenn wir die return -Anweisung am Ende einer Subroutine weglassen, so wird diese vom
Compiler automatisch eingefügt.
Das return beendet die Subroutine automatisch, gibt den Speicher der temporären Variable
auf dem Stack wieder frei und springt zum aufrufenden Programm zurück (daher wurde die
Rücksprungadresse auch gespeichert).
Der Leserlichkeit halber wird diese abschließende return -Anweisung in der Praxis üblicherweise
weggelassen.
153
A Anhang
A.13 Java-Klasse (Kompilationseinheit)

Jede Kompilationseinheit in Java beinhaltet in der Regel (genau) eine Klasse. Diese ist (ab-
gesehen von Code-Kommentaren) nach dem folgenden Grundmuster (und in dieser Reihenfolge)
aufgebaut:
[package] genau eine Paketdeklaration, die aus-
sagt, wo die Datei aufzufinden ist
[imports] beliebig viele Angaben zu externen Re-
ferenzklassen und Paketen
[class] normalerweise eine Klassendefinition
Dabei ist die Klasse ( class ) wie folgt aufgebaut58 :
[ < MODIFIER >]* class < Klassenname >
[ extends < Klassenname >]
[ implements < Klassenname >+]
{
[ member ]*
}
A.13.1 Kommentare
An jeder Stelle59 im Quelltext können Kommentare geschrieben werden. Diese dienen dem Ver-
ständnis des Codes und werden vom Compiler ignoriert.
• Alles was ab /* bis und mit */ steht, wird als Kommentar gesehen und gehört nicht zum
ausführbaren Programmcode.
• Das Symbol // bezeichnet einen Kommentar: Alles bis zum Zeilenende wird vom Compiler
ignoriert.
58
Für die EBNF Notation (s. Kap. A.9 auf Seite 149)
59
... mit Ausnahme innerhalb von Operatoren (z. B. ++ ) und Bezeichnern (z. B. Variablennamen) ...

A.13.2 Members einer Klasse
Innerhalb einer Klasse ( class ) können die folgenden Klassenelemente (Members) auftreten (wo-
bei nur die ersten drei wirklich wichtig sind):
Member Beschreibung Beispiel Bemerkung
Attribut Objekt- String name; Jedes Objekt hat sei-
Eigenschaft nen eigenen internen Zu-
stand.
void add(float smd)
{
Methode Ereignisse Ereignisse verändern ty-
(Events), summe += smd; pischerweise den inter-
die auf die Objekte } nen Zustand (die Attri-
wirken können bute) der Objekte.
Konstruktoren Spezielle Methode, public Person () {...} Jedes Objekt wird durch
um Objekte zu er- einen Konstruktor (mit-
zeugen tels new ) erzeugt.
Statisches Klasseneigenschaft static int obCount; Jede Klasse kann auch
Attribut globale Variable aufwei-
sen, die für alle Objekte
verwendbar sind.
Statische Code, der bei Klas- static {...} Dieser Code wird beim
Initialisierer senerzeugung aus- Laden der Klasse ausge-
geführt werden soll führt. Ohne das Schlüs-
selwort static wird
der Code bei der Objek-
terzeugung ausgeführt.
Dynamischer Code, der nach { ...} Dynamische Initialisie-
Initialisierer super() , aber rer werden selten ge-
vor dem Rest braucht, da den Ent-
des Konstruktors wicklern oft nicht klar
ausgeführt wird. ist, wann diese ausge-
führt werden. Finger da-
von lassen!
Statische Klassenereignisse static int getYear() Werden meist für klas-
Subroutinen sische Funktionen, die
nicht von einem Objekt-
zustand abhängig sind,
verwendet.
Innere Klassen Klassen innerhalb class Xyz {...} Beispiel: AHV Nummer
bestehender Klas- als innere Klasse von
sen Person.
155
A Anhang
1. Beispiel einer Kompilationseinheit:

public class Trampeltier extends Kamel implements Haustier
{
float gewicht ;
String name ;
public Trampeltier ( String name , Date geburt , float gewicht )

{
super ( name , geburt );
this . gewicht = gewicht ;
}
float getGewicht ()
{
return this . gewicht ;
}
}

2. Beispiel einer etwas komplizierteren Kompilationseinheit:
/* package */
package ch . programmieraufgaben ;
/* imports */
import ch . programmieraufgaben . util .*;
import java . util . HashMap ;
/* Klassendefinition der Klasse Kunde */

public class Kunde {
String name , vorname ;
int kundennummer ;
public Kunde ( String name , String vorname , int id )

{
this . name = name ;
this . vorname = vorname ;
this . kundennummer = id ;
}
public String getName ()

{
return name ;
}
}
Bemerkung A.1. Neben class sind auch interface oder enum als Inhalt einer Kompilations-
einheit möglich. Zu enum gibt es ein eigenes Kapitel (s. Kap. A.15 auf Seite 159).
157
A Anhang
A.14 Variable
Variable bezeichnen Speicherstellen. An ihrer Stelle können (binär kodierte) Werte stehen. Jede
Variable hat einen Namen (Bezeichner), einen Datentypen und allenfalls einen Wert. In JAVA
kommen Variable an verschiedenen Stellen zum Einsatz:
Lokale Variable Jeder Block (Subroutinen, Kontrollstrukturen, aber auch namenlose Blöcke)
kann lokale Variable deklarieren. Wichtig: Die lokalen Variablen erhalten
keinen Standardwert (Default). Sie müssen explizit definiert werden (z. B.:
int x; x = 7; ).
Parameter Methoden und Konstruktoren können mit einer formalen Parameterliste ver-
sehen sein. Diese Variablen sind nur innerhalb der Methode sichtbar und
leben nur solange (auf dem Stack) wie sich der ausführende Thread (Pro-
grammzeiger) innerhalb der Methode bzw. des Konstruktors befindet. Para-
meter haben keine Defaultwerte. Die Werte werden beim Aufruf der Methode
oder des Konstruktors vom aufrufenden Programmteil übergeben. Genauer:
Das aufrufende Programm wertet die Argumente aus, und die Werte (z. B.
Zahlen, Referenzen) werden auf den Stack geschrieben.
Attribute Variable, die innerhalb von Klassen, aber außerhalb von Methoden oder Kon-
struktoren deklariert werden, heißen (sofern nicht static ) Attribute. Diese
erhalten ihren Speicherplatz, sobald ein Objekt der entsprechenden Klasse
(oder einer Subklasse) generiert wird ( new ). Attribute erhalten beim Gene-
rieren (sofern nicht anders definiert) ihren Defaultwert (z. B. 0 für int ).
Klassenvariable Mit static markierte Felder sind Klassenvariable. Diese Variablen können
von allen Instanzen (Objekten) dieser Klasse verwendet werden und können
im Gegensatz zu Attributen für verschiedene Objekte keine verschiedenen
Werte annehmen. Pro Klasse existiert genau eine Speicherstelle für diese
Variable, die von allen Objekten geteilt wird. Auch dürfen die statischen
Methoden (Klassenfunktionen) auf diese Variable zugreifen. Egal wie viele
Objekte es gibt, die Klassenvariable kommt nur einmal vor und ist in die-
sem Sinne global. In einer Interface-Deklaration braucht das Schlüsselwort
static nicht angegeben zu werden. Die Variable erhält ihren Speicherplatz,
sobald der Classloader die Klasse in die virtuelle Maschine lädt. Klassenva-
riable erhalten - sofern keine Definition angegeben ist - automatisch den
Defaultwert.
Arraywerte Arrays (selten auch Felder genannt) bestehen aus Variablen desselben Da-
tentyps. Wenn ein Array generiert wird ( new A[<size>] ), erhalten alle
Elemente Speicherplatz und ihren Defaultwert. Objektreferenzen werden mit
null initialisiert.
Exception- Jeder Exceptionhandler ( catch(Exception e) {...} ) enthält ein Argu-
Handler ment des Datentyps der entsprechenden Exception (Ausnahme). Sobald die
Parameter Exception auftritt, wird ein Objekt der entsprechenden Klasse generiert. Die-
ses Objekt wird dem Argument übergeben und kann innerhalb des catch -
Blocks benutzt werden.

A.15 Nominale Werte ( enum )
«Eigene primitive Datentypen erstellen»

Oft kennt man von seinem Datentyp den Wertebereich nominal. Das heißt, der Wertebereich ist
auf einige wenige Wörter oder Begriffe eingeschränkt (z. B. Wochentage, Ampelzustände, ...). Die
erste der folgenden Möglichkeiten, um nominale Werte darzustellen, kennen wir bereits (Ganz-
zahltyp).
A.15.1 Darstellung als Ganzzahltyp
Bei dieser einfachen Implementation nominaler Werte wird jedem möglichen Wert eine ganze Zahl
zugeordnet:
// Beschreibung : 0= Montag , 1= Dienstag , 2= Mittwoch , ...
int ferienanfang = 4; // Freitag
...
// Freitag :
if (4 == ferienanfang )
{
...
}
Nachteil: Ständiges Nachschlagen in der Dokumentation (Tabelle oder Programmkommentar) ist

nötig. Zahlfehler werden vom Compiler nicht erkannt; m. a. W.: Es kann der Variable auch ein
Wert zugeordnet werden, der in der Tabelle fehlt.
Daher bietet sich sofort das Arbeiten mit unveränderbaren Variablen an, sogenannten Konstanten:
A.15.2 Variable oder Konstante
Eine weitere Möglichkeit besteht darin, für jede vorkommende Zahl eine Variable (falls möglich
eine Konstante, die in Java mit dem Schlüsselwort final gekennzeichnet werden) zuzuweisen:
final int MONTAG = 0;
final int DIENSTAG = 1;
final int MITTWOCH = 2;
...
int ferienanfang = FREITAG ;
Zwar müssen wir nun die Bedeutungen nicht permanent nachschlagen; ein Nachteil bleibt trotz-
dem: der Variable ferienanfang kann jeder int -Wert zugewiesen werden. Um das etwas zu
umgehen, kann man auch mit Konstanten Strings arbeiten:
159
A Anhang
A.15.3 Konstante Zeichenketten
Die nun vorgestellte Variante unterscheidet sich zur vorangehenden dadurch, dass anstelle von
ganzen Zahlen ( int ) Strings (also Zeichenketten) verwendet werden. Gleich ein Beispiel:
final String MONTAG = " Montag " ;
final String DIENSTAG = " Dienstag " ;
final String MITTWOCH = " Mittwoch " ;
...
String ferienanfang = FREITAG ;
Vorteil: Eine künstliche Zuordnung zu den Zahlen fällt weg. Nachteil: Weiterhin kann jeder be-
liebige String der Variable ferienanfang zugewiesen werden.
A.15.4 Die technische Lösung
(Konstante Objekte und versteckte Konstruktoren)

Die Lösung: Damit keine anderen Objekte einer Variablen zugewiesen werden können, verwendet
man in der Praxis konstante (finale) Objekte von Klassen, die keinen öffentlichen Konstruktor
aufweisen:
public class Wochentag {
public static final Wochentag MONTAG = new Wochentag ();
public static final Wochentag DIENSTAG = new Wochentag ();
public static final Wochentag MITTWOCH = new Wochentag ();
...
private Wochentag () {}
} // end of class Wochentag
Verwendet werden diese Typen danach folgendermaßen:

Wochentag ferienanfang = Wochentag . FREITAG ;
...
if ( Wochentag . FREITAG == ferienanfang )
{
...
}
Liest sich doch schon besser, als if(4 == ferienanfang) ...

Damit nicht jeder Programmierer sich all diese Gedanken wieder machen muss, hat Java seit
Version 1.5 so genannte Enumerationstypen ( enum ) eingeführt, welche sich technisch genauso
verhalten, wie die eben gezeigte Lösung; sie sind aber einfacher zu benutzen. Verwenden Sie wenn
immer möglich die folgende Vorgehensweise:

A.15.5 Enumerationstypen (Java- enum )
Schreiben Sie in der Kompilationseinheit Wochentag.java nur noch folgendes:

enum Wochentag { MONTAG , DIENSTAG , MITTWOCH , ...}
Verwendet wird dies dann genau so wie im Beispiel vorhin. Nun ist Wochentag ein eigener Da-
tentyp und wird von der Syntax wie alle anderen Datentypen verwendet (siehe unten).
Im Gegensatz zur Lösung mit int oder mit String kann nun kein ungültiger mehr Wert zuge-
wiesen werden und den Werten sieht man ihre Bedeutung direkt an (z. B. Wochentag.FREITAG ).
Beispiel A.1. Beispiel: Ich will ausschließlich einen der vier folgenden Werte für meine Variable
zulassen
0 (= Nord), 1 (= Ost), 2 (= Süd), 3 (= West):
so schreibe ich in einer Kompilationseinheit namens Richtung.java folgendes:

enum Richtung { NORD , OST , SUED , WEST }
Und verwende dies wie folgt:

Richtung sonnenUntergang = Richtung . WEST ;
Geek Tipp 11
Verwende immer Enumerationstypen (enum) für nominale Werte!
161
A Anhang
A.16 Bit-Maskierung (Mengen)

Oftmals genügt ein nominaler Wert nicht, um unsere Daten darzustellen. Als Beispiel soll ein Ka-
mel in einer Karawane dienen. Ein Kamel kann Wasserträger, Verpflegungsträger, Gepäckträger
oder Personenträger sein. Es kann aber auch jede Kombination dieser Eigenschaften aufweisen.
So kann die Variable Last nun einfach mit 4 Bit abgespeichert werden. Jedes Bit entspricht dabei
einer der erwähnten Lasten:
Bit 1: Wassertraeger
Bit 2: Verpflegungstraeger
Bit 3: Gepaecktraeger
Bit 4: Personentraeger
Ist ein Kamel innerhalb einer Karawane nun Wasser-, Gepäck- und Personenträger (aber kein
Verpflegungsträger), so schreiben wir dafür das Bitmuster 1101 in eine Variable. Bemerke: Das
erste Bit (Bit mit Nummer 1) steht ganz rechts.
Mit sogenannten Masken-Konstanten können wir einem Kamel eine Eigenschaft hinzufügen, eine
Eigenschaft wegnehmen oder einfach auf eine Eigenschaft prüfen. Hier die vier benötigten Masken-
Konstanten:
int WASSER_TRAEGER = 1; // Bit 1 = 0000 0001
int VERPFLEGUNGS_TRAEGER = 2; // Bit 2 = 0000 0010
int GEPAECK_TRAEGER = 4; // Bit 3 = 0000 0100
int PERSONEN_TRAEGER = 8; // Bit 4 = 0000 1000
int typ ; // Kombination aus obigen Bitwerten
Hinzufügen einer Eigenschaft:

typ = typ | GEPAECK_TRAEGER ;
Entfernen einer Eigenschaft:

typ = typ & (~ GEPAECK_TRAEGER );
Prüfen einer Eigenschaft

a) auf Vorkommen:
if ( GEPAECK_TRAEGER == ( typ & GEPAECK_TRAEGER )) {...}
b) auf Nichtübereinstimmung:
if ( GEPAECK_TRAEGER != ( typ & GEPAECK_TRAEGER )) {...}

A.17 Abfragen im Geek-Style
Ein Computer-Geek ist ein «Besserwisser» in der Art, dass er technische Sachverhalte zwar tat-
sächlich meist besser weiß, aber auch permanent an seinem Informatik-Wissen zweifelt und dieses
in Frage stellt. Insofern muss der folgende Geek-Style auch immer wieder in Frage gestellt wer-
den...
Beachten und diskutieren Sie die folgenden Abfragearten. Verinnerlichen Sie sich den «Geek-
Style»:
Titel Zahlen Bool’sche Werte
Standard if(x == 4) if(ok == true)
Gefahr if(x = 4) if(ok = true)
Nix verstan- if(true == ok)

den?
Tippfehler? if(true = ok)
Geek-Style if(4 == x) if(ok)
Tippfehler? if(4 = x)
Beachten Sie, dass 4 == x natürlich mit x == 4 mathematisch identisch ist. Die zweite Variante
läuft jedoch in einzelnen Sprachen (C, ...) Gefahr, sich bei Tippfehlern fatal zu verhalten. Die
Variante 4 == x ist hier etwas gewöhnungsbedürftig.
Generell: Wer die Konstanten links lässt, schreibt robusteren Code:
String s = ...;
if ( " abc " . equals ( s ))
{
...
}
Umgekehrt ( s.equals("abc") ) kann es hier sein, dass die Variable s noch nicht definiert ist
und eine sog. NullPointerException würde das Programm unsanft beenden.
Bemerkung: Je nach Programmiersprache ist eine andere Art die sinnvollste. Wichtig ist, dass Sie
die obige Tabelle verstehen und in Ihrer Programmiersprache versuchen, die Vor- und Nachteile
der einzelnen Bedingungen (Boole’sche Ausdrücke) kritisch zu hinterfragen.
163
A Anhang
A.18 Spezialitäten von Arrays

Hier folgen noch einige Eigenheiten von Java-Arrays.
A.18.1 Anonyme Arrays
Arrays können seit der JAVA 1.1 Version auch anonym definiert werden. Falls z. B. eine Metho-
de public int sum(int a[]) besteht, die alle Werte eines int -Arrays zusammenzählt, kann
diese Methode mit der Syntax für anonyme Arrays ...
int summe = sum ( new int []{1 , 5 , 3 , 2 , 4 , 4});
... aufgerufen werden.
A.18.2 Implementierung von Tabellen
Tabellen oder Matrizen kennt Java von sich aus nicht. Da aber ein Array auch aus Arrays
bestehen kann, sind Tabellen einfach zu verwirklichen.
Hier nochmals das Beispiel aus dem Theorieteil (s. Kap. 6.2 auf Seite 89). Intern sieht die Um-
setzung technisch wie folgt aus:

A.18.3 Arrays und Maps
Handelt es sich bei den Indizes nicht um Zahlen, so können (selbst für mehrdimensionale Tabellen)
in Java Map s verwendet werden. Hier eine Umsatztabelle nach Quartalen (q1 - q4):
q1 q2 q3 q4
Meier 48 000 36 000 52 000 68 000
Freimann 12 000 11 000 8 000 24 000
Huber 50 000 51 000 53 000 46 000
Müller 5 500 5 500 3 800 2 200
Guggisberg 38 000 36 000 48 000 54 000
Dabei wird eine Zeile wie folgt zugewiesen:
HashMap < String , Integer > meier ;
meier = new HashMap < String , Integer >();
meier . put ( " q1 " , 48 _000 );
meier . put ( " q2 " , 36 _000 );
meier . put ( " q3 " , 52 _000 );
meier . put ( " q4 " , 68 _000 );
Um die Zeilen nun eine «Tabelle» zu füllen, kann wieder eine Map verwendet werden und wir
erhalten mit diesem «Trick» die gewünschte Tabelle:
HashMap < String , HashMap < String , Integer > > tabelle ;
tabelle = new HashMap < String , HashMap < String , Integer > >();
tabelle . put ( " Meier " , meier );

tabelle . put ( " Huber " , huber );
...
A.18.4 Tabellen mit Zeilen unterschiedlicher Länge
In folgendem Beispiel besteht die Tabelle aus drei unterschiedlich langen Zeilen:
int [][] matrix =
{
{37 , 42} ,
{12 , 25 , 18} ,
{3 , 9}
};
System . out . println ( Arrays . toString ( matrix [1]));
165
A Anhang
A.19 Besonderheiten von Strings

A.19.1 Stringlänge
Java verwendet für Strings Arrays (Felder) von Unicode Zeichen ( char ). Ein Unicode-Zeichen
benötigt 2 Byte und Arrays werden mit int angesprochen. Somit könnte ein Java-String theo-
retisch 4GiB an Speicher einnehmen (2 Milliarden Zeichen!). Leider konnte ich dies nicht tes-
ten, da solche Tests in der Regel zunächst den Heap komplett auffressen. Stringlängen von über
600 000 000 Zeichen sind jedoch auf heutigen PCs kein Problem. Mit anderen Worten: Sie können
in einer einzigen String-Variable den kompletten Text von über 500 Büchern speichern!
Die Länge eines Strings wird in Java mit der length() -Methode ermittelt:
meinString.length();
A.19.2 Teilstring
Teilstrings werden in Java wie folgt ermittelt: str.substring(start, end) . Zu bemerken

ist, dass in einigen Programmiersprachen die Länge mitgegeben wird, in Java hingegen die
gewünschte End-Position. Wollen Sie z. B. alle Zeichen ab Position 5 bis zur Position 10 aus
einem String str extrahieren, so schreiben Sie in Java:
str.substring(5, 11)
Das Ende ( end ) wird in Java bei der String-Extraktion nicht mit eingeschlossen. end zeigt
auf das erste Zeichen im String, das nicht mehr zum Teilstring gehören soll. Dieser offensichtliche
Fehler ist ein Relikt aus der Programmiersprache C. Auch wenn es tatsächlich Algorithmen gibt,
die damit effizient arbeiten können, so ist der gewählte Variablenname ( end ) mit Sicherheit
falsch.
Aufgabe A.1 «Teilstring» Schreiben Sie ein Java-Programm, das vom Benutzer einen Text
abverlangt, schneiden Sie den ersten und den letzten Buchstaben ab und geben Sie den Teilstring
aus.

A.19.3 Unveränderbarkeit
Strings sind nicht veränderbar. Mit diesem Wissen erstaunt der Output des folgenden Codes nicht:
String a = " Hallo ␣ ␣ " ;
String b = " ␣ ␣ ␣ Welt " ;
a . trim (); b . trim ();
System . out . println ( a + b ); // liefert " Hallo Welt "
Die Idee war wohl aber eher die folgende:

String a = " Hallo ␣ ␣ " ;
String b = " ␣ ␣ ␣ Welt " ;
String a2 = a . trim ();
String b2 = b . trim ();
System . out . println ( a2 + b2 ); // liefert " HalloWelt "
Was ist geschehen? Die trim() -Funktion ändert nicht den gegebenen String, sondern es wird ein
neuer String erzeugt, welcher getrimmt, also frei von führenden und nachfolgenden Leerzeichen,
ist.
A.19.4 StringBuilder
Aus oben genannten Gefahren und weil zudem das Zusammenfügen von String s in Java eine
teure Angelegenheit ist, verwendet man häufig auch den StringBuilder . Dieser reserviert sich
von vornherein 16 Zeichen (32 Byte) und muss erst Speicher neu allozieren, wenn diese 16 Zeichen
aufgebraucht sind.
Beispiel:
StringBuilder sb = new StringBuilder ( " Hallo " );
sb . append ( " ␣ " );
sb . append ( " Welt " );
System . out . println ( sb );
167
A Anhang
A.19.5 equals
Wir haben im Kapitel über Zeichenketten bereits gesehen, dass Strings nicht mit dem « == »-
Operator verglichen werden sollten, wenn wir uns dafür interessieren, ob zwei Strings die selbe
Zeichenfolge beinhalten.
Hier aber noch eine Möglichkeit, bei der der « == »-Operator trotzdem funktioniert. Hat man es
in einem Programm sehr häufig mit denselben Zeichenketten zu tun60 , dann kann die intern -
Funktion sehr nützlich sein:
a = "Hallo"; b = "Hallo"; a == b
a = new String(b); a != b
a = a.intern(); a == b
Im internen Konstanten String-Pool, kommt jeder Text genau einmal vor. Zum einen werden
dort alle Literale aus dem Programmcode abgelegt. Mit der Funktion intern() kann ein Text
ebenfalls dahin verschoben werden!
60
Dies ist der Fall, wenn wenige Strings jeweils mehrere hundert Male im System auftauchen sollten.

A.20 Java-Dateien (file-handling)
Ist ein Programm einmal gestartet, so gibt es grundsätzlich zwei Arten von Daten. Die sog. per-
sistenten Daten müssen auch zur Verfügung stehen, wenn das Programm einmal nicht mehr läuft.
Dabei kann es sich um Kundendaten, Spielstände, Ausleihen in Bibliotheken etc. handeln. Andere
sog. transiente (lat. kurzlebig) Daten sind jedoch nur gerade während der Programmausführung
wichtig. Typische Vertreter sind Positionen von graphischen Komponenten (wie z. B. der Ort des
OK-Buttons), der Ort des Cursors in Textverarbeitungen, berechnete statistische Werte, die je-
derzeit aus den persistenten Stammdaten wieder erzeugt werden könnten und und und (s. Kap.
A.6.2 auf Seite 141).
Achtung - Eine Warnung vorab: Die Klasse File in Java be-
zeichnet leider keine Datei (engl. File) im landläufigen Sinne. Mit einem
Java- File() wird ein Eintrag im File-System bezeichnet also ein Ord-
ner(Directory), ein Link oder eben ein Dateiname (Filename); nicht aber
der Inhalt einer Datei!
Die Java-File Klasse beinhaltet also lediglich einen Filenamen. Ob die Datei existiert und ob
es sich dabei um ein Textfile, ein Bild oder gar um ein Verzeichnis handelt, interessiert Java
vorerst nicht. Interessant sind daher vor allem folgende Methoden, wenn wir uns im Dateisystem
bewegen:
exists ()
isDirectory ()
listFiles ()
isFile ()
canRead ()
canWrite ()
Aufgaben zu File
Aufgabe A.2 « java.io.File » Schreiben Sie ein Programm, das ein Verzeichnis einliest und
alle darin enthaltenen Files ausgibt.
Zusatz 1: Geben Sie von jedem Inhalt jeweils an, ob es sich um ein Verzeichnis oder eine Datei
handelt.
Zusatz 2: Tauchen Sie rekursiv in alle Unterverzeichnisse ab.
169
A Anhang
A.20.1 Reader und Writer
Eine typische Anwendung einer File-Verarbeitung ist das zeilenweise Einlesen, Verarbeiten und
Ausgeben. Die folgende Demo-Anwendung liest eine Datei (Eingabe) ein, schreibt vor jede Zeile
die Zeilennummer und schreibt dies in eine neue Datei (Ausgabe). Um das ganze etwas span-
nender zu machen, sollen bei Leerzeilen keine Zeilennummern ausgegeben werden, jedoch soll die
Zeilennummer dennoch erhöht werden.
import java . io .*;
public class InOut {

new InOut (). top ();
}
final String IN_FILE_NAME = " eingabe . txt " ;

final String OUT_FILE_NAME = " ausgabe . txt " ;
String line ;
int lineNumber = 0;
void top () {
try (
Reader r = new FileReader ( IN_FILE_NAME );
LineNumberReader in = new LineNumberReader ( r ) ;
Writer out = new FileWriter ( OUT_FILE_NAME );
)
{
line = in . readLine ();
lineNumber = lineNumber + 1;
if ( line . trim (). length () > 0) {
out . write ( lineNumber + " . ␣ " );
}
out . write ( line + " \ n " );
line = in . readLine ();
}
}
catch ( IOException iox ) {
System . out . println ( " Fehler ␣ mit ␣ Datei : ␣ " + iox );
}
} // end method top ()
} // end of class InOut

Bemerkung: null wird von der Subroutine readLine() genau dann zurückgegeben, wenn keine
Zeile mehr gelesen werden kann. Dies bezeichnet das Ende der Datei (engl. EOF = «End of File»).
171
A Anhang
A.20.2 Abkürzung im while() -Header
Eine spezielle Möglichkeit, das Vor- bzw. Nachlesen abgekürzt zu notieren, bietet Java im
while() -Header.
Anstelle von
String line = in . readLine (); // Vor - Lesen
behandle ( line );
line = in . readLine (); // Nach - Lesen
}
kann abkürzend folgendes stehen:

String line ;
while ( null != ( line = in . readLine ())) {
behandle ( line );
}
Hier wird zunächst ein String eingelesen und in die Variable line geschrieben. Da in Java
eine Zuweisung gleichzeitig ein Ausdruck (Term) mit einem Wert ist, kann dieser Wert gleich im
Vergleich eingesetzt werden. Sobald der Wert null von readLine() zurückgegeben wird, so
bezeichnet dies das Ende der Datei.
Dies funktioniert, da die Zuweisungs-Anweisung in Java auch als Ausdruck verwendet werden
kann.

A.20.3 Anfügen
Zeilen oder Zeichen können auch ans Ende einer bestehenden Datei angefügt werden. Dazu be-
nötigt der FileWriter beim Erstellen einen zweiten Parameter ( true ).
Das folgende Beispiel zeigt, wie Textzeilen ans Ende der Datei Ausgabe.txt angefügt werden:
File out = new File ( " Ausgabe . txt " );
try ( FileWriter fw = new FileWriter ( out , true )) {
fw . append ( " Eine ␣ letzte ␣ Zeile \ n " );
System . err . println ( " Fehler : ␣ " + iox );
}
Aufgaben zu Reader und Writer
Aufgabe A.3 «Top» Schreiben Sie ein Programm namens «Top», das von einer Text-Datei die
ersten sieben Zeilen ausgibt.
Zusatz: Lesen Sie den Filenamen über die main -Parameter ein (s. Kap. A.23 auf Seite 187).
Aufgabe A.4 «Zähler» Schreiben Sie ein Programm, das von einer Text-Datei alle Zeilen zählt
und diese Anzahl auf der Konsole ausgibt.
Zusatz: Zählen Sie alle Zeilen, Zeichen, alle Buchstaben und alle Wörter.
Zum Testen können Sie folgenden Text verwenden:
Dieser Text besteht

aus neun Zeilen und
zwanzig Wörtern,
davon eines ge-
trennt.
Total sind es
hundertneunzehn
Buchstaben mit
drei Satzzeichen.
173
A Anhang
A.20.4 Filterketten (Filter chaining)
Java verwendet für die Datenverarbeitung sog. Filter. Ein Filter kann man sich vorstellen wie
eine Umwandlung von einem Datenstrom in einen anderen. So kann ein Filter zuständig sein,
dass die Daten zunächst aus einer *.zip -Datei gelesen werden. Der zweite Filter verwandelt die
Bytes anhand einer Kodierung in Unicode-Character ( char ). Ein dritter Filter ist zuständig, um
die Datei zeilenweise einzulesen und so fort:
Im klassischen EVA-Prinzip61 werden die Daten typischerweise von einem Datenstrom (Datei
oder Netzwerk-Ressource) gelesen62 . Nach dem Filtern in unser gewünschtes Format werden die
Daten verarbeitet. Zum Schluss wird die Ausgabe aus unserem Programm wieder in ein neues
gewünschtes Format gefiltert und so in den Ausgabedatenstrom gesendet:
61
EVA = Eingabe-Verarbeitung-Ausgabe
62
Ein Datenstrom ist in Java eine Aneinanderreihung von byte . Beim Lesen aus einem Datenstrom, insbe-
sondere bei Musik oder Videos von einer Netzwerk-Ressource, sprechen wir oft auch von streamen.

A.20.5 Klassisches Filter-Chaining
Das folgende Beispiel (nächste Seite) zeigt ein Filter-Chaining, um aus einer Datei einen Text
zeilenweise auslesen zu können. Ein FileReader ist im Grunde nichts anderes als das Chaining
eines FileInputStream mit einem InputStreamReader . Der FileInputStream liest byteweise
von einer Datei (im Gegensatz z. B. von einem Stream einer URLConnection , welche Daten von
einer Netzwerkressource liest). Der InputStreamReader ist zuständig, die Text-Kodierung (utf-
8, Latin, EBCDIC, ...) aufzulösen und um aus den byte char herzustellen. Zu guter Letzt ist
ein BufferedReader eingesetzt, der die Zeilenenden erkennt und im Wesentlichen eine Funktion
readLine zur Verfügung stellt:
175
A Anhang
Klassisches Filter-Chaining
import java . io .*;
public class FilterChaining {

new FilterChaining (). top ();
}
void top ()
{
String inFileName = " test . txt " ;
String encoding = " utf -8 " ;
// Verwenden Sie zum Test die folgenden Kodierungen :
// " utf -8" , " iso -8859 -1" , " Cp437 ", " Cp850 ", " Cp500 "
try (
FileInputStream fis = new FileInputStream ( inFileName ) ;
InputStreamReader isr = new InputStreamReader ( fis , encoding );
BufferedReader br = new BufferedReader ( isr ) ;
)
{
String line ;
while ( null != ( line = br . readLine ()))
{
System . out . println ( " Gelesen : ␣ " + line );
}
System . out . println ( " Fehler ␣ in ␣ der ␣ Fileverarbeitung : ␣ " + iox );
} // end of try - catch
} // end of top ()
} // end of class FilterChaining
Bemerkung A.2. Für die Bedingung in der while() -Schleife siehe Seite 172.

A.20.6 Datenströme (Streams)
Den Readern und Writern aus dem vorangehenden Kapitel liegen sog. Datenströme zugrunde. Ein
Datenstrom ist eine Reihe von Bytes, wohingegen die Reader und Writer Zeichen (char) liefern
und somit zur Textverarbeitung geeignet sind.
Viele Anwendungen gehen aber tiefer als die reine Behandlung von Texten und Verarbeiten die
Daten byteweise. Dabei kann es sich um Files, aber auch um Datenströme von einem Netzwerk
handeln.
Die folgende Tabelle hilft zu entscheiden, welche der Java-Objekte im Zusammenhang mit
Readers , Writers und Streams verwendet werden sollte.
byte (8 bit) char (16 bit) / String

Lesen InputStream Reader
Schreiben OutputStream Writer
Das folgende Hauptprogramm gibt eine Datei Byteweise auf der Konsole aus:
void top () {
try (
FileInputStream fis = new FileInputStream ( " inFile . bin " );
) {
int inByte ;
while ( -1 != ( inByte = fis . read ()))
{
System . out . println ( inByte + " ␣ " );
}
System . out . println ( " Fehler ␣ in ␣ der ␣ Dateibehandlung : ␣ " + iox );
}
}
Beachten Sie, dass der Befehl read() die Zahl -1 zurückgibt, wenn das Ende der Datei erreicht
ist. Die Bytes werden in Werten von 0 bis 255 wiedergegeben und nicht wie sonst in Java üblich
von -128 bis +127.
Bemerkung A.3. Die Bedingung in der while() -Schleife ist hier analog zur readLine() -Funktion
für Zeichenketten (s. Kap. A.20.2 auf Seite 172).
177
A Anhang
Encoding Zeichen werden durch Bytes (in Java 8-bit / ASCII 7-Bit) bzw. durch Characters
(in Java 16 Bit) repräsentiert. Bytes werden vorwiegend in Datenströmen (Files bzw. Netzwerk-
verbindungen TCP/IP) verwendet.
Nun können wir uns die Frage stellen, warum es dann die Unterscheidung in byte und char
überhaupt braucht. Java- byte sind einfach eine Aneinanderreihung von je 8 Bit. Welche Buch-
staben sich dahinter verbergen ist aber von System zu System verschieden. Die Zeichen ( char )
werden durch sogenannte Kodierungen (encodings) festgelegt. Ein FileReader , wie wir ihn oben
verwendet hatten, verwandelt eine Datei ( byte -Strom) in einen Zeichenstrom, indem die Kodie-
rung des aktuellen Betriebssystems verwendet wird. Auf modernen Betriebssystemen ist das meist
die UTF-8 Kodierung.
Unicode 16-Bit Zeichen werden in Java im RAM verwendet. Je nach Kodierung liegt einem
Zeichen ein anderes Bitmuster (oben als Hex-Wert angegeben) zugrunde. Im RAM der Java
virtuellen Maschine (JVM) wird jedoch stets Unicode verwendet. So brauchen wir uns lediglich
beim Lesen und Schreiben außerhalb des Programmes (Files, Network I/O, . . . ) um die Kodierung
zu kümmern.
Die folgende Tabelle zeigt den Sachverhalt anhand der Zeichen «K» und «ä»:
Files / Networking ( Streams ) Java (char / Strings)
( Readers / Writers )
Bytes ( byte ) Characters ( char )
8 Bit (= 1 Oktett) 16 Bit (= 1 char)
256 mögliche Zeichen 65’536 mögliche Zeichen
Zeichen Kodierungen: Kodierungen in Java:
Immer Unicode ( www.unicode.org )
K #4B = ASCII ’K’ 0x004B = ’K’ (= «00» + ASCII)
#D2 = EBCDIC ’K’
ä #E4 = ANSI ’ä’ 0x00E4 = ’ä’ (= «00» + ANSI)
#8A = Mac ’ä’
#84 = Cp-437 ’ä’
#C3A4 = UTF-8 ’ä’
Java verwendet intern für char (und somit auch für Strings) die Unicode-Kodierung. Siehe
http://www.unicode.org .

Aufgabe A.5 «Kodierungen» Lesen Sie eine Datei mit dem folgenden Programm ein (dabei wird
das File test.txt je nach Kodierung anders auf der Konsole wieder ausgegeben).
void top () {
String inFileName = " test . txt " ;
String encoding = " utf -8 " ;
// Verwenden Sie zum Test die folgenden Kodierungen :
// " utf -8" , " iso -8859 -1" , " Cp437 ", " Cp850 ", " Cp500 "
try (
FileInputStream fis = new FileInputStream ( inFileName ) ;
InputStreamReader isr = new InputStreamReader ( fis , encoding );
) {
int nextChar ;
while ( -1 != ( nextChar = isr . read ()))
{
char ch = ( char ) nextChar ;
System . out . print ( ch );
}
System . out . println ( " Fehler ␣ in ␣ der ␣ Fileverarbeitung : ␣ " + iox );
}
}
Aufgabe A.6 «Filevergleich» Zwei Dateien sollen geöffnet werden und der Inhalt byteweise ver-
glichen werden. Wenn die Dateien identisch sind, dann und nur dann soll true zurückgegeben
werden - ansonsten false .
Aufgabe A.7 «Lesbar» Eine Datei soll zum Lesen geöffnet werden. Daraus soll eine neue Da-
tei geschrieben werden, die nur die Buchstaben und die Leerschläge und die Satzzeichen Punkt
und Komma enthält, welche in der Originaldatei vorhanden waren. Alle anderen Zeichen sollen
ignoriert werden.
179
A Anhang
A.20.7 Randomaccess-Files
Manchmal wollen wir eine Datei aber nicht nur sequentiell lesen sondern innerhalb der Datei
Ausschnitte lesen bzw. schreiben.
Gleich ein Beispiel:
File dataFile = new File ( " dataFile . raw " );
RandomAccessFile f = new RandomAccessFile ( dataFile , " rw " );
f . seek (64); // Auf Position 64 springen

byte daten [] = new byte [32]; // 32 Byte Platz bereitstellen
f . read ( daten ); // 32 Byte aus dem File lesen
f . writeInt (1234); // Die Zahl 1234 ( als 4 Byte Int ) an
// Stelle 96 Schreiben ( Die Position
// ist ja 64+32)
f . close (); // File wieder schliessen
Aufgabe A.8 «PNG» Schreiben Sie ein Programm, das von einer PNG (Portable Network Gra-
phics) Datei die Header ausgibt.
Das PNG-Fileformat ist wie folgt aufgebaut:
• Erste 8 Byte = Magic number = Byte values 137, 80, 78 71 13 10 26 10
• Danach folgen beliebig viele Chunks:
– Ein Chunk beginnt mit der Chunk Größe (4 Byte), danach kommt der Chunk Name (4
Byte), danach kommen die Chunk Daten (die Länge wurde in der Größe angegeben).
und zuletzt folgen nochmals 4 Byte Prüfsumme (CRC).
– Der Letzte Header hat Länge 0 und heißt IEND. Sobald dieser Header erreicht ist,
folgen keine PNG relevanten Daten mehr.
Verwenden Sie die Methoden

read() , readInt() , skipBytes() und close() .

A.21 Java Collection Framework
A.21.1 Collection
• Collection: Interface, das alle Collections implementieren müssen.
• List: Die Elemente sind geordnet, d. h. in derselben Reihenfolge, wie sie eingefügt werden.
• ArrayList: Auf die Elemente kann via Index zugegriffen werden. Das Einfügen am Anfang
oder in der Mitte ist zeitaufwändig.
• LinkedList: Geordnete Sequenz, bei der am Anfang und am Ende hinzugefügt, abgeholt
und gelöscht werden kann. Somit kann eine LinkedList auch als Queue , Deque oder
Stack verwendet werden. Das Einfügen in der Mitte geht sehr rasch.
• Set: Set = Menge: Elemente können nur einmal angefügt werden.
• HashSet: Set, der mit einer Hash-Tabelle Elemente einfügt und wieder finden kann. Es
entspricht etwa einer HashMap , bei der aber nur Keys und keine Values eingefügt werden.
• SortedSet, TreeSet: Set, der die Elemente sortiert. Bei der Implementation TreeSet wird
ein Baum als abstrakter Datentyp eingesetzt. Die compareTo() Funktion wird verwendet,
um Elemente an die richtige Position einzufügen.
181
A Anhang
A.21.2 Assoziative Arrays: Java- Map
Oftmals reichen ganze Zahlen nicht als vernünftige Indizes aus. Hier kommen Maps zum Zuge.
• Map: Interface mit den wichtigen Methoden put(key, value) ,

containsKey(key) , containsValue(value) , get(key) : value , remove(key) und
size() . Zum Iterieren werden die beiden Methoden keySet() und values() verwendet,
welche die Schlüssel bzw. die Datenobjekte zurückgeben.
• HashMap: Klassische assoziative Arrays. Bei assoziativen Arrays sind die Indizes nicht
Zahlen, sondern beliebige Schlüsselobjekte.
• LinkedHashMap: Wie die HashMap , jedoch wird zusätzlich eine Liste geführt, in welcher
Reihenfolge die Objekte hinzugefügt wurden.
• WeakHashMap: Objekte dürfen bei Nichtgebrauch vom Garbage Collector vernichtet wer-
den.
• SortedMap, TreeMap: Wie SortedSet bzw. TreeSet . Im Gegensatz zu diesen oben

genannten Objekten arbeiten die Maps auf den Schlüsseln und nicht auf den Datenobjekten.

A.21.3 Auf finden der richtigen Sammlung
Oft ist es nicht einfach zu sehen, welche Collection bzw. Map dann für ein Problem die geeignetste
Form ist. Hier eine Hilfe in Zweifelsfällen.
Ist ein schneller Zugriff über Schlüsselobjekte nötig?
• Map
Dürfen länger nicht benutzte Objekte vom Garbage Collector abgeräumt werden?
• WeakHashMap
Ist die Reihenfolge der Objekte relevant?
• List
• LinkedHashMap
Werden nur ab und zu, bzw. beim Initialisieren Daten hinzugefügt bzw. entfernt?
• ArrayList
Gibt es eine natürliche Ordnung (z. B. alphabetisch) auf den Daten bzw. auf den Schlüsseln?
• TreeSet bzw. TreeMap
Kann jedes Objekt nur einmal gespeichert werden? (Duplikate sind nicht gestattet.)
• Set
A.21.4 Eigene Sammelobjekte
Natürlich ist es auch möglich, eigene generische Datentypen herzustellen. Ein Beispiel findet sich
im Anhang: (s. Kap. A.22 auf Seite 184)
183
A Anhang
A.22 Eigene Sammelobjekte: Beispiel Kette (LinkedList)

Natürlich können wir für eine effiziente Softwareentwicklung Sammelobjekte (Container) wie
ArrayList , Set , Map , ... einfach verwenden. Für Interessierte ist es jedoch genauso spannend,
ein solche Sammlungen einmal selbst zu schreiben oder zumindest ein bestehendes Sammelobjekt
zu analysieren. Ein solches Verständnis hat zudem den Vorteil, dass bei mehreren Möglichkeiten
der beste Sammelcontainer ausgewählt wird — oder gar effizienter neu implementiert werden
kann.
Zunächst müssen wir uns im Klaren sein, welche Eigenschaften fast alle Sammelcontainer auf-
weisen. Dies sind: Hinzufügen, Entfernen, Zählen, Suchen, ... Wichtig ist aber auch, dass man
einem Container jedes beliebige Objekt hinzufügen kann. Der Container kümmert sich überhaupt
nicht um die Inhalte63 .
Somit verwenden die Sammelcontainer ihrerseits Referenzvariable auf die Nutzobjekte. Diese Re-
ferenzen können in Arrays, aber auch in eigenen Verpackungs-Objekten geführt werden.
Wir wollen als Beispiel eine verkettete Liste implementieren ( Kette , «linked List»). Sie ver-
wendet ein Kettenglied , um die Referenzen auf die Nutzdaten ( data ) zu speichern. Ebenso
muss natürlich ein Zeiger auf das vorangehende vorgaenger , wie einer auf das nachfolgende
Kettenglied ( nachfolger ) gespeichert werden:
Das erste Kettenglied hat keinen vorgaenger (wie auch das letzte keinen nachfolger hat).
Dies ist in der Grafik durch einen NIL-Pointer64 dargestellt.
63
Eine Ausnahme bilden die Sammelcontainer, welche die enthaltenen Objekte sortieren können. Hier wird meist
noch eine Funktion zum Vergleich der Objekte gefordert (z. B. gleich() , kleinerAls() , vergleicheMit() ).
64
NIL = «not in list» wird in Java mit dem null -Pointer implementiert.

Die Implementation der Kette kann dann wie folgt aussehen:
(Ich zeige hier lediglich exemplarisch die Methode existiert() . Die Klasse mit allen Sortier-,
Hinzufüge-, Auffind-, Entferne- etc. -Funktionen ist natürlich ziemlich lange.)
public class Kette <T > implements Iterable <T >{
Kettenglied <T > erstes ;
Kettenglied <T > letztes ;
int anzahlGlieder ;
public Kette () {
listeLeeren ();
}
public void listeLeeren () {

erstes = null ;
letztes = null ;
anzahlGlieder = 0 ;
}
public boolean existiert ( T objekt ) {

Kettenglied <T > akt = erstes ;
while ( null != akt )
{
if ( akt . getData () == objekt )
{
return true ;
}
akt = akt . nachfolger ;
}
return false ;
}
... // weitere Funktionen
185
A Anhang
Ein einzelnes Kettenglied könnte nun wie folgt aussehen:

public class Kettenglied <T > {
Kettenglied <T > vorgaenger ; // prev
Kettenglied <T > nachfolger ; // next
private T data ;
public Kettenglied ( T data ) {

this . data = data ;
}
public T getData () {
return data ;
}
} // end of class Kettenglied
Der generische Datentyp <T> sagt Java, dass hier ein beliebiges Objekt verwendet werden darf.
Es muss sich jedoch bei allen Objekten um Objekte derselben Klasse handeln.

A.23 Eingabe via Kommandozeilen-Argument
Die meisten Programmiersprachen können ihre Programme ab einer Konsole (shell, cmd) starten.
Die meisten davon wiederum kennen sogenannte Kommandozeilen-Argumente.
Die Java- main() -Methode muss eine Parameterliste vom Datentyp String[] aufweisen. Diese
Liste wird in den meisten Übungsaufgaben und Lehrbüchern mit args bezeichnet. Dieser Array
besteht aus den Strings, die beim Aufruf der Klasse der virtuellen Maschine mitgegeben wurden.
Starten wir z. B. ein Java-Programm Namens Hitch.class aus der Konsole mit dem folgenden
Befehl:
> java Hitch " Hallo ␣ Welt " 42 " marvin ␣ is ␣ cool "
So erhält die Variable String[] args in der Java-spancodemain-Methode die drei Argumente
• args[0] hat den Wert "Hallo Welt"
• args[1] hat den Wert "42" und
• args[2] hat den Wert "marvin is cool".
Ach ja, hier noch ein möglicher Quelltext des Programmes "Hitch":
package buchBeispiele . anhang ;
public class Hitch {

{
new Hitch (). top ( args );
}
void top ( String [] parameter )

{
int i = 0;
for ( String s : parameter )
{
System . out . println ( " args [ " + ( i ++) + " ] ␣ hat ␣ Wert ␣ " + s );
}
}
} // end of class Hitch
187
A Anhang
A.23.1 Typische Anwendung
Oft werden die String[] args verwendet um Filenamen (z. B. inFileName und outFileName )
anzugeben. Wenn jemand einen der beiden Namen vergisst, so soll eine Angabe zur typischen
Verwendung (usage) ausgegeben werden:
public class MainUsage {

{
if (2 != args . length )
{
printUsage () ;
System . exit (1); // Fehlercode > 0
}
new MainUsage (). top ( args );
}
void top ( String [] args )

{
String inFileName = args [0];
String outFileName = args [1];
... // TODO : Hauptprogramm hier .
}
static void printUsage ()

{
System . out . println ( " Verwende ␣ dieses ␣ Programm ␣ so : " );
System . out . println ( " java ␣ MainUsage ␣ < inName > ␣ < outName > " );
}
} // end of class MainUsage
Mittlerweile gibt es auch einige Frameworks, die einem das Parsen von umfassenden Kommando-
Argumenten erleichtern65 .
65
Siehe z. B. Usage Scenarios bei http://commons.apache.org/proper/commons-cli/

189
B | Aufgabenverzeichnis / Lösungen
Neben den offiziellen Aufgaben aus dem Buch [GFG11] und der zugehörigen Webseite hat es im
vorliegenden Skript weitere Aufgaben, welche hier zusammengefasst sind:
• Aufgabe Teilausdrücke (s. Kap. 1.1.1 auf Seite 18)
Lösung : w , 3.2 , x , 2 , y , sin(y) , 2 * sin(y) , x + 2 * sin(y) ,
3.2 * (x + 2 * sin(y)) und natürlich der Gesamtausdruck
w + 3.2 * (x + 2 * sin(y)) .
• int (s. Kap. 2.1 auf Seite 34) Hier wird ein Überlauf (Overflow) generiert.
• Die richtige Wahl (s. Kap. 3.10 auf Seite 52)

Kompiliert werden alle, außer D. Korrekt sind alle außer C und D. Die beste Lösung ist G.
• Name und Alter ausgeben (s. Kap. 5.1 auf Seite 70)
• Leseaufgabe zu den Parametern (s. Kap. 5.7 auf Seite 81)
c = 17
r = 46
x=33, y=42, z=33
• Person Erfassen (s. Kap. 8.1 auf Seite 102)
• Leseaufgaben zu Algorithmen (s. Kap. 9.1 auf Seite 112)
– «Selektion» Finde das Minimum ((4, 6, 3) liefert 3)
– «Iteration» Quadratzahl (4 liefert 16, 11 liefert 121)
– «Selektion und Iteration» Umdrehen der Ziffernfolge (236 wird zu 632)
– «Zahlenspielerei» Verdoppeln der Ziffernfolgen (236 wird zu 223366)
– «Fuß gesteuerte Schleife» Finde den kleinsten Teiler (63 liefert 3, 17 liefert 17)
– «Nur für Spieler» Finde heraus, ob der Array ein sog. Full-House darstellt: Ein Paar
+ ein Trippel.
– «Ein sehr alter Algorithmus» Wurzelziehen nach Heron: Berechnet die Quadratwurzel
• Teilstring (s. Kap. A.1 auf Seite 166)
• Verzeichnis ausgeben (s. Kap. A.2 auf Seite 169)
• Top (s. Kap. A.3 auf Seite 173)
• Zähler (s. Kap. A.4 auf Seite 173)
• Kodierungen (s. Kap. A.5 auf Seite 179)
• File Vergleich (s. Kap. A.6 auf Seite 179)
• File lesbar (s. Kap. A.7 auf Seite 179)
• Dateistruktur PNG (s. Kap. A.8 auf Seite 180)
191
C | Link-Verzeichnis
• http://commons.apache.org/proper/commons-cli/ : Umgang mit Kommandozeilenar-
gumenten
• https://github.com/pheek/javaInput/blob/master/Input.java : Vereinfachtes Einle-

sen von Zahlen und Text über die Konsole
• http://www.gress.ly/javastarter : Erstes Java-Programm als Download. Doch ich

rate allen, das Programm abzutippen und so eine erste Übung zu erhalten.
• http://www.oracle.com/technetwork/java/javase/downloads/index.html : Download
Java
• http://www.programmieraufgaben.ch : Aufgabenbuch zu diesem Skript
• http://smoch.santis-basis.ch/index.php/halbaddierer : Funktionsweise und Nach-

bau eines Halbaddierers
• http://www.santis-training.ch/java/javasyntax/keywords : Liste der Java Schlüs-

selwörter
• http://www.santis-training.ch/java/javasyntax/operatoren.php : Liste der Java

Operatoren
• http://www.santis-training.ch/java/pitfalls.php#c : Fehler und Fallen in Program-

miersprachen, vorwiegend in Java
• http://www.unicode.org : Vollständige Unicode Zeichentabelle
• http://www.wolframalpha.com : Lösen mathematisch formulierter Probleme online (z. B.

Gleichungssysteme)
193
D | Literaturverzeichnis
195
| Literatur
[Fre15] Freimann, Philipp G.: Objekte und Klassen. 2015
[GFG11] Gressly-Freimann, Philipp ; Guggisberg, Martin: Programmieren lernen. Orell

Füssli, 2011 http://www.programmieraufgaben.ch. – ISBN 978–3–280–04066–9
[Him01] Himanen, Pekka: Die Hacker- Ethik. Und der Geist des Informations- Zeitalters. Rie-
mann Verlag, 2001. – ISBN 978–3570500200
[Knu97] Knuth, Donald E.: The Art of Computer Programming. Addison Wesley, 1997 http:
//www.oose.de/uml. – ISBN 0–201–89683–4
[Tzu00] Tzu, Sun: Die Kunst des Krieges. -500
197
E | Stichwortverzeichnis
++ -Operator, 31, 59 BRAV, 48
BufferedReader , 96, 176
−− -Operator, 31
byte , 21, 134
< , 40
<= , 40 casting, 22
cd : change directory, 136
== , 40, 97, 168
char , 21, 134, 177
> , 40
Literal, 98
>= , 40 Chunk, 180
&& , 41 Classloader, 158
CMD, 136
ˆ , 41 Collection, 103
|| , 41 Collection , 107, 181
collection framework, 181
Abbruchbedingung, 57 Collection Framework, 107
Abfolge, 29 Compiler, 129
Abkürzung, 41
Dank, 13
add() -Methode, 103
Datei, 96, 169
Algorithmus, 111 Daten
Aneinanderreihung, 29 metrische, 22
Anweisung, 29, 30 Datenstrom, 177
Argument, 69, 70 Datenstruktur, 101
Array, 85 Datentyp, 17, 25, 134
assoziatives, 104 Datentypen, 21
Syntax, 87 De Morgan’sche Regeln, 43
ArrayList , 103, 106, 181 debuggen, 126
Arrays, 164 Dekomposition
anonyme, 164 funktionale, 65
Arrays und Schleifen, 88 del : Delete, 136
ASCII, 178
Deque , 181
Ausdruck, 17, 18, 75
Ausgabe, 140 dir : Directory Listing, 136
Auswahl, 37 Divide et Impera, 65
Auswertungsreihenfolge, 20 do , 57
BASH, 130, 136 DOS, 136
Befehl, 29 double , 21, 134
Bezeichner, 26 DUFTE, 50
BigInteger , 23
eclipse, 136
binär, 19 Eingabe, 140
Bit, 39 Einlesen, 140
Bit, Binary Digit, 21 else , 38
byte , 177 Encoding, 178
Boole, George, 21 End of File, 171
boolean , 21, 40, 134 Entscheidung, 37
199
STICHWORTVERZEICHNIS
enum , 159 Integer, 21

EOF, 171 Invariante
equals() , 97, 168 Schleife, 148
Selektion, 51
EVA, 72, 174
IOException , 170
Feld, 85 Iteration, 55
assoziatives, 104 Iterationsinvariante, 148
Fibonacci, 74, 123
File, 96, 180 Java
File -Klasse, 169 Kompilationseinheit, 154
JDK, 129
File-Handling, 169
Jump, 55
FileInputStream , 176, 177, 179 JVM, 129
FileReader , 170
Kellerspeicher, 103
FileWriter , 170 Kette, 184
Filter, 174 Key, 104
float , 134 Klasse, 101
innere, 155
for -Schleife, 61 Java, 154
for-each, 88 Kodierung, 175, 178
Framework, 188 Kommentare, 154
Funktion, 65, 71 Kompilationseinheit, 154
Resultat, 18 Konsole, 130
funktionale Dekomposition, 65 Konstante, 18
Funktionsresultate vernichten, 77
Länge
ganze Zahlen, 21 Strings, 166
gebrochene Zahlen, 22 von Strings, 94, 166
Vergleiche, 48 length() , 94, 166
Geek-Style, 163 Leseaufgaben, 112
Geringschätzung, 77 Lesen
globale Variable, 76 von Dateien, 177
GRIPS, 80 Level
Halbaddierer, 21 Operatoren, 20
HashMap , 104, 106, 182 LineNumberReader() , 170
Linked List, 184
HashSet , 104, 181
LinkedList , 103, 181
Herrscher, 65
Linkverzeichnis, 193
identifier, 26 Linux Kommandos, 136
if , 37 List , 103, 181
Indexoperator, 85 Liste, 103
InputStream , 177 Literal, 18, 21
char , 98
InputStreamReader , 175, 176, 179 LOGIK, 49
int , 21, 134 lokale Variable, 76
spancodeint, 21 long , 21, 134

ls : Listing-Kommando, 136 reservierte Wörter, 139
Restbildung, 19
Map , 104, 182 Resultat
Maskierung Funktion, 18
Bit, 162 rm : remove, 136
Mehrfachselektion, 45
Member, 155 Sammelobjekt, 103
Menge, 104, 162 Scanner , 142
Methode, 65 Scanner Einlesen via Tastatur, 94
Methodensyntax, 150 Schlüssel, 104
metrische Daten, 22 Schlüsselwort, 139
mkdir : make directory, 136 Schleife, 55
MODULO, 19 Schleifen
Felder, 88
netbeans, 136
Schleifeninvariante, 148
Notation
Schreiben
wissenschaftliche, 22
in Dateien, 177
null , 171 Scope, 62
Selektion, 37
Objekt, 101
Selektionsinvariante, 51
objektorientiert, 12
Sequenz, 29
Operator, 17
+ für Strings, 97 Set , 104, 107, 181
Operatoren shell, 136
logische, 41 short , 21, 134
OutputStream , 177 Sichtbarkeit, 62
Overloading Unterprogramm, 70
Subroutine, 151 Simulation, 119
size() , 182
Parameter, 69
performant, 124 SortedSet , 104, 181
PNG-Dateien, 180 Sprung, 55
println , 15, 29, 140 Stack, 103, 152
Programmierung Stack
strukturierte, 10 Datenstruktur, 181
Prozedur, 65 Standardtypen, 21
Punkt-Vor-Strich, 20 Stapel, 152
Statement, 29
Random, 119 Stream, 177
Randomaccess, 180 streamen, 174
Reader, 170 Strichpunkt
Reader , 170, 177 Warnhinweis, 147
readLine() -Funktion, 96, 172, 176 String , 21, 93, 93, 134, 166
Referenzvariable, 76 Teil, 166
Regeln von De Morgan, 43 Vergleich, 97
Reihung, 85 StringBuilder , 167
Rekursion, 123 strukturierte Programmierung, 10
201
STICHWORTVERZEICHNIS
Subroutine, 65 Wörter
Überladen, 151 reservierte, 139
Java-Syntax, 150 Wächter, 79
Subroutinen while , 55, 57
Anmerkungen, 147 Wissenschaftlichen Notation, 22
Substring, 166 write() -Funktion, 170
switch , 46 Writer, 170
Syntax Writer , 177
Arrays, 87
System.in , 142 Zahlen, 21
ganze, 21
System.out.println , 15, 29, 140
gebrochene, 22, 48
Zählervariable, 59
Tabelle, 89
Zeichenketten, 93
Teile und Herrsche, 65
Teil, 166
Terminal, 136
Vergleich, 97
ternär, 19
Zufallszahl, 119
Tree, 104
Zugriff
TreeSet , 104, 181 auf Attribute, 102
Typumwandlung, 22 Zusammenfügen
von Strings, 94
Überladen Zuweisung, 33
Unterprogramm, 151 Zweiersystem, 21
unär, 19
Unicode, 98, 135, 166
Unterprogramm, 65
Unveränderbarkeit
von Strings, 167
Usage der main-args , 188
UTF-8, 98, 178
Variable, 18, 24, 158

globale, 76
lokale, 76
Vektor, 85
Vergleich von Strings, 97
Vergleiche mit gebrochenen Zahlen, 48
vergleichen
logisch, 41
Zahlen, 40
Vernichten von Funktionsresultaten, 77
Verzweigung, 37
virtuelle Maschine, 129
void , 69
Vorrangregeln, 20
Vorwort, 10
Vorzeichen behaftet, 21

Strukturiert Programmieren Lernen Mit Java

Hochgeladen von

Copyright:

Verfügbare Formate

Strukturiert Programmieren Lernen Mit Java

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Strukturiert Programmieren Lernen Mit Java

Hochgeladen von

Copyright:

Verfügbare Formate

Strukturiert programmieren mit Java

Philipp Gressly Freimann © 17. Juli 2019 (Version 1.2.21 (TeX))

Alle Rechte vorbehalten

Herausgeber: Philipp Gressly Freimann

10 Strukturiert programmieren mit Java - Grundkonzepte

Bewährt den Forscher der Natur

• überhaupt nicht programmieren

12 Strukturiert programmieren mit Java - Grundkonzepte

Dieses Programm wird

1. In einem Texteditor geschrieben und als MeinErstes.java gespeichert;

2. mit dem Java-Compiler kompiliert javac MeinErstes.java ;

3. und zuletzt mit der Java-virtuellen Maschine (JVM) ausgeführt:

x + 15 * len ( " Hallo ␣ Welt " )

• Zusammengesetzte Ausdrücke Ebenso können Ausdrücke mit speziellen Operatoren

Aufgabe: Finden Sie alle zehn (Teil)ausdrücke im folgenden Ausdruck:

Lösung (s. Kap. B auf Seite 191).

18 Strukturiert programmieren mit Java - Grundkonzepte

• Restbildung ( % )(s. Kap. 1.1.3 auf Seite 19)

1.1.3 Restbildung (Modulo %)

1.2 Unär, binär, ternär

... wie folgt geklammert:

Obiger Ausdruck wird wie folgt geklammert:

20 Strukturiert programmieren mit Java - Grundkonzepte

1.4.1 Ganze Zahlen

1.4.2 Der Halbaddierer

1.4.3 Gebrochene Zahlen (metrische Daten)

• 5.7e6 = 5 700 000 = 5.7· 106

// Diese Umwandlung ist trivial :

// Dies ist nur mit Casting erlaubt :

22 Strukturiert programmieren mit Java - Grundkonzepte

double abstandInMetern = 4.88 ;

24 Strukturiert programmieren mit Java - Grundkonzepte

In unserem Beispiel wird das Bitmuster «1100 1010» in die Va-

1.5.2 Bezeichner (identifier)

• Bezeichner dürfen Buchstaben, Ziffern, Währungssymbole und den Unterstrich ( _ ) enthal-

• Bezeichner dürfen nicht mit einer Ziffer beginnen.

Gut sind Bezeichner wie: x , aktuelleZeit , width , TAUSEND . . .

Aufgaben aus «Programmieren lernen» [GFG11]

• 1. 2 Berechnung von Ausdrücken (1) (Web-Code: 8kqe-uout)

• 1. 3 Berechnung von Ausdrücken (2) (Web-Code: mupd-pv9h)

26 Strukturiert programmieren mit Java - Grundkonzepte

2.1 Abfolgen (Sequenzen)

• Deklarieren von Variablen:

– Zuweisen von Literalen (Konstanten):

Scanner sc = new Scanner ( System . in );

– Hilfsfunktionen (Kalender, Ausgabeformat, ...):

Calendar cal = new GregorianCalendar () ;

30 Strukturiert programmieren mit Java - Grundkonzepte

• Variableninkrement bzw. -dekrement (z. B. ++i; , x--; )

• Return Anweisung ( return; )

• Objekterzeugung (z. B. new JFrame(); )

• try - catch -Block

32 Strukturiert programmieren mit Java - Grundkonzepte

Beachten Sie den folgenden Code:

Aufgaben aus «Programmieren lernen» [GFG11]

• 2. 1 Hello World (Web-Code: hr5f-yysf)

• 2. 3 Variablenwert nach einer Sequenz (Web-Code: pi2t-72oe)

• 2. 4 Ohm’sche Gesetze (Web-Code: po9n-fjn6)

• Satz von Pick (Web-Code: hpaj-dw3x)

• 2. 5 Abbildungsgleichung (Web-Code: 2v7c-bobb)