Inhaltsverzeichnis

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

Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.

Name
E-Mail
Ihr Kommentar