15 Jahre Erfahrung FreeCall 0800 tutegos

›Java ist auch eine Insel‹ 10. Auflage

 

Vorwort

[]Über dieses Buch

Die Zielgruppe
Mein Leben und Java, oder warum es noch ein Java-Buch gibt
Software und Versionen
Das Buch in der Lehre einsetzen
Organisation der Kapitel
Konventionen
Online-Informationen und -Aufgaben
Weiterbildung durch tutego
Danksagungen
Feedback

Vorwort zur 10. Auflage

Vorwort zur 9. Auflage


1 Java ist auch eine Sprache

1.1 Historischer Hintergrund

1.2 Warum Java gut ist: die zentralen Eigenschaften

1.2.1 Bytecode
1.2.2 Ausführung des Bytecodes durch eine virtuelle Maschine
1.2.3 Plattformunabhängigkeit
1.2.4 Java als Sprache, Laufzeitumgebung und Standardbibliothek
1.2.5 Objektorientierung in Java
1.2.6 Java ist verbreitet und bekannt
1.2.7 Java ist schnell: Optimierung und Just-in-Time Compilation
1.2.8 Das Java-Security-Modell
1.2.9 Zeiger und Referenzen
1.2.10 Bring den Müll raus, Garbage-Collector!
1.2.11 Ausnahmebehandlung
1.2.12 Einfache Syntax der Programmiersprache Java
1.2.13 Java ist Open Source
1.2.14 Wofür sich Java weniger eignet
1.2.15 Java im Vergleich zu anderen Sprachen
1.2.16 Java und das Web, Applets und JavaFX
1.2.17 Features, Enhancements (Erweiterungen) und ein JSR
1.2.18 Die Entwicklung von Java und seine Zukunftsaussichten

1.3 Java-Plattformen: Java SE, Java EE und Java ME

1.3.1 Die Java SE-Plattform
1.3.2 Java für die Kleinen
1.3.3 Java für die ganz, ganz Kleinen
1.3.4 Java für die Großen
1.3.5 Echtzeit-Java (Real-time Java)

1.4 Die Installation der Java Platform Standard Edition (Java SE)

1.4.1 Die Java SE von Oracle
1.4.2 Download des JDK
1.4.3 Java SE unter Windows installieren

1.5 Das erste Programm compilieren und testen

1.5.1 Ein Quadratzahlen-Programm
1.5.2 Der Compilerlauf
1.5.3 Die Laufzeitumgebung
1.5.4 Häufige Compiler- und Interpreterprobleme

1.6 Entwicklungsumgebungen im Allgemeinen

1.6.1 Die Entwicklungsumgebung Eclipse
1.6.2 NetBeans von Oracle
1.6.3 IntelliJ IDEA
1.6.4 Ein Wort zu Microsoft, Java und zu J++, J#

1.7 Eclipse im Speziellen

1.7.1 Eclipse starten
1.7.2 Das erste Projekt anlegen
1.7.3 Eine Klasse hinzufügen
1.7.4 Übersetzen und ausführen
1.7.5 JDK statt JRE *
1.7.6 Start eines Programms ohne Speicheraufforderung
1.7.7 Projekt einfügen, Workspace für die Programme wechseln
1.7.8 Plugins für Eclipse

1.8 NetBeans im Speziellen

1.8.1 NetBeans-Bundles
1.8.2 NetBeans installieren
1.8.3 NetBeans starten
1.8.4 Ein neues NetBeans-Projekt anlegen
1.8.5 Ein Java-Programm starten
1.8.6 Einstellungen

1.9 Zum Weiterlesen


2 Imperative Sprachkonzepte

2.1 Elemente der Programmiersprache Java

2.1.1 Token
2.1.2 Textkodierung durch Unicode-Zeichen
2.1.3 Bezeichner
2.1.4 Literale
2.1.5 Reservierte Schlüsselwörter
2.1.6 Zusammenfassung der lexikalischen Analyse
2.1.7 Kommentare

2.2 Von der Klasse zur Anweisung

2.2.1 Was sind Anweisungen?
2.2.2 Klassendeklaration
2.2.3 Die Reise beginnt am main()
2.2.4 Der erste Methodenaufruf: println()
2.2.5 Atomare Anweisungen und Anweisungssequenzen
2.2.6 Mehr zu print(), println() und printf() für Bildschirmausgaben
2.2.7 Die API-Dokumentation
2.2.8 Ausdrücke
2.2.9 Ausdrucksanweisung
2.2.10 Erste Idee der Objektorientierung
2.2.11 Modifizierer
2.2.12 Gruppieren von Anweisungen mit Blöcken

2.3 Datentypen, Typisierung, Variablen und Zuweisungen

2.3.1 Primitive Datentypen im Überblick
2.3.2 Variablendeklarationen
2.3.3 Konsoleneingaben
2.3.4 Fließkommazahlen mit den Datentypen float und double
2.3.5 Ganzzahlige Datentypen
2.3.6 Wahrheitswerte
2.3.7 Unterstriche in Zahlen *
2.3.8 Alphanumerische Zeichen
2.3.9 Gute Namen, schlechte Namen
2.3.10 Initialisierung von lokalen Variablen

2.4 Ausdrücke, Operanden und Operatoren

