Materialien zum Buch

Vorwort

1   Java ist auch eine Sprache

1.1   Historischer Hintergrund

1.2   Warum Java populär 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   Das Angebot an Bibliotheken und Werkzeugen

1.2.13   Vergleichbar einfache Syntax

1.2.14   Java ist Open Source

1.2.15   Wofür sich Java weniger eignet

1.3   Java im Vergleich zu anderen Sprachen *

1.3.1   Java und C(++)

1.3.2   Java und JavaScript

1.3.3   Ein Wort zu Microsoft, Java und zu J++

1.3.4   Java und C#/.NET

1.4   Weiterentwicklung und Verluste

1.4.1   Die Entwicklung von Java und seine Zukunftsaussichten

1.4.2   Features, Enhancements (Erweiterungen) und ein JSR

1.4.3   Applets

1.4.4   JavaFX

1.5   Java-Plattformen: Java SE, Jakarta EE, Java ME, Java Card

1.5.1   Die Java SE-Plattform

1.5.2   Java ME: Java für die Kleinen

1.5.3   Java für die ganz, ganz Kleinen

1.5.4   Java für die Großen: Jakarta EE (ehemals Java EE)

1.5.5   Echtzeit-Java (Real-time Java)

1.6   Java SE-Implementierungen

1.6.1   OpenJDK

1.6.2   Oracle JDK

1.7   JDK installieren

1.7.1   Oracle JDK unter Windows installieren

1.8   Das erste Programm compilieren und testen

1.8.1   Ein Quadratzahlen-Programm

1.8.2   Der Compilerlauf

1.8.3   Die Laufzeitumgebung

1.8.4   Häufige Compiler- und Interpreter-Probleme

1.9   Entwicklungsumgebungen

1.9.1   IntelliJ IDEA

1.9.2   Eclipse IDE

1.9.3   NetBeans

1.10   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(String[])

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   Erster Einblick in die 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   Automatisches Feststellen der Typen mit var

2.3.4   Finale Variablen und der Modifizierer final

2.3.5   Konsoleneingaben

2.3.6   Fließkommazahlen mit den Datentypen float und double

2.3.7   Ganzzahlige Datentypen

2.3.8   Wahrheitswerte

2.3.9   Unterstriche in Zahlen

2.3.10   Alphanumerische Zeichen

2.3.11   Gute Namen, schlechte Namen

2.3.12   Keine automatische 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   Präfix- oder Postfix-Inkrement und -Dekrement

2.4.5   Zuweisung mit Operation (Verbundoperator)

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 Typumwandlung (das Casting)

2.4.11   Überladenes Plus für Strings

2.4.12   Operator vermisst *

2.5   Bedingte Anweisungen oder Fallunterscheidungen

2.5.1   Verzweigung mit der 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.5.5   Switch-Ausdrücke

2.6   Immer das Gleiche mit den 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   Schleifenabbruch mit break und zurück zum Test mit continue

2.6.6   break und continue mit Marken *

2.7   Methoden einer Klasse

2.7.1   Bestandteile 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   Gültigkeitsbereich

2.7.12   Vorgegebener Wert für nicht aufgeführte Argumente *

2.7.13   Rekursive Methoden *

2.7.14   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   Klassenarbeit mit Point

3.3   Natürlich modellieren mit der UML (Unified Modeling Language) *

3.3.1   Wichtige Diagrammtypen der UML *

3.4   Neue Objekte erzeugen

3.4.1   Ein Exemplar einer Klasse mit dem Schlüsselwort new anlegen

3.4.2   Deklarieren von Referenzvariablen

3.4.3   Jetzt mach mal ’nen Punkt: Zugriff auf Objektvariablen und -methoden

3.4.4   Der Zusammenhang von new, Heap und Garbage-Collector

3.4.5   Überblick über Point-Methoden

3.4.6   Konstruktoren nutzen

3.5   ZZZZZnake

3.6   Pakete schnüren, Importe und Compilationseinheiten

3.6.1   Java-Pakete

3.6.2   Pakete der Standardbibliothek

3.6.3   Volle Qualifizierung und import-Deklaration

3.6.4   Mit import p1.p2.* alle Typen eines Pakets erreichen

3.6.5   Hierarchische Strukturen über Pakete und die Spiegelung im Dateisystem

3.6.6   Die package-Deklaration

3.6.7   Unbenanntes Paket (default package)

3.6.8   Compilationseinheit (Compilation Unit)

3.6.9   Statischer Import *

3.7   Mit Referenzen arbeiten, Vielfalt, Identität, Gleichwertigkeit

3.7.1   null-Referenz und die Frage der Philosophie

3.7.2   Alles auf null? Referenzen testen

3.7.3   Zuweisungen bei Referenzen

3.7.4   Methoden mit Referenztypen als Parameter

3.7.5   Identität von Objekten

3.7.6   Gleichwertigkeit und die Methode equals(…)

3.8   Zum Weiterlesen

4   Arrays und ihre Anwendungen

4.1   Einfache Feldarbeit

4.1.1   Grundbestandteile

4.1.2   Deklaration von Array-Variablen

4.1.3   Array-Objekte mit new erzeugen

4.1.4   Arrays mit { Inhalt }

4.1.5   Die Länge eines Arrays über die Objektvariable length auslesen

4.1.6   Zugriff auf die Elemente über den Index

4.1.7   Typische Array-Fehler

4.1.8   Arrays an Methoden übergeben

4.1.9   Mehrere Rückgabewerte *

4.1.10   Vorinitialisierte Arrays

4.2   Die erweiterte for-Schleife

4.3   Methode mit variabler Argumentanzahl (Varargs)

