(c) APSIS GmbH

Inhaltsverzeichnis

des Lehrbuchs

Verzeichnis der Beispielprogramme

Übungslösungen

Ausführliches Inhaltsverzeichnis

Inhaltsverzeichnis * Seite I

• Vorwort * Seite IX
• Danksagungen * Seite XI
• Die Lehrbuchbibliothek * Seite XI

1. Informelle Einführung * Seite 1

• 1.1. Die Dualität des Programmierens * Seite 1
• 1.1.1. Geschwindigkeit * Seite 1
• 1.1.2. Datenmenge * Seite 2
• 1.1.3. Die Komplexität * Seite 2
• 1.1.4. Kapselung * Seite 3
• 1.2. Das Schichtenmodell * Seite 4
• 1.3. Werkzeuge des Programmierens * Seite 6
• 1.3.1. Der Editor * Seite 8
• 1.3.2. Der Übersetzer * Seite 8
• 1.3.3. Der Binder * Seite 9
• 1.3.4. Der Ausführer * Seite 9
• 1.3.5. Das Laufzeitsystem * Seite 10
• 1.3.6. Der Bibliothekar * Seite 11
• 1.3.7. Testwerkzeuge * Seite 11
• 1.3.8. Generatoren * Seite 12
• 1.3.9. Die Entwicklungsumgebung * Seite 13
• 1.4. Fehlerarten * Seite 13
• 1.5. Struktur einer Programmiersprache * Seite 14
• 1.5.1. Sprachdefinition * Seite 14
• 1.5.2. Zeichensatz * Seite 14
• 1.5.3. Syntax * Seite 15
• 1.5.4. Semantik * Seite 16

2. Klassen und Objekte * Seite 18

• 2.1. Die leere Klasse * Seite 18
• 2.2. Erweiterung von Klassen * Seite 20
• 2.2.1. Erweiterung eigener Klassen * Seite 20
• 2.2.2. Klassen in Paketen * Seite 21
• 2.2.3. Erben von Methoden * Seite 22
• 2.2.4. Das Hallo-Programm * Seite 23
• 2.2.5. Mehrfache Erweiterung * Seite 23
• 2.2.6. Überschreiben von Methoden * Seite 24
• 2.2.7. Aufruf von geerbten Methoden * Seite 25
• 2.2.8. Hinzufügen von Methoden * Seite 27
• 2.2.9. Private Methoden * Seite 28
• 2.2.10. Parameter * Seite 29
• 2.2.11. Mehrere Parameter * Seite 30
• 2.2.12. Methodenaufrufe aus Klassen * Seite 30
• 2.2.13. Import * Seite 31
• 2.2.14. Klassenspezifikationen * Seite 31
• 2.3. Datenbehälter * Seite 33
• 2.3.1. Statische Datenbehälter * Seite 33
• 2.3.2. Operationen * Seite 34
• 2.4. Algorithmen * Seite 35
• 2.4.1. Elementare Algorithmen * Seite 35
• 2.4.2. Programm- und Datenbehälterklassen * Seite 36
• 2.4.3. Sequenzen * Seite 36
• 2.4.4. Statisches und dynamisches Ende * Seite 37
• 2.5. Ausnahmen * Seite 38
• 2.5.1. Ausnahmebehandlung * Seite 38
• 2.5.2. Reihenfolgebedingungen * Seite 39
• 2.5.3. Ausnahmeverteiler * Seite 39
• 2.5.4. Ausnahmespezifikation * Seite 40
• 2.5.5. Geprüfte und ungeprüfte Ausnahmen * Seite 40
• 2.5.6. Weiterreichen von Ausnahmen * Seite 42
• 2.6. Dynamische Objekte * Seite 43
• 2.6.1. Ausprägung einer Klasse * Seite 43
• 2.6.2. Referenzen und Objekte * Seite 44
• 2.6.3. Erzeugung von Objekten * Seite 45
• 2.6.4. Zuweisung * Seite 47
• 2.6.5. Typprüfung * Seite 47
• 2.6.6. Lokale und globale Referenzen * Seite 48

3. Strukturierung von Klassen * Seite 50