2.4.1 Zuweisungsoperator
2.4.2 Arithmetische Operatoren
2.4.3 Unäres Minus und Plus
2.4.4 Zuweisung mit Operation
2.4.5 Präfix- oder Postfix-Inkrement und -Dekrement
2.4.6 Die relationalen Operatoren und die Gleichheitsoperatoren
2.4.7 Logische Operatoren: Nicht, Und, Oder, Xor
2.4.8 Kurzschluss-Operatoren
2.4.9 Der Rang der Operatoren in der Auswertungsreihenfolge
2.4.10 Die Typanpassung (das Casting)
2.4.11 Überladenes Plus für Strings
2.4.12 Operator vermisst *

2.5 Bedingte Anweisungen oder Fallunterscheidungen

2.5.1 Die if-Anweisung
2.5.2 Die Alternative mit einer if-else-Anweisung wählen
2.5.3 Der Bedingungsoperator
2.5.4 Die switch-Anweisung bietet die Alternative

2.6 Schleifen

2.6.1 Die while-Schleife
2.6.2 Die do-while-Schleife
2.6.3 Die for-Schleife
2.6.4 Schleifenbedingungen und Vergleiche mit ==
2.6.5 Ausbruch planen mit break und Wiedereinstieg mit continue
2.6.6 break und continue mit Marken *

2.7 Methoden einer Klasse

2.7.1 Bestandteil einer Methode
2.7.2 Signatur-Beschreibung in der Java-API
2.7.3 Aufruf einer Methode
2.7.4 Methoden ohne Parameter deklarieren
2.7.5 Statische Methoden (Klassenmethoden)
2.7.6 Parameter, Argument und Wertübergabe
2.7.7 Methoden vorzeitig mit return beenden
2.7.8 Nicht erreichbarer Quellcode bei Methoden *
2.7.9 Methoden mit Rückgaben
2.7.10 Methoden überladen
2.7.11 Sichtbarkeit und Gültigkeitsbereich
2.7.12 Vorgegebener Wert für nicht aufgeführte Argumente *
2.7.13 Finale lokale Variablen
2.7.14 Rekursive Methoden *
2.7.15 Die Türme von Hanoi *

2.8 Zum Weiterlesen


3 Klassen und Objekte

3.1 Objektorientierte Programmierung (OOP)

3.1.1 Warum überhaupt OOP?
3.1.2 Denk ich an Java, denk ich an Wiederverwendbarkeit

3.2 Eigenschaften einer Klasse

3.2.1 Die Klasse Point

3.3 Die UML (Unified Modeling Language) *

3.3.1 Hintergrund und Geschichte der UML
3.3.2 Wichtige Diagrammtypen der UML
3.3.3 UML-Werkzeuge

3.4 Neue Objekte erzeugen

3.4.1 Ein Exemplar einer Klasse mit dem new-Operator anlegen
3.4.2 Garbage-Collector (GC) – Es ist dann mal weg
3.4.3 Deklarieren von Referenzvariablen
3.4.4 Zugriff auf Objektattribute und -methoden mit dem ».«
3.4.5 Überblick über Point-Methoden
3.4.6 Konstruktoren nutzen

3.5 ZZZZZnake

3.6 Kompilationseinheiten, Imports und Pakete schnüren

3.6.1 Volle Qualifizierung und import-Deklaration
3.6.2 Mit import p1.p2.* alle Typen eines Pakets erreichen
3.6.3 Hierarchische Strukturen über Pakete
3.6.4 Die package-Deklaration
3.6.5 Unbenanntes Paket (default package)
3.6.6 Klassen mit gleichen Namen in unterschiedlichen Paketen *
3.6.7 Compilationseinheit (Compilation Unit)
3.6.8 Statischer Import *
3.6.9 Eine Verzeichnisstruktur für eigene Projekte *

3.7 Mit Referenzen arbeiten, Identität und Gleichheit

3.7.1 Die null-Referenz
3.7.2 null-Referenzen testen
3.7.3 Zuweisungen bei Referenzen
3.7.4 Methoden mit nicht-primitiven Parametern
3.7.5 Identität von Objekten
3.7.6 Gleichheit und die Methode equals()

3.8 Arrays

3.8.1 Grundbestandteile
3.8.2 Deklaration von Arrays
3.8.3 Arrays mit Inhalt
3.8.4 Die Länge eines Arrays über das Attribut length auslesen
3.8.5 Zugriff auf die Elemente über den Index
3.8.6 Array-Objekte mit new erzeugen
3.8.7 Typische Feldfehler
3.8.8 Feld-Objekte als Parametertyp
3.8.9 Vorinitialisierte Arrays
3.8.10 Die erweiterte for-Schleife
3.8.11 Arrays mit nicht-primitiven Elementen
3.8.12 Mehrdimensionale Arrays *
3.8.13 Nichtrechteckige Arrays *
3.8.14 Die Wahrheit über die Array-Initialisierung *
3.8.15 Mehrere Rückgabewerte *
3.8.16 Methode mit variabler Argumentanzahl (Vararg)
3.8.17 Klonen kann sich lohnen – Arrays vermehren *
3.8.18 Feldinhalte kopieren *
3.8.19 Die Klasse Arrays zum Vergleichen, Füllen, Suchen, Sortieren nutzen
3.8.20 Eine lange Schlange

3.9 Der Einstiegspunkt für das Laufzeitsystem: main()

3.9.1 Korrekte Deklaration der Startmethode
3.9.2 Kommandozeilenargumente verarbeiten
3.9.3 Der Rückgabetyp von main() und System.exit() *

3.10 Annotationen und Generics