4.3.1   System.out.printf(…) nimmt eine beliebige Anzahl von Argumenten an

4.3.2   Durchschnitt finden von variablen Argumenten

4.3.3   Varargs-Designtipps *

4.4   Mehrdimensionale Arrays *

4.4.1   Nichtrechteckige Arrays *

4.5   Bibliotheksunterstützung von Arrays

4.5.1   Klonen kann sich lohnen – Arrays vermehren

4.5.2   Warum »können« Arrays so wenig?

4.5.3   Array-Inhalte kopieren

4.6   Die Klasse Arrays zum Vergleichen, Füllen, Suchen und Sortieren nutzen

4.6.1   Eine lange Schlange

4.7   Der Einstiegspunkt für das Laufzeitsystem: main(…)

4.7.1   Korrekte Deklaration der Startmethode

4.7.2   Kommandozeilenargumente verarbeiten

4.7.3   Der Rückgabetyp von main(…) und System.exit(int) *

4.8   Zum Weiterlesen

5   Der Umgang mit Zeichen und Zeichenketten

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

5.1.1   ASCII

5.1.2   ISO/IEC 8859-1

5.1.3   Unicode

5.1.4   Unicode-Zeichenkodierung

5.1.5   Escape-Sequenzen/Fluchtsymbole

5.1.6   Schreibweise für Unicode-Zeichen und Unicode-Escapes

5.1.7   Java-Versionen gehen mit dem Unicode-Standard Hand in Hand *

5.2   Datentypen für Zeichen und Zeichenfolgen

5.3   Die Character-Klasse

5.3.1   Ist das so?

5.3.2   Zeichen in Großbuchstaben/Kleinbuchstaben konvertieren

5.3.3   Vom Zeichen zum String

5.3.4   Von char in int: vom Zeichen zur Zahl *

5.4   Zeichenfolgen

5.5   Die Klasse String und ihre Methoden

5.5.1   String-Literale als String-Objekte für konstante Zeichenketten

5.5.2   Konkatenation mit +