• 3.1. Prozeduren * Seite 50
• 3.1.1. Aufruf von Prozeduren * Seite 50
• 3.1.2. Schachtelung von Algorithmen * Seite 51
• 3.1.3. Steuerfluss * Seite 52
• 3.1.4. Parametrisierte Prozeduren * Seite 54
• 3.1.5. Globale Referenz oder Parameter * Seite 56
• 3.1.6. Wert- und Referenzübergabe * Seite 57
• 3.1.7. Parametrisierte Operationen * Seite 58
• 3.2. Pakete * Seite 59
• 3.2.1. Spezifikation eines Pakets * Seite 59
• 3.2.2. Implementierung eines Pakets * Seite 61
• 3.3. Schachtelungen * Seite 62
• 3.3.1. Sichtbarkeit und Lebensdauer * Seite 63
• 3.3.2. Statische Schachtelung von Klassen * Seite 65
• 3.3.3. Blöcke * Seite 66
• 3.3.4. Geschützte Blöcke * Seite 67
• 3.3.5. Der Stapel * Seite 68
• 3.3.6. Rekursive Aufrufe * Seite 69
• 3.3.7. Abbruch einer Rekursion * Seite 70
• 3.3.8. Wirkungsmechanismus der Ausnahmen * Seite 71
• 3.4. Verwendung von Standardpaketen * Seite 72
• 3.4.1. Geschachtelte Pakete * Seite 72
• 3.4.2. Standardpakete * Seite 73
• 3.4.3. Das Standard-Hallo-Applet * Seite 73
• 3.4.4. Das Standard-Hallo-Anwendung * Seite 74
• 3.4.5. Implizite Erweiterung * Seite 75
• 3.4.6. Impliziter Import * Seite 76

4. Implementierung von Datenbehältern * Seite 77

• 4.1. Klassenkomponenten * Seite 77
• 4.2. Implementierung von Ausnahmen * Seite 79
• 4.2.1. Verbreitung von Ausnahmen * Seite 79
• 4.2.2. Auslösen von Ausnahmen * Seite 79
• 4.2.3. Klasseninitialisator * Seite 80
• 4.3. Objektkomponenten * Seite 81
• 4.3.1. Implementierung von dynamischen Datenbehältern * Seite 81
• 4.3.2. Klassen- und Objektkomponenten * Seite 82
• 4.3.3. Ledige Objekte * Seite 83
• 4.4. Schnittstellen * Seite 83
• 4.4.1. Kopieren * Seite 84
• 4.4.2. Einkaufen * Seite 85
• 4.4.3. Erben * Seite 85
• 4.4.4. Implementierung von Schnittstellen * Seite 86
• 4.5. Konstruktoren und Destruktoren * Seite 87
• 4.5.1. Konstruktoren * Seite 87
• 4.5.2. Destruktoren * Seite 89
• 4.6. Typkompatibilität * Seite 89
• 4.6.1. Aufwärtskompatibilität * Seite 89
• 4.6.2. Erzwungene Abwärtskompatibilität * Seite 91
• 4.6.3. Typschwäche * Seite 93
• 4.6.4. Polymorphie * Seite 93

5. Werte * Seite 97

• 5.1. Wertefunktionen * Seite 97
• 5.1.1. Parametrisierte Mutatoren für statische Objekte * Seite 97
• 5.1.2. Parametrisierte Mutatoren für dynamische Objekte * Seite 98
• 5.1.3. Inhalt eines Behälters * Seite 99
• 5.2. Funktionen * Seite 99
• 5.2.1. Informatoren für statische Objekte * Seite 100
• 5.2.2. Informatoren für dynamische Objekte * Seite 100
• 5.2.3. Implementierung von Informatoren * Seite 101
• 5.2.4. Private Funktionen * Seite 102
• 5.2.5. Konstante Parameter * Seite 103
• 5.3. Duplizieren von Inhalten * Seite 103
• 5.3.1. Kopie * Seite 103
• 5.3.2. Zuweisung * Seite 104
• 5.3.3. Klonen * Seite 105
• 5.4. Profilkompatibilität * Seite 106
• 5.4.1. Profilkompatibilität beim Aufruf * Seite 107
• 5.4.2. Signaturidentität * Seite 108
• 5.5. Verwendung von Informatoren * Seite 109
• 5.5.1. Standardinformatoren * Seite 109
• 5.5.2. Geschachtelte Informatoraufrufe * Seite 110
• 5.5.3. Informatoren als Objektlieferanten * Seite 111
• 5.5.4. Spezifikation von Informatoren * Seite 113
• 5.5.5. Werte als Referenzen * Seite 114
• 5.5.6. Export und Import * Seite 115

