Inhaltsverzeichnis

1. Informelle Einführung
1.1. Die Dualität des Programmierens
1.1.1. Geschwindigkeit
1.1.2. Datenmenge
1.1.3. Die Komplexität
1.1.4. Kapselung
1.1.5. Programmierparadigma
1.1.6. Programmiersprachen
1.2. Das Schichtenmodell
1.3. Werkzeuge des Programmierens
1.3.1. Der Editor
1.3.2. Der Übersetzer
1.3.3. Der (statische) Binder
1.3.4. Dynamisches Binden
1.3.5. Der Ausführer
1.3.6. Das Laufzeitsystem
1.3.7. Der Bibliothekar
1.3.8. Dokumentationswerkzeuge
1.3.9. Testwerkzeuge
1.3.10. Generatoren
1.3.11. Die Entwicklungsumgebung
1.4. Java-Werkzeuge
1.5. Fehlerarten
1.6. Struktur einer Programmiersprache
1.6.1. Sprachdefinition
1.6.2. Zeichensatz
1.6.3. Syntax
1.6.4. Semantik
2. Klassen und Objekte
2.1. Die leere Klasse
2.2. Erweiterung von Klassen
2.2.1. Erweiterung eigener Klassen
2.2.2. Klassen in Paketen
2.2.3. Erben von Methoden
2.2.4. Das Hallo-Programm
2.2.5. Mehrfache Erweiterung
2.2.6. Überschreiben von Methoden
2.2.7. Aufruf von geerbten Methoden
2.2.8. Hinzufügen von Methoden
2.2.9. Interne Methoden
2.2.10. Parameter
2.2.11. Mehrere Parameter
2.2.12. Methodenaufrufe aus Klassen
2.2.13. Import
2.2.14. Klassenspezifikationen
2.2.15. Lesbarkeit von Programmen
2.3. Datenbehälter
2.3.1. Statische Datenbehälter
2.3.2. Operationen
2.4. Algorithmen
2.4.1. Elementare Algorithmen
2.4.2. Programm- und Datenbehälterklassen
2.4.3. Sequenzen
2.4.4. Statisches und dynamisches Ende
2.5. Ausnahmen
2.5.1. Ausnahmebehandlung
2.5.2. Reihenfolgebedingungen
2.5.3. Ausnahmeverteiler
2.5.4. Ausnahmespezifikation
2.5.5. Geprüfte und ungeprüfte Ausnahmen
2.5.6. Weiterreichen von Ausnahmen
2.6. Dynamische Objekte
2.6.1. Ausprägung einer Klasse
2.6.2. Referenzen und Objekte
2.6.3. Erzeugung von Objekten
2.6.4. Zuweisung
2.6.5. Typprüfung
2.6.6. Lokale und globale Referenzen
3. Strukturierung von Klassen
3.1. Prozeduren
3.1.1. Aufruf von Prozeduren
3.1.2. Schachtelung von Algorithmen
3.1.3. Steuerfluss
3.1.4. Parametrisierte Prozeduren
3.1.5. Globale Referenz oder Parameter
3.1.6. Wert- und Referenzübergabe
3.1.7. Parametrisierte Methoden
3.2. Pakete
3.2.1. Spezifikation eines Pakets
3.2.2. Implementierung eines Pakets
3.3. Schachtelungen
3.3.1. Sichtbarkeit und Lebensdauer
3.3.2. Statische Schachtelung von Klassen
3.3.3. Blöcke
3.3.4. Geschützte Blöcke
3.3.5. Benutzung von Blöcken
3.3.6. Der Stapel
3.3.7. Rekursive Aufrufe
3.3.8. Abbruch einer Rekursion
3.3.9. Wirkungsmechanismus der Ausnahmen
3.4. Standardpakete
3.4.1. Geschachtelte Pakete
3.4.2. Verwendung von Standardpaketen
3.4.3. Applets
3.4.4. Hauptprogramme
3.4.5. Implizite Erweiterung
3.4.6. Impliziter Import
4. Implementierung von Datenbehältern
4.1. Klassenkomponenten
4.2. Implementierung von Ausnahmen
4.2.1. Verbreitung von Ausnahmen
4.2.2. Auslösen von Ausnahmen
4.2.3. Klasseninitialisator
4.3. Objektkomponenten
4.3.1. Implementierung von dynamischen Datenbehältern
4.3.2. Klassen- und Objektkomponenten
4.3.3.4.4. Schnittstellen
4.4.1. Kopieren
4.4.2. Erwerben
4.4.3. Erben
4.4.4. Implementierung von Schnittstellen
4.4.5. Erweiterung von Schnittstellen
4.5. Konstruktoren und Destruktoren
4.5.1. Konstruktoren
4.5.2. Destruktoren
4.6. Typkompatibilität
4.6.1. Aufwärtskompatibilität
4.6.2. Unspezifische Ausnahmebehandlung
4.6.3. Erzwungene Abwärtskompatibilität
4.6.4. Typschwäche
4.6.5. Polymorphie
4.7. Standardklassen als Datenbehälter
4.7.1. Knöpfe
4.7.2. Zeichenketten
5. Werte und Funktionen
5.1. Wertefunktionen
5.2. Funktionen
5.2.1. Informatoren für Datenbehälter
5.2.2. Konstante und endgültige Methoden
5.2.3. Implementierung von Funktionen
5.2.4. Interne Funktionen
5.2.5. Konstante Parameter
5.3. Duplizieren von Inhalten
5.3.1. Kopie
5.3.2. Zuweisung
5.3.3. Klonen
5.4. Profilkompatibilität
5.4.1. Profilkompatibilität beim Aufruf
5.4.2. Signaturidentität
5.5. Verwendung von Funktionen
5.5.1. Standardfunktionen
5.5.2. Geschachtelte Funktionsaufrufe
5.5.3. Funktionen als Objektlieferanten
5.5.4. Spezifikation von Funktionen
5.5.5. Werte als Referenzen
5.5.6. Export und Import
5.6. Standard-Datenbehälter
5.6.1. Informatoren für Standard-Datenbehälter
5.6.2. Funktionen für Applets
5.6.3. Beans
5.7. Programmierung grafischer Oberflächen
5.8. Anordnung der Fensterkomponenten
5.8.1. Fließende Anordnung
5.8.2. Rundum-Anordnung
5.8.3. Gitteranordnung
5.8.4. Kombination von Anordnungen
6. Ereignissteuerung
6.1. Menüs zur Programmsteuerung
6.1.1. Das leere Menü
6.1.2. Anonyme Objekte
6.1.3. Menügesteuerte Programme
6.2. Rückruf
6.2.1. Prozedurparameter
6.2.2. Überschreiben leerer Methoden
6.2.3. Mehrere Menüversionen
6.2.4. Geschachtelte Klassen
6.2.5. Anonyme Klassen
6.2.6. Mehrere Menüpunkte
6.2.7. Aufgeschobene Methoden
6.2.8. Mehrere aufgeschobene Methoden
6.3. Werkzeuge für Anwenderkommunikation
6.3.1. Menügeneratoren
6.3.2. Direktmenüs
6.3.3. Auswahllisten
6.3.4. Eingabemasken
6.4. Objektwahl
6.4.1. Aktion nach Vorwahl
6.4.2. Referenzen als Gedächtnis
6.4.3. Polymorphe Objektwahl
6.5. Ereignissteuerung durch Standardklassen
6.5.1. Ereignisbehandlung durch Lauscher
6.5.2. Fensterlauscher
6.5.3. Komponentenlauscher
6.5.4. Verteilung der Ereignisse
6.5.5. Standardmenüs
6.5.6. Menüsteuerung
6.5.7. Ereignisse aus unterschiedlichen Quellen
7. Einfache Klassen und Basistypen
7.1. Aufzählungsklassen
7.1.1. Aufzählungsmethoden
7.1.2. Importierte Aufzählungsklassen
7.1.3. Definition von Aufzählungsklassen
7.1.4. Implementierungslogik
7.2. Logische Objekte
7.2.1. Logische Klassen
7.2.2. Logische Literale
7.2.3. Der Basistyp boolean
7.3. Basistypen
7.3.1. Der Basistyp char
7.3.2. Ganzzahltypen
7.3.3. Bruchtypen
7.3.4. Typbindung von Variablen
7.3.5. Konvertierung
7.3.6. Basistypen und Klassen
7.4. Operatoren
7.4.1. Gleichheitsoperatoren
7.4.2. Ordnungsoperatoren
7.4.3. Logische Operatoren
7.4.4. Arithmetische Operatoren
7.5. Verwendung von Basistypen in Klassen
7.5.1. Informatoren mit Basistyp-Ergebnis
7.5.2. Gleichheitsoperationen
7.5.3. Ordnungsoperationen
7.5.4. Variablen als Datenkomponenten
7.5.5. Ganzzahlkomponenten
7.6. Hüllenklassen
7.6.1. Standard-Hüllenklassen
7.6.2. Hüllenklassen im Lehrbuch-Paket
7.6.3. Typsicherheit durch Hüllenklassen
7.6.4. Sicheres Rechnen mit Hüllenklassen
7.7. Zeichenkettenklassen
7.8. Ausdrücke
7.8.1. Geschachtelte Aufrufe
7.8.2. Bindungsstärke
7.8.3. Kombination von Operatoren
7.9. Parameterübergabemechanismen
7.10. Zusicherungen
8. Steuerstrukturen
8.1. Alternativen
8.1.1. Verzweigungen
8.1.2. Fallunterscheidungen
8.1.3. Schachtelung von Alternativen
8.1.4. Kombination von Bedingungen
8.1.5. Erkennen einer Ausnahmesituation
8.1.6. Vorbeugende Ausnahmebehandlung
8.2. Zählergesteuerte Wiederholungen
8.2.1. Zählschleifen
8.2.2. Abarbeitung von Zeichenketten
8.2.3. Geschachtelte Schleifen
8.3. Bedingungsgesteuerte Wiederholungen
8.3.1. Endlosschleifen
8.3.2. Rumpfgesteuerte Schleifen
8.3.3. Kopf- und fußgesteuerte Schleifen
8.3.4. Verwendung der Schleifenarten
8.3.5. Gleichwertigkeit von Wiederholungen
8.4. Rekursion
8.4.1. Fakultät
8.4.2. Die Fibonacci-Zahlen
8.4.3. Die Türme von Hanoi
9. Multibehälter
9.1. Mengen
9.1.1. Farbmengen
9.1.2. Erweiterung von Multibehältern
9.1.3. Zeichenmengen
9.1.4. Persistenz
9.1.5. Generische Mengen
9.1.6. Polymorphe Mengen
9.1.7. Diskrete Mengen
9.1.8. Iteratoren
9.2. Säcke
9.3. Folgen
9.3.1. Zeichenfolgen
9.3.2. Listen
9.3.3. Warteschlangen
9.3.4. Verwendung von Multibehältern
9.3.5. Stapel
9.3.6. Positionierbare Listen
9.3.7. Implementierung mit positionierbaren Listen
9.3.8. Sequenzielle Dateien
9.3.9. Dateiverarbeitung
9.3.10. Sortierkanäle
9.4. Assoziativspeicher
9.4.1. Allgemeine Assoziativspeicher
9.4.2. Direkte Dateien
9.5. Standard-Multibehälter
9.5.1. Vererbungshierarchie der Standard-Multibehälter
9.5.2. Benutzung von Standard-Multibehältern
9.5.3. Iteratorobjekte
9.5.4. Weitere Arbeitshilfen
10. Implementierungstechniken für Multibehälter
10.1. Verbunde
10.2. Reihungen
10.2.1. Reihungsobjekte
10.2.2. Reihungsklassen
10.2.3. Aufwärtskompatibilität bei Reihungen
10.2.4. Reihungen als Datenkomponenten
10.2.5. Übersetzungstabellen
10.2.6. Kommandozeilenparameter
10.2.7. Mehrdimensionale Reihungen
10.2.8. Dynamische Reihungen
10.3. Verwendung von Reihungen
10.3.1. Reihungsimplementierung von Multibehältern
10.3.2. Implementierung diskreter Multibehälter
10.3.3. Relevante Gleichheit
10.3.4. Vektoren
10.3.5. Matrizen
10.3.6. Assoziativtabellen
10.4. Verkettete Listen
10.4.1. Rekursiv vereinbarte Klassen
10.4.2. Verkettung
10.4.3. Rückwärts verkettete Listen
10.4.4. Rekursive Abarbeitung einer Liste
10.4.5. Vorwärts verkettete Listen
10.4.6. Doppelt verkettete Listen
10.4.7. Iterative Abarbeitung einer Liste
10.4.8. Binärbäume
10.4.9. Abbruch der Rekursion
10.4.10. Mehrfach verkettete Listen
10.5. Quelltextinformation zur Laufzeit
10.5.1. Methoden finden
10.5.2. Datenkomponenten finden
10.6. Ströme
10.6.1. Byteorientierte Ströme
10.6.2. Zeichenorientierte Ströme
10.6.3. Objekte in Strömen
10.6.4. Standardein- und Ausgabe
10.6.5. Implementierung der Persistenz
11. Nebenläufigkeit
11.1. Prozesse
11.1.1. Disjunkte und voneinander abhängige Prozesse
11.1.2. Kritische Abschnitte und gegenseitiger Ausschluss
11.1.3. Synchronisierung
11.1.4. Semaphore
11.1.5. Nachrichtenaustausch
11.1.6. Monitore
11.2. Nebenläufige Prozesse in Java
11.2.1. Prozesse und Monitore
11.2.2. Synchronisierung auf Grund von Zusatzbedingungen
11.2.3. Unterbrechungen
11.2.4. Weitere Synchronisierungsoperationen
11.3. Java im Internet
11.3.1. Sicherheitskonzepte
11.3.2. Applets
11.3.3. Einbinden entfernter Applets in Netzseiten
11.3.4. Adressieren entfernter Objekte
11.3.5. Laden entfernter Textobjekte
11.3.6. Laden entfernter Klassenobjekte
11.3.7. Fernaufruf von Methoden
12. Ausblick
13. Anhang
13.1. Literatur
13.2. Hierarchie der Algorithmen
13.3. Die Struktur der Sprachelemente
13.4. Programmverzeichnis
13.5. Standardklassen
Glossar
Sachwortverzeichnis