3.10.1 Generics
3.10.2 Annotationen
3.10.3 Eigene Metadaten setzen
3.10.4 Annotationstypen @Override, @Deprecated, @SuppressWarnings

3.11 Zum Weiterlesen


4 Der Umgang mit Zeichenketten

4.1 Von ASCII über ISO-8859-1 zu Unicode

4.1.1 ASCII
4.1.2 ISO/IEC 8859-1
4.1.3 Unicode
4.1.4 Unicode-Zeichenkodierung
4.1.5 Escape-Sequenzen/Fluchtsymbole
4.1.6 Schreibweise für Unicode-Zeichen und Unicode-Escapes
4.1.7 Unicode 4.0 und Java *

4.2 Die Character-Klasse

4.2.1 Ist das so?
4.2.2 Zeichen in Großbuchstaben/Kleinbuchstaben konvertieren
4.2.3 Ziffern einer Basis *

4.3 Zeichenfolgen

4.4 Die Klasse String und ihre Methoden

4.4.1 String-Literale als String-Objekte für konstante Zeichenketten
4.4.2 Konkatenation mit +
4.4.3 String-Länge und Test auf Leerstring
4.4.4 Zugriff auf ein bestimmtes Zeichen mit charAt( )
4.4.5 Nach enthaltenen Zeichen und Zeichenfolgen suchen
4.4.6 Das Hangman-Spiel
4.4.7 Gut, dass wir verglichen haben
4.4.8 Phonetische Vergleiche *
4.4.9 String-Teile extrahieren
4.4.10 Strings anhängen, Groß-/Kleinschreibung und Leerraum
4.4.11 Suchen und ersetzen
4.4.12 String-Objekte mit Konstruktoren neu anlegen *

4.5 Konvertieren zwischen Primitiven und Strings

4.5.1 Unterschiedliche Typen in String-Repräsentationen konvertieren
4.5.2 Stringinhalt in einen primitiven Wert konvertieren
4.5.3 String-Repräsentation im Format Binär, Hex, Oktal *

4.6 Veränderbare Zeichenketten mit StringBuilder und StringBuffer

4.6.1 Anlegen von StringBuilder/StringBuffer-Objekten
4.6.2 StringBuilder/StringBuffer in andere Zeichenkettenformate konvertieren
4.6.3 Zeichen(folgen) erfragen
4.6.4 Daten anhängen
4.6.5 Zeichen(folgen) setzen, löschen und umdrehen
4.6.6 Länge und Kapazität eines StringBuilder/StringBuffer-Objekts *
4.6.7 Vergleichen von String mit StringBuilder und StringBuffer
4.6.8 hashCode() bei StringBuilder/StringBuffer *

4.7 CharSequence als Basistyp *

4.8 Reguläre Ausdrücke

4.8.1 Pattern.matches() bzw. String#matches()
4.8.2 Die Klassen Pattern und Matcher
4.8.3 Finden und nicht matchen
4.8.4 Gierige und nicht gierige Operatoren *
4.8.5 Mit MatchResult alle Ergebnisse einsammeln *
4.8.6 Suchen und Ersetzen mit Mustern
4.8.7 Hangman Version 2

4.9 Zerlegen von Zeichenketten

4.9.1 Splitten von Zeichenketten mit split()
4.9.2 Die Klasse Scanner
4.9.3 Die Klasse StringTokenizer *
4.9.4 BreakIterator als Zeichen-, Wort-, Zeilen- und Satztrenner *

4.10 Zeichenkodierungen, XML/HTML-Entitys, Base64 *

4.10.1 Unicode und 8-Bit-Abbildungen
4.10.2 Das Paket java.nio.charset und der Typ Charset
4.10.3 Konvertieren mit OutputStreamWriter/InputStreamReader-Klassen *
4.10.4 XML/HTML-Entitys ausmaskieren
4.10.5 Base64-Kodierung

4.11 Ausgaben formatieren

4.11.1 Formatieren und Ausgeben mit format()
4.11.2 Die Formatter-Klasse *
4.11.3 Formatieren mit Masken *
4.11.4 Format-Klassen
4.11.5 Zahlen, Prozente und Währungen mit NumberFormat und DecimalFormat formatieren *
4.11.6 MessageFormat und Pluralbildung mit ChoiceFormat

4.12 Sprachabhängiges Vergleichen und Normalisierung *

4.12.1 Die Klasse Collator
4.12.2 Effiziente interne Speicherung für die Sortierung
4.12.3 Normalisierung

4.13 Zum Weiterlesen


5 Eigene Klassen schreiben

5.1 Eigene Klassen mit Eigenschaften deklarieren

5.1.1 Attribute deklarieren
5.1.2 Methoden deklarieren
5.1.3 Die this-Referenz

5.2 Privatsphäre und Sichtbarkeit

5.2.1 Für die Öffentlichkeit: public
5.2.2 Kein Public Viewing – Passwörter sind privat
5.2.3 Wieso nicht freie Methoden und Variablen für alle?
5.2.4 Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht *
5.2.5 Zugriffsmethoden für Attribute deklarieren
5.2.6 Setter und Getter nach der JavaBeans-Spezifikation
5.2.7 Paketsichtbar
5.2.8 Zusammenfassung zur Sichtbarkeit

5.3 Statische Methoden und statische Attribute

5.3.1 Warum statische Eigenschaften sinnvoll sind
5.3.2 Statische Eigenschaften mit static
5.3.3 Statische Eigenschaften über Referenzen nutzen? *
5.3.4 Warum die Groß- und Kleinschreibung wichtig ist *
5.3.5 Statische Variablen zum Datenaustausch *
5.3.6 Statische Eigenschaften und Objekteigenschaften *