5.5.3   Mehrzeilige Textblöcke mit """

5.5.4   String-Länge und Test auf Leer-String

5.5.5   Zugriff auf ein bestimmtes Zeichen mit charAt(int)

5.5.6   Nach enthaltenen Zeichen und Zeichenfolgen suchen

5.5.7   Das Hangman-Spiel

5.5.8   Gut, dass wir verglichen haben

5.5.9   String-Teile extrahieren

5.5.10   Strings anhängen, zusammenfügen, Groß-/Kleinschreibung und Weißraum

5.5.11   Gesucht, gefunden, ersetzt

5.5.12   String-Objekte mit Konstruktoren und aus Wiederholungen erzeugen *

5.6   Veränderbare Zeichenketten mit StringBuilder und StringBuffer

5.6.1   Anlegen von StringBuilder-Objekten

5.6.2   StringBuilder in andere Zeichenkettenformate konvertieren

5.6.3   Zeichen(folgen) erfragen

5.6.4   Daten anhängen

5.6.5   Zeichen(folgen) setzen, löschen und umdrehen

5.6.6   Länge und Kapazität eines StringBuilder-Objekts *

5.6.7   Vergleich von StringBuilder-Exemplaren und Strings mit StringBuilder

5.6.8   hashCode() bei StringBuilder *

5.7   CharSequence als Basistyp

5.8   Konvertieren zwischen Primitiven und Strings

5.8.1   Unterschiedliche Typen in String-Repräsentationen konvertieren

5.8.2   String-Inhalt in einen primitiven Wert konvertieren

5.8.3   String-Repräsentation im Format Binär, Hex und Oktal *

5.8.4   parse*(…)- und print*()-Methoden in DatatypeConverter *

5.9   Strings zusammenhängen (konkatenieren)

5.9.1   Strings mit StringJoiner zusammenhängen

5.10   Zerlegen von Zeichenketten

5.10.1   Splitten von Zeichenketten mit split(…)

5.10.2   Yes we can, yes we scan – die Klasse Scanner

5.11   Ausgaben formatieren

5.11.1   Formatieren und Ausgeben mit format()

5.12   Zum Weiterlesen

6   Eigene Klassen schreiben

6.1   Eigene Klassen mit Eigenschaften deklarieren

6.1.1   Objektvariablen deklarieren

6.1.2   Methoden deklarieren

6.1.3   Verdeckte (shadowed) Variablen

6.1.4   Die this-Referenz

6.2   Privatsphäre und Sichtbarkeit

6.2.1   Für die Öffentlichkeit: public

6.2.2   Kein Public Viewing – Passwörter sind privat

6.2.3   Wieso nicht freie Methoden und Variablen für alle?

6.2.4   Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht *

6.2.5   Zugriffsmethoden für Objektvariablen deklarieren

6.2.6   Setter und Getter nach der JavaBeans-Spezifikation

6.2.7   Paketsichtbar

6.2.8   Zusammenfassung zur Sichtbarkeit

6.3   Eine für alle – statische Methoden und Klassenvariablen

6.3.1   Warum statische Eigenschaften sinnvoll sind

6.3.2   Statische Eigenschaften mit static

6.3.3   Statische Eigenschaften über Referenzen nutzen? *

6.3.4   Warum die Groß- und Kleinschreibung wichtig ist *

6.3.5   Statische Variablen zum Datenaustausch *

6.3.6   Statische Eigenschaften und Objekteigenschaften *

6.4   Konstanten und Aufzählungen

6.4.1   Konstanten über statische finale Variablen

6.4.2   Typunsichere Aufzählungen

6.4.3   Aufzählungstypen: typsichere Aufzählungen mit enum

6.5   Objekte anlegen und zerstören

6.5.1   Konstruktoren schreiben

6.5.2   Verwandtschaft von Methode und Konstruktor

6.5.3   Der Standard-Konstruktor (default constructor)

6.5.4   Parametrisierte und überladene Konstruktoren

6.5.5   Copy-Konstruktor

6.5.6   Einen anderen Konstruktor der gleichen Klasse mit this(…) aufrufen

6.5.7   Immutable-Objekte und Wither-Methoden

6.5.8   Ihr fehlt uns nicht – der Garbage-Collector

6.6   Klassen- und Objektinitialisierung *

6.6.1   Initialisierung von Objektvariablen

6.6.2   Statische Blöcke als Klasseninitialisierer

6.6.3   Initialisierung von Klassenvariablen

6.6.4   Eincompilierte Belegungen der Klassenvariablen

6.6.5   Exemplarinitialisierer (Instanzinitialisierer)

6.6.6   Finale Werte im Konstruktor und in statischen Blöcken setzen

6.7   Zum Weiterlesen

7   Objektorientierte Beziehungsfragen

7.1   Assoziationen zwischen Objekten

7.1.1   Unidirektionale 1:1-Beziehung

7.1.2   Zwei Freunde müsst ihr werden – bidirektionale 1:1-Beziehungen

7.1.3   Unidirektionale 1:n-Beziehung

7.2   Vererbung

7.2.1   Vererbung in Java

7.2.2   Ereignisse modellieren

7.2.3   Die implizite Basisklasse java.lang.Object

7.2.4   Einfach- und Mehrfachvererbung *

7.2.5   Sehen Kinder alles? Die Sichtbarkeit protected

7.2.6   Konstruktoren in der Vererbung und super(…)

7.3   Typen in Hierarchien

7.3.1   Automatische und explizite Typumwandlung

7.3.2   Das Substitutionsprinzip

7.3.3   Typen mit dem instanceof-Operator testen

7.3.4   Pattern-Matching bei instanceof

7.4   Methoden überschreiben

7.4.1   Methoden in Unterklassen mit neuem Verhalten ausstatten

7.4.2   Mit super an die Eltern

7.5   Drum prüfe, wer sich dynamisch bindet

7.5.1   Gebunden an toString()

7.5.2   Implementierung von System.out.println(Object)

7.6   Finale Klassen und finale Methoden

7.6.1   Finale Klassen

7.6.2   Nicht überschreibbare (finale) Methoden

7.7   Abstrakte Klassen und abstrakte Methoden

7.7.1   Abstrakte Klassen

7.7.2   Abstrakte Methoden

7.8   Weiteres zum Überschreiben und dynamischen Binden

7.8.1   Nicht dynamisch gebunden bei privaten, statischen und finalen Methoden

7.8.2   Kovariante Rückgabetypen

7.8.3   Array-Typen und Kovarianz *

7.8.4   Dynamisch gebunden auch bei Konstruktoraufrufen *

7.8.5   Keine dynamische Bindung bei überdeckten Objektvariablen *

7.9   Zum Weiterlesen und Programmieraufgabe

8   Schnittstellen, Aufzählungen, versiegelte Klassen, Records

8.1   Schnittstellen

8.1.1   Schnittstellen sind neue Typen

8.1.2   Schnittstellen deklarieren

8.1.3   Abstrakte Methoden in Schnittstellen

8.1.4   Implementieren von Schnittstellen

8.1.5   Ein Polymorphie-Beispiel mit Schnittstellen

8.1.6   Die Mehrfachvererbung bei Schnittstellen

8.1.7   Keine Kollisionsgefahr bei Mehrfachvererbung *

8.1.8   Erweitern von Interfaces – Subinterfaces

8.1.9   Konstantendeklarationen bei Schnittstellen

8.1.10   Nachträgliches Implementieren von Schnittstellen *

8.1.11   Statische ausprogrammierte Methoden in Schnittstellen

8.1.12   Erweitern und Ändern von Schnittstellen

8.1.13   Default-Methoden

8.1.14   Erweiterte Schnittstellen deklarieren und nutzen

8.1.15   Öffentliche und private Schnittstellenmethoden

8.1.16   Erweiterte Schnittstellen, Mehrfachvererbung und Mehrdeutigkeiten *

8.1.17   Bausteine bilden mit Default-Methoden *

8.1.18   Markierungsschnittstellen *

8.1.19   (Abstrakte) Klassen und Schnittstellen im Vergleich

8.2   Aufzählungstypen

8.2.1   Methoden auf Enum-Objekten

8.2.2   Aufzählungen mit eigenen Methoden und Initialisierern *

8.2.3   enum mit eigenen Konstruktoren *

8.3   Versiegelte Klassen und Schnittstellen

8.3.1   Versiegelte Klassen und Schnittstellen (sealed classes/interfaces)

8.3.2   Unterklassen sind final, sealed, non-sealed

8.3.3   Abkürzende Schreibweisen

8.4   Records

8.4.1   Einfache Records

8.4.2   Records mit Methoden

8.4.3   Konstruktoren von Records anpassen

8.4.4   Konstruktoren ergänzen

8.4.5   Versiegelte Schnittstellen und Records

8.4.6   Zusammenfassung

8.5   Zum Weiterlesen

9   Ausnahmen müssen sein

9.1   Problembereiche einzäunen

9.1.1   Exceptions in Java mit try und catch

9.1.2   Geprüfte und ungeprüfte Ausnahmen

9.1.3   Eine NumberFormatException fliegt (ungeprüfte Ausnahme)

9.1.4   UUID in Textdatei anhängen (geprüfte Ausnahme)

9.1.5   Wiederholung abgebrochener Bereiche *

9.1.6   Bitte nicht schlucken – leere catch-Blöcke

9.1.7   Mehrere Ausnahmen auffangen

9.1.8   Zusammenfassen gleicher catch-Blöcke mit dem multi-catch

9.2   Ausnahmen weiterleiten, throws am Kopf von Methoden/Konstruktoren

9.2.1   throws bei Konstruktoren und Methoden

9.3   Die Klassenhierarchie der Ausnahmen

9.3.1   Eigenschaften des Exception-Objekts

9.3.2   Basistyp Throwable

9.3.3   Die Exception-Hierarchie

9.3.4   Oberausnahmen auffangen

9.3.5   Schon gefangen?

9.3.6   Ablauf einer Ausnahmesituation

9.3.7   Nicht zu allgemein fangen!

9.3.8   Bekannte RuntimeException-Klassen

9.3.9   Kann man abfangen, muss man aber nicht

9.4   Abschlussbehandlung mit finally

9.5   Auslösen eigener Exceptions

9.5.1   Mit throw Ausnahmen auslösen

9.5.2   Vorhandene Runtime-Ausnahmetypen kennen und nutzen

9.5.3   Parameter testen und gute Fehlermeldungen

9.5.4   Neue Exception-Klassen deklarieren

9.5.5   Eigene Ausnahmen als Unterklassen von Exception oder RuntimeException?

9.5.6   Ausnahmen abfangen und weiterleiten *

9.5.7   Aufruf-Stack von Ausnahmen verändern *

9.5.8   Präzises rethrow *

9.5.9   Geschachtelte Ausnahmen *

9.6   try mit Ressourcen (automatisches Ressourcen-Management)

9.6.1   try mit Ressourcen

9.6.2   Die Schnittstelle AutoCloseable

9.6.3   Ausnahmen vom close()

9.6.4   Typen, die AutoCloseable und Closeable sind

9.6.5   Mehrere Ressourcen nutzen

9.6.6   try mit Ressourcen auf null-Ressourcen

9.6.7   Unterdrückte Ausnahmen *

9.7   Besonderheiten bei der Ausnahmebehandlung *

9.7.1   Rückgabewerte bei ausgelösten Ausnahmen

9.7.2   Ausnahmen und Rückgaben verschwinden – das Duo return und finally

9.7.3   throws bei überschriebenen Methoden

9.7.4   Nicht erreichbare catch-Klauseln

9.8   Harte Fehler – Error *

9.9   Assertions *

9.9.1   Assertions in eigenen Programmen nutzen

9.9.2   Assertions aktivieren und Laufzeit-Errors

9.9.3   Assertions feiner aktivieren oder deaktivieren

9.10   Zum Weiterlesen

10   Geschachtelte Typen

10.1   Geschachtelte Klassen, Schnittstellen und Aufzählungen

10.2   Statische geschachtelte Typen

10.3   Nichtstatische geschachtelte Typen

10.3.1   Exemplare innerer Klassen erzeugen

10.3.2   Die this-Referenz

10.3.3   Vom Compiler generierte Klassendateien *

10.3.4   Erlaubte Modifizierer bei äußeren und inneren Klassen

10.4   Lokale Klassen

10.4.1   Beispiel mit eigener Klassendeklaration

10.4.2   Lokale Klasse für einen Timer nutzen

10.5   Anonyme innere Klassen

10.5.1   Nutzung einer anonymen inneren Klasse für den Timer

10.5.2   Umsetzung innerer anonymer Klassen *

10.5.3   Konstruktoren innerer anonymer Klassen

10.6   Zugriff auf lokale Variablen aus lokalen und anonymen Klassen *

10.7   this in Unterklassen *

10.7.1   Geschachtelte Klassen greifen auf private Eigenschaften zu

10.8   Nester

10.9   Zum Weiterlesen

11   Besondere Typen der Java SE

11.1   Object ist die Mutter aller Klassen

11.1.1   Klassenobjekte

11.1.2   Objektidentifikation mit toString()

11.1.3   Objektgleichwertigkeit mit equals(…) und Identität

11.1.4   Klonen eines Objekts mit clone() *

11.1.5   Hashwerte über hashCode() liefern *

11.1.6   System.identityHashCode(…) und das Problem der nicht eindeutigen Objektverweise *

11.1.7   Aufräumen mit finalize() *

11.1.8   Synchronisation *

11.2   Schwache Referenzen und Cleaner

11.3   Die Utility-Klasse java.util.Objects

11.3.1   Eingebaute null-Tests für equals(…)/hashCode()

11.3.2   Objects.toString(…)

11.3.3   null-Prüfungen mit eingebauter Ausnahmebehandlung

11.3.4   Tests auf null

11.3.5   Indexbezogene Programmargumente auf Korrektheit prüfen

11.4   Vergleichen von Objekten und Ordnung herstellen

11.4.1   Natürlich geordnet oder nicht?

11.4.2   compare*()-Methode der Schnittstellen Comparable und Comparator

11.4.3   Rückgabewerte kodieren die Ordnung

11.4.4   Beispiel-Comparator: den kleinsten Raum einer Sammlung finden

11.4.5   Tipps für Comparator- und Comparable-Implementierungen

11.4.6   Statische und Default-Methoden in Comparator

11.5   Wrapper-Klassen und Autoboxing

11.5.1   Wrapper-Objekte erzeugen

11.5.2   Konvertierungen in eine String-Repräsentation

11.5.3   Von einer String-Repräsentation parsen

11.5.4   Die Basisklasse Number für numerische Wrapper-Objekte

11.5.5   Vergleiche durchführen mit compare*(…), compareTo(…), equals(…) und Hashwerten

11.5.6   Statische Reduzierungsmethoden in Wrapper-Klassen

11.5.7   Konstanten für die Größe eines primitiven Typs

11.5.8   Behandeln von vorzeichenlosen Zahlen *

11.5.9   Die Klasse Integer

11.5.10   Die Klassen Double und Float für Fließkommazahlen

11.5.11   Die Long-Klasse

11.5.12   Die Boolean-Klasse

11.5.13   Autoboxing: Boxing und Unboxing

11.6   Iterator, Iterable *

11.6.1   Die Schnittstelle Iterator

11.6.2   Wer den Iterator liefert

11.6.3   Die Schnittstelle Iterable

11.6.4   Erweitertes for und Iterable

11.6.5   Interne Iteration

11.6.6   Ein eigenes Iterable implementieren *

11.7   Annotationen in der Java SE

11.7.1   Orte für Annotationen

11.7.2   Annotationstypen aus java.lang

11.7.3   @Deprecated

11.7.4   Annotationen mit zusätzlichen Informationen

11.7.5   @SuppressWarnings

11.8   Zum Weiterlesen

12   Generics<T>

12.1   Einführung in Java Generics

12.1.1   Mensch versus Maschine – Typprüfung des Compilers und der Laufzeitumgebung

12.1.2   Raketen

12.1.3   Generische Typen deklarieren

12.1.4   Generics nutzen

12.1.5   Diamonds are forever

12.1.6   Generische Schnittstellen

12.1.7   Generische Methoden/Konstruktoren und Typ-Inferenz

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

12.2.1   Realisierungsmöglichkeiten

12.2.2   Typlöschung (Type Erasure)

12.2.3   Probleme der Typlöschung

12.2.4   Raw-Type

12.3   Die Typen über Bounds einschränken

12.3.1   Einfache Einschränkungen mit extends

12.3.2   Weitere Obertypen mit &

12.4   Typparameter in der throws-Klausel *

12.4.1   Deklaration einer Klasse mit Typvariable <E extends Exception>

12.4.2   Parametrisierter Typ bei Typvariable <E extends Exception>

12.5   Generics und Vererbung, Invarianz

12.5.1   Arrays sind kovariant

12.5.2   Generics sind nicht kovariant, sondern invariant

12.5.3   Wildcards mit ?

12.5.4   Bounded Wildcards

12.5.5   Bounded-Wildcard-Typen und Bounded-Typvariablen

12.5.6   Das LESS-Prinzip

12.5.7   Enum<E extends Enum<E>> *

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

12.6.1   Typ-Token

12.6.2   Super-Type-Token

12.6.3   Generics und Arrays

12.6.4   Brückenmethoden

12.7   Zum Weiterlesen

13   Lambda-Ausdrücke und funktionale Programmierung

13.1   Funktionale Schnittstellen und Lambda-Ausdrücke

13.1.1   Klassen implementieren Schnittstellen

13.1.2   Lambda-Ausdrücke implementieren Schnittstellen

13.1.3   Funktionale Schnittstellen

13.1.4   Der Typ eines Lambda-Ausdrucks ergibt sich durch den Zieltyp

13.1.5   Annotation @FunctionalInterface

13.1.6   Syntax für Lambda-Ausdrücke

13.1.7   Die Umgebung der Lambda-Ausdrücke und Variablenzugriffe

13.1.8   Ausnahmen in Lambda-Ausdrücken

13.1.9   Klassen mit einer abstrakten Methode als funktionale Schnittstelle? *

13.2   Methodenreferenz

13.2.1   Motivation

13.2.2   Methodenreferenzen mit ::

13.2.3   Varianten von Methodenreferenzen

13.3   Konstruktorreferenz

13.3.1   Parameterlose und parametrisierte Konstruktoren

13.3.2   Nützliche vordefinierte Schnittstellen für Konstruktorreferenzen

13.4   Funktionale Programmierung

13.4.1   Code = Daten

13.4.2   Programmierparadigmen: imperativ oder deklarativ

13.4.3   Das Wesen der funktionalen Programmierung

13.4.4   Funktionale Programmierung und funktionale Programmiersprachen

13.4.5   Funktionen höherer Ordnung am Beispiel von Comparator

13.4.6   Lambda-Ausdrücke als Abbildungen bzw. Funktionen betrachten

13.5   Funktionale Schnittstellen aus dem java.util.function-Paket

13.5.1   Blöcke mit Code und die funktionale Schnittstelle Consumer

13.5.2   Supplier

13.5.3   Prädikate und java.util.function.Predicate

13.5.4   Funktionen über die funktionale Schnittstelle java.util.function.Function

13.5.5   Ein bisschen Bi …

13.5.6   Funktionale Schnittstellen mit Primitiven

13.6   Optional ist keine Nullnummer

13.6.1   Einsatz von null

13.6.2   Der Optional-Typ

13.6.3   Erst mal funktional mit Optional

13.6.4   Primitiv-Optionales mit speziellen Optional*-Klassen

13.7   Was ist jetzt so funktional?

13.8   Zum Weiterlesen

14   Architektur, Design und angewandte Objektorientierung

14.1   SOLIDe Modellierung

14.1.1   DRY, KISS und YAGNI

14.1.2   SOLID

14.1.3   Sei nicht STUPID

14.2   Architektur, Design und Implementierung

14.3   Design-Patterns (Entwurfsmuster)

14.3.1   Motivation für Design-Patterns

14.3.2   Singleton

14.3.3   Fabrikmethoden

14.3.4   Das Beobachter-Pattern mit Listener realisieren

14.4   Zum Weiterlesen

15   Java Platform Module System

15.1   Klassenlader (Class Loader) und Modul-/Klassenpfad

15.1.1   Klassenladen auf Abruf

15.1.2   Klassenlader bei der Arbeit zusehen

15.1.3   JMOD-Dateien und JAR-Dateien

15.1.4   Woher die Klassen kommen: Suchorte und spezielle Klassenlader

15.1.5   Setzen des Modulpfades

15.2   Module entwickeln und einbinden

15.2.1   Wer sieht wen?

15.2.2   Plattform-Module und ein JMOD-Beispiel

15.2.3   Interne Plattformeigenschaften nutzen, --add-exports

15.2.4   Neue Module einbinden, --add-modules und --add-opens

15.2.5   Projektabhängigkeiten in Eclipse

15.2.6   Benannte Module und module-info.java

15.2.7   Automatische Module

15.2.8   Unbenanntes Modul

15.2.9   Lesbarkeit und Zugreifbarkeit

15.2.10   Modul-Migration

15.3   Zum Weiterlesen

16   Die Klassenbibliothek

16.1   Die Java-Klassenphilosophie

16.1.1   Modul, Paket, Typ

16.1.2   Übersicht über die Pakete der Standardbibliothek

16.2   Einfache Zeitmessung und Profiling *

16.3   Die Klasse Class

16.3.1   An ein Class-Objekt kommen

16.3.2   Eine Class ist ein Type

16.4   Klassenlader

16.4.1   Die Klasse java.lang.ClassLoader

16.5   Die Utility-Klassen System und Properties

16.5.1   Speicher der JVM

16.5.2   Anzahl der CPUs bzw. Kerne

16.5.3   Systemeigenschaften der Java-Umgebung

16.5.4   Eigene Properties von der Konsole aus setzen *

16.5.5   Zeilenumbruchzeichen, line.separator

16.5.6   Umgebungsvariablen des Betriebssystems

16.6   Sprachen der Länder

16.6.1   Sprachen in Regionen über Locale-Objekte

16.7   Wichtige Datum-Klassen im Überblick

16.7.1   Der 1.1.1970

16.7.2   System.currentTimeMillis()

16.7.3   Einfache Zeitumrechnungen durch TimeUnit

16.8   Date-Time-API

16.8.1   Menschenzeit und Maschinenzeit

16.8.2   Die Datumsklasse LocalDate

16.9   Logging mit Java

16.9.1   Logging-APIs

16.9.2   Logging mit java.util.logging

16.10   Maven: Build-Management und Abhängigkeiten auflösen

16.10.1   Beispielprojekt in Eclipse mit Maven

16.10.2   Properties hinzunehmen

16.10.3   Dependency hinzunehmen

16.10.4   Lokales und das Remote-Repository

16.10.5   Lebenszylus, Phasen und Maven-Plugins

16.10.6   Archetypes

16.11   Zum Weiterlesen

17   Einführung in die nebenläufige Programmierung

17.1   Nebenläufigkeit und Parallelität

17.1.1   Multitasking, Prozesse und Threads

17.1.2   Threads und Prozesse

17.1.3   Wie nebenläufige Programme die Geschwindigkeit steigern können

17.1.4   Was Java für Nebenläufigkeit alles bietet

17.2   Existierende Threads und neue Threads erzeugen

17.2.1   Main-Thread

17.2.2   Wer bin ich?

17.2.3   Die Schnittstelle Runnable implementieren

17.2.4   Thread mit Runnable starten

17.2.5   Runnable parametrisieren

17.2.6   Die Klasse Thread erweitern

17.3   Thread-Eigenschaften und Zustände

17.3.1   Der Name eines Threads

17.3.2   Die Zustände eines Threads *

17.3.3   Schläfer gesucht

17.3.4   Wann Threads fertig sind

17.3.5   Einen Thread höflich mit Interrupt beenden

17.3.6   Unbehandelte Ausnahmen, Thread-Ende und UncaughtExceptionHandler

17.3.7   Der stop() von außen und die Rettung mit ThreadDeath *

17.3.8   Ein Rendezvous mit join(…) *

17.3.9   Arbeit niederlegen und wieder aufnehmen *

17.3.10   Priorität *

17.4   Der Ausführer (Executor) kommt

17.4.1   Die Schnittstelle Executor

17.4.2   Glücklich in der Gruppe – die Thread-Pools

17.4.3   Threads mit Rückgabe über Callable

17.4.4   Erinnerungen an die Zukunft – die Future-Rückgabe

17.4.5   Mehrere Callable-Objekte abarbeiten

17.4.6   CompletionService und ExecutorCompletionService

17.4.7   ScheduledExecutorService: wiederholende Aufgaben und Zeitsteuerungen

17.4.8   Asynchrones Programmieren mit CompletableFuture (CompletionStage)

17.5   Zum Weiterlesen

18   Einführung in Datenstrukturen und Algorithmen

18.1   Listen

18.1.1   Erstes Listen-Beispiel

18.1.2   Auswahlkriterium ArrayList oder LinkedList

18.1.3   Die Schnittstelle List

18.1.4   ArrayList

18.1.5   LinkedList

18.1.6   Der Array-Adapter Arrays.asList(…)

18.1.7   ListIterator *

18.1.8   toArray(…) von Collection verstehen – die Gefahr einer Falle erkennen

18.1.9   Primitive Elemente in Datenstrukturen verwalten

18.2   Mengen (Sets)

18.2.1   Ein erstes Mengen-Beispiel

18.2.2   Methoden der Schnittstelle Set

18.2.3   HashSet

18.2.4   TreeSet – die sortierte Menge

18.2.5   Die Schnittstellen NavigableSet und SortedSet

18.2.6   LinkedHashSet

18.3   Assoziative Speicher

18.3.1   Die Klassen HashMap und TreeMap

18.3.2   Einfügen und Abfragen des Assoziativspeichers

18.4   Java-Stream-API

18.4.1   Deklaratives Programmieren

18.4.2   Interne versus externe Iteration

18.4.3   Was ist ein Stream?

18.5   Einen Stream erzeugen

18.5.1   Parallele oder sequenzielle Streams

18.6   Terminale Operationen

18.6.1   Die Anzahl der Elemente

18.6.2   Und jetzt alle – forEach*(…)

18.6.3   Einzelne Elemente aus dem Strom holen

18.6.4   Existenztests mit Prädikaten

18.6.5   Einen Strom auf sein kleinstes bzw. größtes Element reduzieren

18.6.6   Einen Strom mit eigenen Funktionen reduzieren

18.6.7   Ergebnisse in einen Container schreiben, Teil 1: collect(…)

18.6.8   Ergebnisse in einen Container schreiben, Teil 2: Collector und Collectors

18.6.9   Ergebnisse in einen Container schreiben, Teil 3: Gruppierungen

18.6.10   Stream-Elemente in ein Array oder einen Iterator übertragen

18.7   Intermediäre Operationen

18.7.1   Element-Vorschau

18.7.2   Filtern von Elementen

18.7.3   Statusbehaftete intermediäre Operationen

18.7.4   Präfix-Operation

18.7.5   Abbildungen

18.8   Zum Weiterlesen

19   Einführung in grafische Oberflächen

19.1   GUI-Frameworks

19.1.1   Kommandozeile

19.1.2   Grafische Benutzeroberfläche

19.1.3   Abstract Window Toolkit (AWT)

19.1.4   Java Foundation Classes und Swing

19.1.5   JavaFX

19.1.6   SWT (Standard Widget Toolkit) *

19.2   Deklarative und programmierte Oberflächen

19.2.1   GUI-Beschreibungen in JavaFX

19.2.2   Deklarative GUI-Beschreibungen für Swing?

19.3   GUI-Builder

19.3.1   GUI-Builder für JavaFX

19.3.2   GUI-Builder für Swing

19.4   Mit dem Eclipse WindowBuilder zur ersten Swing-Oberfläche

19.4.1   WindowBuilder installieren

19.4.2   Mit WindowBuilder eine GUI-Klasse hinzufügen

19.4.3   Das Layoutprogramm starten

19.4.4   Grafische Oberfläche aufbauen

19.4.5   Swing-Komponenten-Klassen

19.4.6   Funktionalität geben

19.5   Grundlegendes zum Zeichnen

19.5.1   Die paint(Graphics)-Methode für den AWT-Frame

19.5.2   Die ereignisorientierte Programmierung ändert Fensterinhalte

19.5.3   Zeichnen von Inhalten auf einen JFrame

19.5.4   Auffordern zum Neuzeichnen mit repaint(…)

19.5.5   Java 2D-API

19.6   Zum Weiterlesen

20   Einführung in Dateien und Datenströme

20.1   Alte und neue Welt in java.io und java.nio

20.1.1   java.io-Paket mit File-Klasse

20.1.2   NIO.2 und das java.nio-Paket

20.1.3   java.io.File oder java.nio.*-Typen?

20.2   Dateisysteme und Pfade

20.2.1   FileSystem und Path

20.2.2   Die Utility-Klasse Files

20.3   Dateien mit wahlfreiem Zugriff

20.3.1   Ein RandomAccessFile zum Lesen und Schreiben öffnen

20.3.2   Aus dem RandomAccessFile lesen

20.3.3   Schreiben mit RandomAccessFile

20.3.4   Die Länge des RandomAccessFile

20.3.5   Hin und her in der Datei

20.4   Basisklassen für die Ein-/Ausgabe

20.4.1   Die vier abstrakten Basisklassen

20.4.2   Die abstrakte Basisklasse OutputStream

20.4.3   Die abstrakte Basisklasse InputStream

20.4.4   Die abstrakte Basisklasse Writer

20.4.5   Die Schnittstelle Appendable *

20.4.6   Die abstrakte Basisklasse Reader

20.4.7   Die Schnittstellen Closeable, AutoCloseable und Flushable

20.5   Lesen aus Dateien und Schreiben in Dateien

20.5.1   Byteorientierte Datenströme über Files beziehen

20.5.2   Zeichenorientierte Datenströme über Files beziehen

20.5.3   Die Funktion von OpenOption bei den Files.new*(…)-Methoden

20.5.4   Ressourcen aus dem Modulpfad und aus JAR-Dateien laden

20.6   Zum Weiterlesen

21   Einführung ins Datenbankmanagement mit JDBC

21.1   Relationale Datenbanken und Java-Zugriffe

21.1.1   Das relationale Modell

21.1.2   Java-APIs zum Zugriff auf relationale Datenbanken

21.1.3   Die JDBC-API und Implementierungen: JDBC-Treiber

21.1.4   H2 ist das Werkzeug auf der Insel

21.2   Eine Beispielabfrage

21.2.1   Schritte zur Datenbankabfrage

21.2.2   Mit Java auf die relationale Datenbank zugreifen

21.3   Zum Weiterlesen

22   Bits und Bytes, Mathematisches und Geld

22.1   Bits und Bytes

22.1.1   Die Bit-Operatoren Komplement, Und, Oder und XOR

22.1.2   Repräsentation ganzer Zahlen in Java – das Zweierkomplement

22.1.3   Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem

22.1.4   Auswirkung der Typumwandlung auf die Bit-Muster

22.1.5   Vorzeichenlos arbeiten

22.1.6   Die Verschiebeoperatoren

22.1.7   Ein Bit setzen, löschen, umdrehen und testen

22.1.8   Bit-Methoden der Integer- und Long-Klasse

22.2   Fließkomma-Arithmetik in Java

22.2.1   Spezialwerte für Unendlich, Null, NaN

22.2.2   Standardnotation und wissenschaftliche Notation bei Fließkommazahlen *

22.2.3   Mantisse und Exponent *

22.3   Die Eigenschaften der Klasse Math

22.3.1   Objektvariablen der Klasse Math

22.3.2   Absolutwerte und Vorzeichen

22.3.3   Maximum/Minimum

22.3.4   Runden von Werten

22.3.5   Rest der ganzzahligen Division *

22.3.6   Division mit Rundung in Richtung negativ unendlich, alternativer Restwert *

22.3.7   Multiply-Accumulate

22.3.8   Wurzel- und Exponentialmethoden

22.3.9   Der Logarithmus *

22.3.10   Winkelmethoden *

22.3.11   Zufallszahlen

22.4   Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle *

22.4.1   Der größte und der kleinste Wert

22.4.2   Überlauf und alles ganz exakt

22.4.3   Was bitte macht eine ulp?

22.5   Zufallszahlen: Random, SecureRandom und SplittableRandom

22.5.1   Die Klasse Random

22.5.2   Random-Objekte mit dem Samen aufbauen

22.5.3   Einzelne Zufallszahlen erzeugen

22.5.4   Pseudo-Zufallszahlen in der Normalverteilung *

22.5.5   Strom von Zufallszahlen generieren *

22.5.6   Die Klasse SecureRandom *

22.5.7   SplittableRandom *

22.6   Große Zahlen *

22.6.1   Die Klasse BigInteger

22.6.2   Beispiel: ganz lange Fakultäten mit BigInteger

22.6.3   Große Fließkommazahlen mit BigDecimal

22.6.4   Mit MathContext komfortabel die Rechengenauigkeit setzen

22.6.5   Noch schneller rechnen durch mutable Implementierungen

22.7   Geld und Währung

22.7.1   Geldbeträge repräsentieren

22.7.2   ISO 4217

22.7.3   Währungen in Java repräsentieren

22.8   Zum Weiterlesen

23   Testen mit JUnit

23.1   Softwaretests

23.1.1   Vorgehen beim Schreiben von Testfällen

23.2   Das Test-Framework JUnit

23.2.1   Test-Driven Development und Test-First

23.2.2   Testen, implementieren, testen, implementieren, testen, freuen

23.2.3   JUnit-Tests ausführen

23.2.4   assert*(…)-Methoden der Klasse Assertions

23.2.5   Exceptions testen

23.2.6   Grenzen für Ausführungszeiten festlegen

23.2.7   Beschriftungen mit @DisplayName

23.2.8   Verschachtelte Tests

23.2.9   Tests ignorieren

23.2.10   Mit Methoden der Assumptions-Klasse Tests abbrechen

23.2.11   Parametrisierte Tests

23.3   Java-Assertions-Bibliotheken und AssertJ

23.3.1   AssertJ

23.4   Aufbau größerer Testfälle

23.4.1   Fixtures

23.4.2   Sammlungen von Testklassen und Klassenorganisation

23.5   Wie gutes Design das Testen ermöglicht

23.6   Dummy, Fake, Stub und Mock

23.7   JUnit-Erweiterungen, Testzusätze

23.8   Zum Weiterlesen

24   Die Werkzeuge des JDK

24.1   Übersicht

24.1.1   Aufbau und gemeinsame Schalter

24.2   Java-Quellen übersetzen

24.2.1   Der Java-Compiler des JDK

24.2.2   Alternative Compiler

24.2.3   Native Compiler

24.3   Die Java-Laufzeitumgebung

24.3.1   Schalter der JVM

24.3.2   Der Unterschied zwischen java.exe und javaw.exe

24.4   Dokumentationskommentare mit Javadoc

24.4.1   Einen Dokumentationskommentar setzen

24.4.2   Mit dem Werkzeug javadoc eine Dokumentation erstellen

24.4.3   HTML-Tags in Dokumentationskommentaren *

24.4.4   Generierte Dateien

24.4.5   Dokumentationskommentare im Überblick *

24.4.6   Javadoc und Doclets *

24.4.7   Veraltete (deprecated) Typen und Eigenschaften

24.4.8   Javadoc-Überprüfung mit DocLint

24.5   Das Archivformat JAR

24.5.1   Das Dienstprogramm jar benutzen

24.5.2   Das Manifest

24.5.3   Applikationen in JAR-Archiven starten

24.6   jlink: der Java Linker

24.7   Zum Weiterlesen

A   Java SE-Module und Paketübersicht

A.1   Alle Module von Java 17

A.1.1   Java SE-Module

A.1.2   JDK-Modul

A.1.3   Java Smart Card I/O-Modul

A.2   Pakete der Java SE-Module

A.2.1   java.base

A.2.2   java.compiler

A.2.3   java.datatransfer

A.2.4   java.desktop

A.2.5   java.instrument

A.2.6   java.logging

A.2.7   java.management

A.2.8   java.management.rmi

A.2.9   java.naming

A.2.10   java.net.http

A.2.11   java.prefs

A.2.12   java.rmi

A.2.13   java.scripting

A.2.14   java.security.jgss

A.2.15   java.security.sasl

A.2.16   java.sql

A.2.17   java.sql.rowset

A.2.18   java.transaction.xa

A.2.19   java.xml

A.2.20   java.xml.crypto

A.3   java.lang-Paket

Stichwortverzeichnis