6. Ereignissteuerung * Seite 117

• 6.1. Menüs für Programmsteuerung * Seite 118
• 6.1.1. Das leere Menü * Seite 118
• 6.1.2. Anonyme Objekte * Seite 119
• 6.1.3. Menügesteuerte Programme * Seite 119
• 6.2. Rückruf * Seite 120
• 6.2.1. Prozedurparameter * Seite 120
• 6.2.2. Überschreiben leerer Methoden * Seite 122
• 6.2.3. Mehrere Menüversionen * Seite 123
• 6.2.4. Geschachtelte Klassen * Seite 124
• 6.2.5. Anonyme Klassen * Seite 125
• 6.2.6. Mehrere Menüpunkte * Seite 125
• 6.2.7. Aufgeschobene Methoden * Seite 126
• 6.2.8. Mehrere aufgeschobene Methoden * Seite 127
• 6.3. Werkzeuge für Anwenderkommunikation * Seite 128
• 6.3.1. Menügeneratoren * Seite 128
• 6.3.2. Direktmenüs * Seite 129
• 6.3.3. Auswahllisten * Seite 130
• 6.3.4. Eingabemasken * Seite 131
• 6.4. Objektwahl * Seite 132
• 6.4.1. Aktion nach Vorwahl * Seite 132
• 6.4.2. Referenzen als Gedächtnis * Seite 132
• 6.4.3. Polymorphe Objektwahl * Seite 133
• 6.5. Ereignissteuerung durch Standardklassen * Seite 137
• 6.5.1. Standardklassen für Anwenderkommunikation * Seite 137
• 6.5.2. Lauscher * Seite 137
• 6.5.3. Verteilung der Ereignisse * Seite 139
• 6.5.4. Standardmenüs * Seite 139
• 6.5.5. Menüsteuerung * Seite 141
• 6.5.6. Verteilung der Menüereignisse * Seite 142

7. Einfache Klassen und Basistypen * Seite 144

• 7.1. Aufzählungsklassen * Seite 144
• 7.1.1. Aufzählungsmethoden * Seite 145
• 7.1.2. Importierte Aufzählungsklassen * Seite 146
• 7.1.3. Definition von Aufzählungsklassen * Seite 147
• 7.1.4. Implementierungslogik * Seite 149
• 7.2. Logische Objekte * Seite 150
• 7.2.1. Logische Klassen * Seite 151
• 7.2.2. Logische Literale * Seite 151
• 7.2.3. Der Basistyp boolean * Seite 152
• 7.2.4. Logische Informatoren * Seite 153
• 7.2.5. Vergleichsoperationen * Seite 154
• 7.3. Zeichen * Seite 155
• 7.3.1. Zeichenliterale * Seite 155
• 7.3.2. Der Basistyp char * Seite 156
• 7.3.3. Hüllenklassen für Zeichen * Seite 157
• 7.4. Operatoren * Seite 157
• 7.4.1. Basistypen und Klassen * Seite 158
• 7.4.2. Typbindung von Variablen * Seite 159
• 7.4.3. Gleichheitsoperatoren * Seite 159
• 7.4.4. Ordnungsoperatoren * Seite 160
• 7.4.5. Logische Operatoren * Seite 161
• 7.5. Arithmetische Basistypen * Seite 162
• 7.5.1. Ganzzahltypen * Seite 162
• 7.5.2. Variablen als Datenkomponenten * Seite 164
• 7.5.3. Verwendung von Hüllenklassen * Seite 165
• 7.5.4. Bruchtypen * Seite 166
• 7.6. Ausdrücke * Seite 167
• 7.6.1. Geschachtelte Aufrufe * Seite 167
• 7.6.2. Kombination von Operatoren * Seite 169
• 7.7. Zusicherungen * Seite 169