5.4 Konstanten und Aufzählungen

5.4.1 Konstanten über öffentliche statische finale Variablen
5.4.2 Typ(un)sichere Aufzählungen *
5.4.3 Aufzählungen mit enum

5.5 Objekte anlegen und zerstören

5.5.1 Konstruktoren schreiben
5.5.2 Der vorgegebene Konstruktor (default constructor)
5.5.3 Parametrisierte und überladene Konstruktoren
5.5.4 Copy-Konstruktor
5.5.5 Einen anderen Konstruktor der gleichen Klasse mit this() aufrufen
5.5.6 Ihr fehlt uns nicht – der Garbage-Collector
5.5.7 Private Konstruktoren, Utility-Klassen, Singleton, Fabriken

5.6 Klassen- und Objektinitialisierung *

5.6.1 Initialisierung von Objektvariablen
5.6.2 Statische Blöcke als Klasseninitialisierer
5.6.3 Initialisierung von Klassenvariablen
5.6.4 Eincompilierte Belegungen der Klassenvariablen
5.6.5 Exemplarinitialisierer (Instanzinitialisierer)
5.6.6 Finale Werte im Konstruktor und in statischen Blöcken setzen

5.7 Assoziationen zwischen Objekten

5.7.1 Unidirektionale 1:1-Beziehung
5.7.2 Bidirektionale 1:1-Beziehungen
5.7.3 Unidirektionale 1:n-Beziehung

5.8 Vererbung

5.8.1 Vererbung in Java
5.8.2 Spielobjekte modellieren
5.8.3 Die implizite Basisklasse java.lang.Object
5.8.4 Einfach- und Mehrfachvererbung *
5.8.5 Die Sichtbarkeit protected
5.8.6 Konstruktoren in der Vererbung und super()

5.9 Typen in Hierarchien

5.9.1 Automatische und explizite Typanpassung
5.9.2 Das Substitutionsprinzip
5.9.3 Typen mit dem instanceof-Operator testen

5.10 Methoden überschreiben

5.10.1 Methoden in Unterklassen mit neuem Verhalten ausstatten
5.10.2 Mit super an die Eltern
5.10.3 Finale Klassen und finale Methoden
5.10.4 Kovariante Rückgabetypen
5.10.5 Array-Typen und Kovarianz *

5.11 Drum prüfe, wer sich ewig dynamisch bindet

5.11.1 Gebunden an toString()
5.11.2 Implementierung von System.out.println(Object)
5.11.3 Nicht dynamisch gebunden bei privaten, statischen und finalen Methoden
5.11.4 Dynamisch gebunden auch bei Konstruktoraufrufen *
5.11.5 Eine letzte Spielerei mit Javas dynamischer Bindung und überschatteten Attributen *

5.12 Abstrakte Klassen und abstrakte Methoden

5.12.1 Abstrakte Klassen
5.12.2 Abstrakte Methoden

5.13 Schnittstellen

5.13.1 Schnittstellen deklarieren
5.13.2 Implementieren von Schnittstellen
5.13.3 Markierungsschnittstellen *
5.13.4 Ein Polymorphie-Beispiel mit Schnittstellen
5.13.5 Die Mehrfachvererbung bei Schnittstellen *
5.13.6 Keine Kollisionsgefahr bei Mehrfachvererbung *
5.13.7 Erweitern von Interfaces – Subinterfaces
5.13.8 Konstantendeklarationen bei Schnittstellen
5.13.9 Initialisierung von Schnittstellenkonstanten *
5.13.10 Abstrakte Klassen und Schnittstellen im Vergleich

5.14 Zum Weiterlesen


6 Exceptions

6.1 Problembereiche einzäunen

6.1.1 Exceptions in Java mit try und catch
6.1.2 Eine NumberFormatException auffangen
6.1.3 Ablauf einer Ausnahmesituation
6.1.4 Eigenschaften vom Exception-Objekt
6.1.5 Wiederholung abgebrochener Bereiche *
6.1.6 Mehrere Ausnahmen auffangen
6.1.7 throws im Methodenkopf angeben
6.1.8 Abschlussbehandlung mit finally

6.2 RuntimeException muss nicht aufgefangen werden

6.2.1 Beispiele für RuntimeException-Klassen
6.2.2 Kann man abfangen, muss man aber nicht

6.3 Die Klassenhierarchie der Fehler

6.3.1 Die Exception-Hierarchie
6.3.2 Oberausnahmen auffangen
6.3.3 Schon gefangen?
6.3.4 Alles geht als Exception durch
6.3.5 Zusammenfassen gleicher catch-Blöcke mit dem multi-catch

6.4 Harte Fehler: Error *

6.5 Auslösen eigener Exceptions

6.5.1 Mit throw Ausnahmen auslösen
6.5.2 Vorhandene Runtime-Fehlertypen kennen und nutzen
6.5.3 Parameter testen und gute Fehlermeldungen
6.5.4 Neue Exception-Klassen deklarieren
6.5.5 Eigene Ausnahmen als Unterklassen von Exception oder RuntimeException?
6.5.6 Ausnahmen abfangen und weiterleiten *
6.5.7 Aufrufstack von Ausnahmen verändern *
6.5.8 Präzises rethrow *
6.5.9 Geschachtelte Ausnahmen *