8. Multibehälter * Seite 171

• 8.1. Mengen * Seite 172
• 8.1.1. Farbmengen * Seite 172
• 8.1.2. Erweiterung von Multibehältern * Seite 173
• 8.1.3. Zeichenmengen * Seite 174
• 8.1.4. Persistenz * Seite 175
• 8.1.5. Generische Mengen * Seite 175
• 8.1.6. Polymorphe Mengen * Seite 177
• 8.1.7. Diskrete Mengen * Seite 178
• 8.1.8. Iteratoren * Seite 179
• 8.2. Säcke * Seite 180
• 8.3. Folgen * Seite 181
• 8.3.1. Zeichenfolgen * Seite 181
• 8.3.2. Listen * Seite 182
• 8.3.3. Warteschlangen * Seite 182
• 8.3.4. Verwendung von Multibehältern * Seite 184
• 8.3.5. Stapel * Seite 185
• 8.3.6. Positionierbare Listen * Seite 187
• 8.3.7. Implementierung mit positionierbaren Listen * Seite 187
• 8.3.8. Sequenzielle Dateien * Seite 188
• 8.3.9. Sortierkanäle * Seite 190
• 8.4. Assoziativspeicher * Seite 192
• 8.4.1. Allgemeine Assoziativspeicher * Seite 192
• 8.4.2. Direkte Dateien * Seite 193

9. Implementierung von Multibehältern * Seite 195

• 9.1. Verbunde * Seite 195
• 9.2. Reihungen * Seite 196
• 9.2.1. Reihungsobjekte * Seite 196
• 9.2.2. Reihungsklassen * Seite 197
• 9.2.3. Die Standardklassen für Zeichenketten * Seite 198
• 9.2.4. Kommandozeilenparameter * Seite 199
• 9.2.5. Übersetzungstabellen * Seite 200
• 9.2.6. Mehrdimensionale Reihungen * Seite 201
• 9.2.7. Implementierung von Multibehältern als Reihung * Seite 201
• 9.3. Verkettete Listen * Seite 203
• 9.3.1. Rekursiv vereinbarte Klassen * Seite 203
• 9.3.2. Verkettung * Seite 204
• 9.3.3. Rückwärts verkettete Listen * Seite 204
• 9.3.4. Rekursive Abarbeitung einer Liste * Seite 205
• 9.3.5. Vorwärts verkettete Listen * Seite 209
• 9.3.6. Doppelt verkettete Listen * Seite 211
• 9.3.7. Binärbäume * Seite 212
• 9.3.8. Mehrfach verkettete Listen * Seite 213
• 9.3.9. Dynamische Reihungen * Seite 214

10. Steuerstrukturen * Seite 216

• 10.1. Alternativen * Seite 216
• 10.1.1. Verzweigungen * Seite 216
• 10.1.2. Fallunterscheidungen * Seite 218
• 10.1.3. Schachtelung von Alternativen * Seite 218
• 10.1.4. Kombination von Bedingungen * Seite 218
• 10.1.5. Erkennen einer Ausnahmesituation * Seite 219
• 10.1.6. Vorbeugende Ausnahmebehandlung * Seite 221
• 10.2. Zählergesteuerte Wiederholungen * Seite 222
• 10.2.1. Zählschleifen * Seite 222
• 10.2.2. Implementierung diskreter Multibehälter * Seite 224
• 10.2.3. Relevante Gleichheit * Seite 226
• 10.2.4. Vektoren * Seite 227
• 10.2.5. Matrizen * Seite 229
• 10.3. Bedingungsgesteuerte Wiederholungen * Seite 230
• 10.3.1. Endlosschleifen * Seite 231
• 10.3.2. Rumpfgesteuerte Schleifen * Seite 231
• 10.3.3. Kopf- und fußgesteuerte Schleifen * Seite 233
• 10.3.4. Implementierung der Persistenzoperationen * Seite 234
• 10.3.5. Abarbeitung einer Liste * Seite 234
• 10.3.6. Dateiverarbeitung * Seite 235
• 10.3.7. Assoziativtabellen * Seite 236
• 10.3.8. Verwendung der Schleifenarten * Seite 237
• 10.3.9. Gleichwertigkeit von Wiederholungen * Seite 238
• 10.3.10. Hierarchie der Algorithmen * Seite 239