6.6 Automatisches Ressourcen-Management (try mit Ressourcen)

6.6.1 try mit Ressourcen
6.6.2 Ausnahmen vom close() bleiben bestehen
6.6.3 Die Schnittstelle AutoCloseable
6.6.4 Mehrere Ressourcen nutzen
6.6.5 Unterdrückte Ausnahmen *

6.7 Besonderheiten bei der Ausnahmebehandlung *

6.7.1 Rückgabewerte bei ausgelösten Ausnahmen
6.7.2 Ausnahmen und Rückgaben verschwinden: Das Duo »return« und »finally«
6.7.3 throws bei überschriebenen Methoden
6.7.4 Nicht erreichbare catch-Klauseln

6.8 Den Stack-Trace erfragen *

6.8.1 StackTraceElement
6.8.2 printStackTrace()
6.8.3 StackTraceElement vom Thread erfragen

6.9 Assertions *

6.9.1 Assertions in eigenen Programmen nutzen
6.9.2 Assertions aktivieren

6.10 Zum Weiterlesen


7 Äußere.innere Klassen

7.1 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen

7.2 Statische innere Klassen und Schnittstellen

7.3 Mitglieds- oder Elementklassen

7.3.1 Exemplare innerer Klassen erzeugen
7.3.2 Die this-Referenz
7.3.3 Vom Compiler generierte Klassendateien *
7.3.4 Erlaubte Modifizierer bei äußeren und inneren Klassen
7.3.5 Innere Klassen greifen auf private Eigenschaften zu

7.4 Lokale Klassen

7.5 Anonyme innere Klassen

7.5.1 Umsetzung innerer anonymer Klassen *
7.5.2 Nutzung innerer Klassen für Threads *
7.5.3 Konstruktoren innerer anonymer Klassen *

7.6 Zugriff auf lokale Variablen aus lokalen inneren und anonymen Klassen *

7.7 this in Unterklassen *


8 Besondere Klassen der Java SE

8.1 Vergleichen von Objekten

8.1.1 Natürlich geordnet oder nicht?
8.1.2 Die Schnittstelle Comparable
8.1.3 Die Schnittstelle Comparator
8.1.4 Rückgabewerte kodieren die Ordnung
8.1.5 Aneinanderreihung von Comparatoren *

8.2 Wrapper-Klassen und Autoboxing

8.2.1 Wrapper-Objekte erzeugen
8.2.2 Konvertierungen in eine String-Repräsentation
8.2.3 Die Basisklasse Number für numerische Wrapper-Objekte
8.2.4 Vergleiche durchführen mit compare(), compareTo(), equals()
8.2.5 Die Klasse Integer
8.2.6 Die Klassen Double und Float für Fließkommazahlen
8.2.7 Die Long-Klasse
8.2.8 Die Boolean-Klasse
8.2.9 Autoboxing: Boxing und Unboxing

8.3 Object ist die Mutter aller Klassen

8.3.1 Klassenobjekte
8.3.2 Objektidentifikation mit toString()
8.3.3 Objektgleichheit mit equals() und Identität
8.3.4 Klonen eines Objekts mit clone() *
8.3.5 Hashcodes über hashCode() liefern *
8.3.6 System.identityHashCode() und das Problem der nicht-eindeutigen Objektverweise *
8.3.7 Aufräumen mit finalize() *
8.3.8 Synchronisation *

8.4 Die Utility-Klasse java.util.Objects

8.5 Die Spezial-Oberklasse Enum

8.5.1 Methoden auf Enum-Objekten
8.5.2 enum mit eigenen Konstruktoren und Methoden *

8.6 Erweitertes for und Iterable

8.6.1 Die Schnittstelle Iterable
8.6.2 Einen eigenen Iterable implementieren *

8.7 Zum Weiterlesen


9 Generics<T>

9.1 Einführung in Java Generics

9.1.1 Mensch versus Maschine: Typprüfung des Compilers und der Laufzeitumgebung
9.1.2 Taschen
9.1.3 Generische Typen deklarieren
9.1.4 Generics nutzen
9.1.5 Diamonds are forever
9.1.6 Generische Schnittstellen
9.1.7 Generische Methoden/Konstruktoren und Typ-Inferenz

9.2 Umsetzen der Generics, Typlöschung und Raw-Types

9.2.1 Realisierungsmöglichkeiten
9.2.2 Typlöschung (Type Erasure)
9.2.3 Probleme aus der Typlöschung
9.2.4 Raw-Type

9.3 Einschränken der Typen über Bounds

9.3.1 Einfache Einschränkungen mit extends
9.3.2 Weitere Obertypen mit &

9.4 Typparameter in der throws-Klausel *

9.4.1 Deklaration einer Klasse mit Typvariable <E extends Exception>
9.4.2 Parametrisierter Typ bei Typvariable <E extends Exception>

9.5 Generics und Vererbung, Invarianz

9.5.1 Arrays sind invariant
9.5.2 Generics sind kovariant
9.5.3 Wildcards mit ?
9.5.4 Bounded Wildcards
9.5.5 Bounded-Wildcard-Typen und Bounded-Typvariablen
9.5.6 Das LESS-Prinzip
9.5.7 Enum<E extends Enum<E>> *

9.6 Konsequenzen der Typlöschung: Typ-Token, Arrays und Brücken *

9.6.1 Typ-Token
9.6.2 Super-Type-Token
9.6.3 Generics und Arrays
9.6.4 Brückenmethoden

10 Architektur, Design und angewandte Objektorientierung

10.1 Architektur, Design und Implementierung

10.2 Design-Pattern (Entwurfsmuster)

10.2.1 Motivation für Design-Pattern
10.2.2 Das Beobachter-Pattern (Observer/Observable)
10.2.3 Ereignisse über Listener

10.3 JavaBean

10.3.1 Properties (Eigenschaften)
10.3.2 Einfache Eigenschaften
10.3.3 Indizierte Eigenschaften
10.3.4 Gebundene Eigenschaften und PropertyChangeListener
10.3.5 Veto-Eigenschaften – dagegen!

10.4 Zum Weiterlesen


11 Die Klassenbibliothek

11.1 Die Java-Klassenphilosophie

11.1.1 Übersicht über die Pakete der Standardbibliothek

11.2 Sprachen der Länder

11.2.1 Sprachen und Regionen über Locale-Objekte

11.3 Die Klasse Date

11.3.1 Objekte erzeugen und Methoden nutzen
11.3.2 Date-Objekte sind nicht immutable

11.4 Calendar und GregorianCalendar

11.4.1 Die abstrakte Klasse Calendar
11.4.2 Der gregorianische Kalender
11.4.3 Calendar nach Date und Millisekunden fragen
11.4.4 Abfragen und Setzen von Datumselementen über Feldbezeichner

11.5 Klassenlader (Class Loader)

11.5.1 Woher die kleinen Klassen kommen
11.5.2 Setzen des Klassenpfades
11.5.3 Die wichtigsten drei Typen von Klassenladern
11.5.4 Die Klasse java.lang.ClassLoader *
11.5.5 Hot Deployment mit dem URL-Classloader *
11.5.6 Das Verzeichnis jre/lib/endorsed *

11.6 Die Utility-Klasse System und Properties

11.6.1 Systemeigenschaften der Java-Umgebung
11.6.2 line.separator
11.6.3 Eigene Properties von der Konsole aus setzen *
11.6.4 Umgebungsvariablen des Betriebssystems *
11.6.5 Einfache Zeitmessung und Profiling *

11.7 Einfache Benutzereingaben

11.7.1 Grafischer Eingabedialog über JOptionPane
11.7.2 Geschützte Passwort-Eingaben mit der Klasse Console *

11.8 Ausführen externer Programme *

11.8.1 ProcessBuilder und Prozesskontrolle mit Process
11.8.2 Einen Browser, E-Mail-Client oder Editor aufrufen

11.9 Benutzereinstellungen *

11.9.1 Benutzereinstellungen mit der Preferences-API
11.9.2 Einträge einfügen, auslesen und löschen
11.9.3 Auslesen der Daten und Schreiben in einem anderen Format
11.9.4 Auf Ereignisse horchen
11.9.5 Zugriff auf die gesamte Windows-Registry

11.10 Zum Weiterlesen


12 Einführung in die nebenläufige Programmierung

12.1 Nebenläufigkeit

12.1.1 Threads und Prozesse
12.1.2 Wie parallele Programme die Geschwindigkeit steigern können
12.1.3 Was Java für Nebenläufigkeit alles bietet

12.2 Threads erzeugen

12.2.1 Threads über die Schnittstelle Runnable implementieren
12.2.2 Thread mit Runnable starten
12.2.3 Die Klasse Thread erweitern

12.3 Thread-Eigenschaften und -Zustände

12.3.1 Der Name eines Threads
12.3.2 Wer bin ich?
12.3.3 Schläfer gesucht
12.3.4 Mit yield() auf Rechenzeit verzichten
12.3.5 Der Thread als Dämon
12.3.6 Das Ende eines Threads
12.3.7 Einen Thread höflich mit Interrupt beenden
12.3.8 UncaughtExceptionHandler für unbehandelte Ausnahmen

12.4 Der Ausführer (Executor) kommt

12.4.1 Die Schnittstelle Executor
12.4.2 Die Thread-Pools

12.5 Synchronisation über kritische Abschnitte

12.5.1 Gemeinsam genutzte Daten
12.5.2 Probleme beim gemeinsamen Zugriff und kritische Abschnitte
12.5.3 Punkte parallel initialisieren
12.5.4 Kritische Abschnitte schützen
12.5.5 Kritische Abschnitte mit ReentrantLock schützen

12.6 Zum Weiterlesen


13 Einführung in Datenstrukturen und Algorithmen

13.1 Datenstrukturen und die Collection-API

13.1.1 Designprinzip mit Schnittstellen, abstrakten und konkreten Klassen
13.1.2 Die Basis-Schnittstellen Collection und Map
13.1.3 Die Utility-Klassen Collections und Arrays
13.1.4 Das erste Programm mit Container-Klassen
13.1.5 Die Schnittstelle Collection und Kernkonzepte
13.1.6 Schnittstellen, die Collection erweitern und Map
13.1.7 Konkrete Container-Klassen
13.1.8 Generische Datentypen in der Collection-API
13.1.9 Die Schnittstelle Iterable und das erweiterte for

13.2 Listen

13.2.1 Erstes Listen-Beispiel

13.3 Mengen (Sets)

13.3.1 Ein erstes Mengen-Beispiel
13.3.2 Methoden der Schnittstelle Set

13.4 Assoziative Speicher

13.4.1 Die Klassen HashMap und TreeMap
13.4.2 Einfügen und Abfragen der Datenstruktur
13.4.3 Über die Bedeutung von equals() und hashCode()

13.5 Mit einem Iterator durch die Daten wandern