11. Algorithmen * Seite 240

• 11.1. Komplexität von Algorithmen * Seite 240
• 11.1.1. Maximale Teilsumme * Seite 241
• 11.1.2. Zeit gegen Raum * Seite 241
• 11.2. Rekursion und Wiederholung * Seite 242
• 11.2.1. Fakultät * Seite 243
• 11.2.2. Die Fibonacci-Zahlen * Seite 244
• 11.2.3. Die Türme von Hanoi * Seite 245
• 11.2.4. Sortieren mit Binärbaum * Seite 246
• 11.3. Klassische Sortierverfahren * Seite 248
• 11.3.1. Quadratische Verfahren * Seite 248
• 11.3.2. Höhere Verfahren * Seite 250
• 11.3.3. Logarithmische Verfahren * Seite 251
• 11.3.4. Messungen * Seite 255
• 11.4. Binärbäume * Seite 257
• 11.4.1. Eintragen und Durchwandern * Seite 258
• 11.4.2. Löschen in Bäumen * Seite 259
• 11.4.3. Eintragen in ausgeglichene Bäume * Seite 261
• 11.4.4. Löschen in ausgeglichenen Bäumen * Seite 266
• 11.5. Komplexitätsvergleich * Seite 267

12. Nebenläufigkeit * Seite 269

• 12.1. Prozesse * Seite 269
• 12.1.1. Disjunkte und voneinander abhängige Prozesse * Seite 269
• 12.1.2. Kritische Abschnitte und gegenseiter Ausschluss * Seite 270
• 12.1.3. Synchronisierung * Seite 271
• 12.1.4. Semaphore * Seite 271
• 12.1.5. Nachrichtenaustausch * Seite 273
• 12.1.6. Monitore * Seite 273
• 12.2. Nebenläufige Prozesse in Java * Seite 274
• 12.2.1. Prozesse und Monitore * Seite 274
• 12.2.2. Synchronisierung auf Grund von Zusatzbedingungen * Seite 276
• 12.2.3. Unterbrechungen * Seite 277
• 12.2.4. Weitere Synchronisierungsoperationen * Seite 278

13. Standardpakete * Seite 279

• 13.1. Das Fensterpaket – java.awt * Seite 280
• 13.1.1. Fensterkomponenten * Seite 281
• 13.1.2. Anordnung der Komponenten * Seite 282
• 13.1.3. Ereignisse und Reaktionen * Seite 283
• 13.1.4. Grafik * Seite 285
• 13.1.5. Bildschirmausdrucke * Seite 287
• 13.2. Quelltextinformation zur Laufzeit – java.lang.reflect * Seite 288
• 13.2.1. Methoden finden * Seite 288
• 13.2.2. Datenkomponenten finden * Seite 290
• 13.3. Datei-Ein/Ausgabe – java.io * Seite 291
• 13.4. Java im Internet * Seite 294
• 13.4.1. Sicherheitskonzepte * Seite 295
• 13.4.2. Applets * Seite 295
• 13.4.3. Einbinden entfernter Applets in Netzseiten * Seite 297
• 13.4.4. Adressieren entfernter Objekte * Seite 297
• 13.4.5. Laden entfernter Textobjekte * Seite 298
• 13.4.6. Laden entfernter allgemeiner Objekte * Seite 299
• 13.4.7. Fernaufruf von Methoden * Seite 301
• 13.5. Ausblick * Seite 304

Literatur * Seite 306

• 1. Java auf Deutsch * Seite 306
• 2. Java auf Englisch * Seite 306
• 3. Anderes * Seite 307

Internet-Adressen * Seite 308

Glossar * Seite 309

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Sachwortverzeichnis * Seite 329

(c) APSIS GmbH