13.5.1 Die Schnittstelle Iterator
13.5.2 Der Iterator kann (eventuell auch) löschen

13.6 Algorithmen in Collections

13.6.1 Die Bedeutung von Ordnung mit Comparator und Comparable
13.6.2 Sortieren
13.6.3 Den größten und kleinsten Wert einer Collection finden

13.7 Zum Weiterlesen


14 Einführung in grafische Oberflächen

14.1 Das Abstract Window Toolkit und Swing

14.1.1 SwingSet-Demos
14.1.2 Abstract Window Toolkit (AWT)
14.1.3 Java Foundation Classes
14.1.4 Was Swing von AWT unterscheidet
14.1.5 GUI-Builder für AWT und Swing

14.2 Mit NetBeans zur ersten Oberfläche

14.2.1 Projekt anlegen
14.2.2 Eine GUI-Klasse hinzufügen
14.2.3 Programm starten
14.2.4 Grafische Oberfläche aufbauen
14.2.5 Swing-Komponenten-Klassen
14.2.6 Funktionalität geben

14.3 Fenster zur Welt

14.3.1 Swing-Fenster mit javax.swing.JFrame darstellen
14.3.2 Fenster schließbar machen – setDefaultCloseOperation()
14.3.3 Sichtbarkeit des Fensters

14.4 Beschriftungen (JLabel)

14.5 Es tut sich was – Ereignisse beim AWT

14.5.1 Die Ereignisquellen und Horcher (Listener) von Swing
14.5.2 Listener implementieren
14.5.3 Listener bei dem Ereignisauslöser anmelden/abmelden
14.5.4 Adapterklassen nutzen
14.5.5 Innere Mitgliedsklassen und innere anonyme Klassen
14.5.6 Aufrufen der Listener im AWT-Event-Thread

14.6 Schaltflächen

14.6.1 Normale Schaltflächen (JButton)
14.6.2 Der aufmerksame ActionListener

14.7 Alles Auslegungssache: die Layoutmanager

14.7.1 Übersicht über Layoutmanager
14.7.2 Zuweisen eines Layoutmanagers
14.7.3 Im Fluss mit FlowLayout
14.7.4 BoxLayout
14.7.5 Mit BorderLayout in alle Himmelsrichtungen
14.7.6 Rasteranordnung mit GridLayout

14.8 Textkomponenten

14.8.1 Text in einer Eingabezeile
14.8.2 Die Oberklasse der Text-Komponenten (JTextComponent)

14.9 Zeichnen von grafischen Primitiven

14.9.1 Die paint()-Methode für das AWT-Frame
14.9.2 Die ereignisorientierte Programmierung ändert Fensterinhalte
14.9.3 Zeichnen von Inhalten auf ein JFrame
14.9.4 Linien
14.9.5 Rechtecke
14.9.6 Zeichenfolgen schreiben
14.9.7 Die Font-Klasse
14.9.8 Farben mit der Klasse Color

14.10 Zum Weiterlesen


15 Einführung in Dateien und Datenströme

15.1 Datei und Verzeichnis

15.1.1 Dateien und Verzeichnisse mit der Klasse File
15.1.2 Verzeichnis oder Datei? Existiert es?
15.1.3 Verzeichnis- und Dateieigenschaften/-attribute
15.1.4 Umbenennen und Verzeichnisse anlegen
15.1.5 Verzeichnisse auflisten und Dateien filtern
15.1.6 Dateien und Verzeichnisse löschen

15.2 Dateien mit wahlfreiem Zugriff

15.2.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen
15.2.2 Aus dem RandomAccessFile lesen
15.2.3 Schreiben mit RandomAccessFile
15.2.4 Die Länge des RandomAccessFile
15.2.5 Hin und her in der Datei

15.3 Dateisysteme unter NIO.2

15.3.1 FileSystem und Path
15.3.2 Die Utility-Klasse Files

15.4 Stream-Klassen und Reader/Writer am Beispiel von Dateien

15.4.1 Mit dem FileWriter Texte in Dateien schreiben
15.4.2 Zeichen mit der Klasse FileReader lesen
15.4.3 Kopieren mit FileOutputStream und FileInputStream
15.4.4 Datenströme über Files mit NIO.2 beziehen

15.5 Basisklassen für die Ein-/Ausgabe

15.5.1 Die abstrakten Basisklassen
15.5.2 Übersicht über Ein-/Ausgabeklassen
15.5.3 Die abstrakte Basisklasse OutputStream
15.5.4 Die Schnittstellen Closeable, AutoCloseable und Flushable
15.5.5 Die abstrakte Basisklasse InputStream
15.5.6 Ressourcen aus dem Klassenpfad und aus Jar?Archiven laden
15.5.7 Die abstrakte Basisklasse Writer
15.5.8 Die abstrakte Basisklasse Reader

15.6 Datenströme filtern und verketten

15.6.1 Streams als Filter verketten (verschachteln)
15.6.2 Gepufferte Ausgaben mit BufferedWriter und BufferedOutputStream
15.6.3 Gepufferte Eingaben mit BufferedReader/BufferedInputStream

15.7 Vermittler zwischen Byte-Streams und Unicode-Strömen

15.7.1 Datenkonvertierung durch den OutputStreamWriter
15.7.2 Automatische Konvertierungen mit dem InputStreamReader

16 Einführung in die <XML>-Verarbeitung mit Java

16.1 Auszeichnungssprachen

16.1.1 Die Standard Generalized Markup Language (SGML)
16.1.2 Extensible Markup Language (XML)

16.2 Eigenschaften von XML-Dokumenten

16.2.1 Elemente und Attribute
16.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten
16.2.3 Schema – eine Alternative zu DTD
16.2.4 Namensraum (Namespace)
16.2.5 XML-Applikationen *

16.3 Die Java-APIs für XML

16.3.1 Das Document Object Model (DOM)
16.3.2 Simple API for XML Parsing (SAX)
16.3.3 Pull-API StAX
16.3.4 Java Document Object Model (JDOM)
16.3.5 JAXP als Java-Schnittstelle zu XML
16.3.6 DOM-Bäume einlesen mit JAXP *

16.4 Java Architecture for XML Binding (JAXB)

16.4.1 Bean für JAXB aufbauen
16.4.2 JAXBContext und die Marshaller
16.4.3 Ganze Objektgraphen schreiben und lesen

16.5 XML-Dateien mit JDOM verarbeiten

16.5.1 JDOM beziehen
16.5.2 Paketübersicht *
16.5.3 Die Document-Klasse
16.5.4 Eingaben aus der Datei lesen
16.5.5 Das Dokument im XML-Format ausgeben
16.5.6 Elemente
16.5.7 Zugriff auf Elementinhalte
16.5.8 Attributinhalte lesen und ändern

16.6 Zum Weiterlesen


17 Einführung ins Datenbankmanagement mit JDBC

17.1 Relationale Datenbanken

17.1.1 Das relationale Modell

17.2 Einführung in SQL

17.2.1 Ein Rundgang durch SQL-Abfragen
17.2.2 Datenabfrage mit der Data Query Language (DQL)
17.2.3 Tabellen mit der Data Definition Language (DDL) anlegen

17.3 Datenbanken und Tools

17.3.1 HSQLDB
17.3.2 Eclipse-Plugins zum Durchschauen von Datenbanken

17.4 JDBC und Datenbanktreiber

17.5 Eine Beispielabfrage

17.5.1 Schritte zur Datenbankabfrage
17.5.2 Ein Client für die HSQLDB-Datenbank
17.5.3 Datenbankbrowser und eine Beispielabfrage unter NetBeans

18 Bits und Bytes und Mathematisches

18.1 Bits und Bytes *

18.1.1 Die Bit-Operatoren Komplement, Und, Oder und Xor
18.1.2 Repräsentation ganzer Zahlen in Java – das Zweierkomplement
18.1.3 Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem
18.1.4 Auswirkung der Typanpassung auf die Bitmuster
18.1.5 byte als vorzeichenlosen Datentyp nutzen
18.1.6 Die Verschiebeoperatoren
18.1.7 Ein Bit setzen, löschen, umdrehen und testen
18.1.8 Bit-Methoden der Integer- und Long-Klasse

18.2 Fließkommaarithmetik in Java

18.2.1 Spezialwerte für Unendlich, Null, NaN
18.2.2 Standard-Notation und wissenschaftliche Notation bei Fließkommazahlen *
18.2.3 Mantisse und Exponent *

18.3 Die Eigenschaften der Klasse Math

18.3.1 Attribute
18.3.2 Absolutwerte und Vorzeichen
18.3.3 Maximum/Minimum
18.3.4 Runden von Werten
18.3.5 Wurzel- und Exponentialmethoden
18.3.6 Der Logarithmus *
18.3.7 Rest der ganzzahligen Division *
18.3.8 Winkelmethoden *
18.3.9 Zufallszahlen

18.4 Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle *

18.4.1 Behandlung des Überlaufs
18.4.2 Was bitte macht ein ulp?

18.5 Mathe bitte strikt *

18.5.1 Strikte Fließkommaberechnungen mit strictfp
18.5.2 Die Klassen Math und StrictMath

18.6 Die Random-Klasse

18.6.1 Objekte mit dem Samen aufbauen
18.6.2 Zufallszahlen erzeugen
18.6.3 Pseudo-Zufallszahlen in der Normalverteilung *

18.7 Große Zahlen *

18.7.1 Die Klasse BigInteger
18.7.2 Methoden von BigInteger
18.7.3 Ganz lange Fakultäten
18.7.4 Große Fließkommazahlen mit BigDecimal
18.7.5 Mit MathContext komfortabel die Rechengenauigkeit setzen

18.8 Zum Weiterlesen


19 Die Werkzeuge des JDK

19.1 Java-Quellen übersetzen

19.1.1 Java-Compiler vom JDK
19.1.2 Native Compiler
19.1.3 Java-Programme in ein natives ausführbares Programm einpacken

19.2 Die Java-Laufzeitumgebung

19.3 Dokumentationskommentare mit JavaDoc

19.3.1 Einen Dokumentationskommentar setzen
19.3.2 Mit dem Werkzeug javadoc eine Dokumentation erstellen
19.3.3 HTML-Tags in Dokumentationskommentaren *
19.3.4 Generierte Dateien
19.3.5 Dokumentationskommentare im Überblick *
19.3.6 JavaDoc und Doclets *
19.3.7 Veraltete (deprecated) Typen und Eigenschaften

19.4 Das Archivformat Jar

19.4.1 Das Dienstprogramm jar benutzen
19.4.2 Das Manifest
19.4.3 Applikationen in Jar-Archiven starten

A Die Klassenbibliothek

A.1 java.lang-Paket

A.1.1 Schnittstellen
A.1.2 Klassen