Zum Rheinwerk-ShopMaterialien
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 AdoptOpenJDK installieren
1.7.1 AdoptOpenJDK 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 Eclipse IDE
1.9.2 IntelliJ IDEA
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 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 Schlüsselwort new anlegen
3.4.2 Deklarieren von Referenzvariablen
3.4.3 Jetzt mach mal ’nen Punkt: Zugriff auf Objektattribute 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 Parametern
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 das Attribut 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 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 String-Länge und Test auf Leer-String
5.5.4 Zugriff auf ein bestimmtes Zeichen mit charAt(int)
5.5.5 Nach enthaltenen Zeichen und Zeichenfolgen suchen
5.5.6 Das Hangman-Spiel
5.5.7 Gut, dass wir verglichen haben
5.5.8 String-Teile extrahieren
5.5.9 Strings anhängen, zusammenfügen, Groß-/Kleinschreibung und Weißraum
5.5.10 Gesucht, gefunden, ersetzt
5.5.11 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 parseXXX(…)- und printXXX()-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 Attribute 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 Attribute 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 statische Attribute
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 Spielobjekte 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.4 Methoden überschreiben
7.4.1 Methoden in Unterklassen mit neuem Verhalten ausstatten
7.4.2 Mit super an die Eltern
7.4.3 Finale Klassen und finale Methoden
7.4.4 Kovariante Rückgabetypen
7.4.5 Array-Typen und Kovarianz *
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.5.3 Nicht dynamisch gebunden bei privaten, statischen und finalen Methoden
7.5.4 Dynamisch gebunden auch bei Konstruktoraufrufen *
7.5.5 Eine letzte Spielerei mit Javas dynamischer Bindung und überdeckten Attributen *
7.6 Abstrakte Klassen und abstrakte Methoden
7.6.1 Abstrakte Klassen
7.6.2 Abstrakte Methoden
7.7 Schnittstellen
7.7.1 Schnittstellen sind neue Typen
7.7.2 Schnittstellen deklarieren
7.7.3 Abstrakte Methoden in Schnittstellen
7.7.4 Implementieren von Schnittstellen
7.7.5 Ein Polymorphie-Beispiel mit Schnittstellen
7.7.6 Die Mehrfachvererbung bei Schnittstellen
7.7.7 Keine Kollisionsgefahr bei Mehrfachvererbung *
7.7.8 Erweitern von Interfaces – Subinterfaces
7.7.9 Konstantendeklarationen bei Schnittstellen
7.7.10 Nachträgliches Implementieren von Schnittstellen *
7.7.11 Statische ausprogrammierte Methoden in Schnittstellen
7.7.12 Erweitern und Ändern von Schnittstellen
7.7.13 Default-Methoden
7.7.14 Erweiterte Schnittstellen deklarieren und nutzen
7.7.15 Öffentliche und private Schnittstellenmethoden
7.7.16 Erweiterte Schnittstellen, Mehrfachvererbung und Mehrdeutigkeiten *
7.7.17 Bausteine bilden mit Default-Methoden *
7.7.18 Initialisierung von Schnittstellenkonstanten *
7.7.19 Markierungsschnittstellen *
7.7.20 (Abstrakte) Klassen und Schnittstellen im Vergleich
7.8 SOLIDe Modellierung
7.8.1 DRY, KISS und YAGNI
7.8.2 SOLID
7.8.3 Sei nicht STUPID
7.9 Zum Weiterlesen
8 Ausnahmen müssen sein
8.1 Problembereiche einzäunen
8.1.1 Exceptions in Java mit try und catch
8.1.2 Geprüfte und ungeprüfte Ausnahmen
8.2 Geprüfte Ausnahmen
8.2.1 Letzte ausgeführte Java-Programme loggen
8.2.2 try-catch-Behandlung
8.2.3 throws im Methodenkopf angeben
8.3 Ungeprüfte Ausnahmen (RuntimeException)
8.3.1 Eine NumberFormatException fliegt
8.3.2 Bekannte RuntimeException-Klassen
8.3.3 Kann man abfangen, muss man aber nicht
8.4 Gut gefangen
8.4.1 Bitte nicht schlucken – leere catch-Blöcke
8.4.2 Wiederholung abgebrochener Bereiche *
8.4.3 Mehrere Ausnahmen auffangen
8.4.4 Ablauf einer Ausnahmesituation
8.4.5 Abschlussbehandlung mit finally
8.5 Die Klassenhierarchie der Ausnahmen
8.5.1 Eigenschaften des Exception-Objekts
8.5.2 Basistyp Throwable
8.5.3 Die Exception-Hierarchie
8.5.4 Oberausnahmen auffangen
8.5.5 Schon gefangen?
8.5.6 Alles geht als Exception durch
8.5.7 Zusammenfassen gleicher catch-Blöcke mit dem multi-catch
8.6 Auslösen eigener Exceptions
8.6.1 Mit throw Ausnahmen auslösen
8.6.2 Vorhandene Runtime-Ausnahmetypen kennen und nutzen
8.6.3 Parameter testen und gute Fehlermeldungen
8.6.4 Neue Exception-Klassen deklarieren
8.6.5 Eigene Ausnahmen als Unterklassen von Exception oder RuntimeException?
8.6.6 Ausnahmen abfangen und weiterleiten *
8.6.7 Aufruf-Stack von Ausnahmen verändern *
8.6.8 Präzises rethrow *
8.6.9 Geschachtelte Ausnahmen *
8.7 Automatisches Ressourcen-Management (try mit Ressourcen)
8.7.1 try mit Ressourcen
8.7.2 Die Schnittstelle AutoCloseable
8.7.3 Mehrere Ressourcen nutzen
8.7.4 try mit Ressourcen auf null-Ressourcen
8.7.5 Ausnahmen vom close()
8.7.6 Unterdrückte Ausnahmen *
8.8 Besonderheiten bei der Ausnahmebehandlung *
8.8.1 Rückgabewerte bei ausgelösten Ausnahmen
8.8.2 Ausnahmen und Rückgaben verschwinden – das Duo return und finally
8.8.3 throws bei überschriebenen Methoden
8.8.4 Nicht erreichbare catch-Klauseln
8.9 Harte Fehler – Error *
8.10 Assertions *
8.10.1 Assertions in eigenen Programmen nutzen
8.10.2 Assertions aktivieren und Laufzeit-Errors
8.10.3 Assertions feiner aktivieren oder deaktivieren
8.11 Zum Weiterlesen
9 Geschachtelte Typen
9.1 Geschachtelte Klassen, Schnittstellen und Aufzählungen
9.2 Statische geschachtelte Typen
9.3 Nichtstatische geschachtelte Typen
9.3.1 Exemplare innerer Klassen erzeugen
9.3.2 Die this-Referenz
9.3.3 Vom Compiler generierte Klassendateien *
9.3.4 Erlaubte Modifizierer bei äußeren und inneren Klassen
9.4 Lokale Klassen
9.4.1 Beispiel mit eigener Klassendeklaration
9.4.2 Lokale Klasse für einen Timer nutzen
9.5 Anonyme innere Klassen
9.5.1 Nutzung einer anonymen inneren Klasse für den Timer
9.5.2 Umsetzung innerer anonymer Klassen *
9.5.3 Konstruktoren innerer anonymer Klassen
9.6 Zugriff auf lokale Variablen aus lokalen und anonymen Klassen *
9.7 this in Unterklassen *
9.7.1 Geschachtelte Klassen greifen auf private Eigenschaften zu
9.8 Nester
9.9 Zum Weiterlesen
10 Besondere Typen der Java SE
10.1 Object ist die Mutter aller Klassen
10.1.1 Klassenobjekte
10.1.2 Objektidentifikation mit toString()
10.1.3 Objektgleichwertigkeit mit equals(…) und Identität
10.1.4 Klonen eines Objekts mit clone() *
10.1.5 Hashwerte über hashCode() liefern *
10.1.6 System.identityHashCode(…) und das Problem der nicht eindeutigen Objektverweise *
10.1.7 Aufräumen mit finalize() *
10.1.8 Synchronisation *
10.2 Schwache Referenzen und Cleaner
10.3 Die Utility-Klasse java.util.Objects
10.3.1 Eingebaute null-Tests für equals(…)/hashCode()
10.3.2 Objects.toString(…)
10.3.3 null-Prüfungen mit eingebauter Ausnahmebehandlung
10.3.4 Tests auf null
10.3.5 Indexbezogene Programmargumente auf Korrektheit prüfen
10.4 Vergleichen von Objekten und Ordnung herstellen
10.4.1 Natürlich geordnet oder nicht?
10.4.2 compareXXX()-Methode der Schnittstellen Comparable und Comparator
10.4.3 Rückgabewerte kodieren die Ordnung
10.4.4 Beispiel-Comparator: den kleinsten Raum einer Sammlung finden
10.4.5 Tipps für Comparator und Comparable-Implementierungen
10.4.6 Statische und Default-Methoden in Comparator
10.5 Wrapper-Klassen und Autoboxing
10.5.1 Wrapper-Objekte erzeugen
10.5.2 Konvertierungen in eine String-Repräsentation
10.5.3 Von einer String-Repräsentation parsen
10.5.4 Die Basisklasse Number für numerische Wrapper-Objekte
10.5.5 Vergleiche durchführen mit compareXXX(…), compareTo(…), equals(…) und Hashwerten
10.5.6 Statische Reduzierungsmethoden in Wrapper-Klassen
10.5.7 Konstanten für die Größe eines primitiven Typs
10.5.8 Behandeln von vorzeichenlosen Zahlen *
10.5.9 Die Klasse Integer
10.5.10 Die Klassen Double und Float für Fließkommazahlen
10.5.11 Die Long-Klasse
10.5.12 Die Boolean-Klasse
10.5.13 Autoboxing: Boxing und Unboxing
10.6 Iterator, Iterable *
10.6.1 Die Schnittstelle Iterator
10.6.2 Wer den Iterator liefert
10.6.3 Die Schnittstelle Iterable
10.6.4 Erweitertes for und Iterable
10.6.5 Interne Iteration
10.6.6 Eine eigene Iterable implementieren *
10.7 Die Spezial-Oberklasse Enum
10.7.1 Methoden auf Enum-Objekten
10.7.2 Aufzählungen mit eigenen Methoden und Initialisierern *
10.7.3 enum mit eigenen Konstruktoren *
10.8 Annotationen in der Java SE
10.8.1 Orte für Annotationen
10.8.2 Annotationstypen aus java.lang
10.8.3 @Deprecated
10.8.4 Annotationen mit zusätzlichen Informationen
10.8.5 @SuppressWarnings
10.9 Zum Weiterlesen
11 Generics<T>
11.1 Einführung in Java Generics
11.1.1 Mensch versus Maschine – Typprüfung des Compilers und der Laufzeitumgebung
11.1.2 Raketen
11.1.3 Generische Typen deklarieren
11.1.4 Generics nutzen
11.1.5 Diamonds are forever
11.1.6 Generische Schnittstellen
11.1.7 Generische Methoden/Konstruktoren und Typ-Inferenz
11.2 Umsetzen der Generics, Typlöschung und Raw-Types
11.2.1 Realisierungsmöglichkeiten
11.2.2 Typlöschung (Type Erasure)
11.2.3 Probleme der Typlöschung
11.2.4 Raw-Type
11.3 Die Typen über Bounds einschränken
11.3.1 Einfache Einschränkungen mit extends
11.3.2 Weitere Obertypen mit &
11.4 Typparameter in der throws-Klausel *
11.4.1 Deklaration einer Klasse mit Typvariable <E extends Exception>
11.4.2 Parametrisierter Typ bei Typvariable <E extends Exception>
11.5 Generics und Vererbung, Invarianz
11.5.1 Arrays sind kovariant
11.5.2 Generics sind nicht kovariant, sondern invariant
11.5.3 Wildcards mit ?
11.5.4 Bounded Wildcards
11.5.5 Bounded-Wildcard-Typen und Bounded-Typvariablen
11.5.6 Das LESS-Prinzip
11.5.7 Enum<E extends Enum<E>> *
11.6 Konsequenzen der Typlöschung: Typ-Token, Arrays und Brücken *
11.6.1 Typ-Token
11.6.2 Super-Type-Token
11.6.3 Generics und Arrays
11.6.4 Brückenmethoden
11.7 Zum Weiterlesen
12 Lambda-Ausdrücke und funktionale Programmierung
12.1 Funktionale Schnittstellen und Lambda-Ausdrücke
12.1.1 Klassen implementieren Schnittstellen
12.1.2 Lambda-Ausdrücke implementieren Schnittstellen
12.1.3 Funktionale Schnittstellen
12.1.4 Der Typ eines Lambda-Ausdrucks ergibt sich durch den Zieltyp
12.1.5 Annotation @FunctionalInterface
12.1.6 Syntax für Lambda-Ausdrücke
12.1.7 Die Umgebung der Lambda-Ausdrücke und Variablenzugriffe
12.1.8 Ausnahmen in Lambda-Ausdrücken
12.1.9 Klassen mit einer abstrakten Methode als funktionale Schnittstelle? *
12.2 Methodenreferenz
12.2.1 Motivation
12.2.2 Methodenreferenzen mit ::
12.2.3 Varianten von Methodenreferenzen
12.3 Konstruktorreferenz
12.3.1 Parameterlose und parametrisierte Konstruktoren
12.3.2 Nützliche vordefinierte Schnittstellen für Konstruktorreferenzen
12.4 Funktionale Programmierung
12.4.1 Code = Daten
12.4.2 Programmierparadigmen: imperativ oder deklarativ
12.4.3 Das Wesen der funktionalen Programmierung
12.4.4 Funktionale Programmierung und funktionale Programmiersprachen
12.4.5 Funktionen höherer Ordnung am Beispiel von Comparator
12.4.6 Lambda-Ausdrücke als Abbildungen bzw. Funktionen betrachten
12.5 Funktionale Schnittstellen aus dem java.util.function-Paket
12.5.1 Blöcke mit Code und die funktionale Schnittstelle Consumer
12.5.2 Supplier
12.5.3 Prädikate und java.util.function.Predicate
12.5.4 Funktionen über die funktionale Schnittstelle java.util.function.Function
12.5.5 Ein bisschen Bi …
12.5.6 Funktionale Schnittstellen mit Primitiven
12.6 Optional ist keine Nullnummer
12.6.1 Einsatz von null
12.6.2 Der Optional-Typ
12.6.3 Primitive optionale Typen
12.6.4 Erst mal funktional mit Optional
12.6.5 Primitiv-Optionales mit speziellen OptionalXXX-Klassen
12.7 Was ist jetzt so funktional?
12.8 Zum Weiterlesen
13 Architektur, Design und angewandte Objektorientierung
13.1 Architektur, Design und Implementierung
13.2 Design-Patterns (Entwurfsmuster)
13.2.1 Motivation für Design-Patterns
13.2.2 Singleton
13.2.3 Fabrikmethoden
13.2.4 Das Beobachter-Pattern mit Listener realisieren
13.3 Zum Weiterlesen
14 Java Platform Module System
14.1 Klassenlader (Class Loader) und Modul-/Klassenpfad
14.1.1 Klassenladen auf Abruf
14.1.2 Klassenlader bei der Arbeit zusehen
14.1.3 JMOD-Dateien und JAR-Dateien
14.1.4 Woher die kleinen Klassen kommen: Die Suchorte und spezielle Klassenlader
14.1.5 Setzen des Modulpfades
14.2 Module entwickeln und einbinden
14.2.1 Wer sieht wen?
14.2.2 Plattform-Module und ein JMOD-Beispiel
14.2.3 Interne Plattformeigenschaften nutzen, --add-exports
14.2.4 Neue Module einbinden, --add-modules und --add-opens
14.2.5 Projektabhängigkeiten in Eclipse
14.2.6 Benannte Module und module-info.java
14.2.7 Automatische Module
14.2.8 Unbenanntes Modul
14.2.9 Lesbarkeit und Zugreifbarkeit
14.2.10 Modul-Migration
14.3 Zum Weiterlesen
15 Die Klassenbibliothek
15.1 Die Java-Klassenphilosophie
15.1.1 Modul, Paket, Typ
15.1.2 Übersicht über die Pakete der Standardbibliothek
15.2 Einfache Zeitmessung und Profiling *
15.3 Die Klasse Class
15.3.1 An ein Class-Objekt kommen
15.3.2 Eine Class ist ein Type
15.4 Klassenlader
15.4.1 Die Klasse java.lang.ClassLoader
15.5 Die Utility-Klassen System und Properties
15.5.1 Speicher der JVM
15.5.2 Anzahl der CPUs bzw. Kerne
15.5.3 Systemeigenschaften der Java-Umgebung
15.5.4 Eigene Properties von der Konsole aus setzen *
15.5.5 Zeilenumbruchzeichen, line.separator
15.5.6 Umgebungsvariablen des Betriebssystems
15.6 Sprachen der Länder
15.6.1 Sprachen in Regionen über Locale-Objekte
15.7 Wichtige Datum-Klassen im Überblick
15.7.1 Der 1.1.1970
15.7.2 System.currentTimeMillis()
15.7.3 Einfache Zeitumrechnungen durch TimeUnit
15.8 Date-Time-API
15.8.1 Menschenzeit und Maschinenzeit
15.8.2 Die Datumsklasse LocalDate
15.9 Logging mit Java
15.9.1 Logging-APIs
15.9.2 Logging mit java.util.logging
15.10 Maven: Build-Management und Abhängigkeiten auflösen
15.10.1 Beispielprojekt in Eclipse mit Maven
15.10.2 Properties hinzunehmen
15.10.3 Dependency hinzunehmen
15.10.4 Lokales und das Remote-Repository
15.10.5 Lebenszylus, Phasen und Maven-Plugins
15.10.6 Archetypes
15.11 Zum Weiterlesen
16 Einführung in die nebenläufige Programmierung
16.1 Nebenläufigkeit und Parallelität
16.1.1 Multitasking, Prozesse und Threads
16.1.2 Threads und Prozesse
16.1.3 Wie nebenläufige Programme die Geschwindigkeit steigern können
16.1.4 Was Java für Nebenläufigkeit alles bietet
16.2 Existierende Threads und neue Threads erzeugen
16.2.1 Main-Thread
16.2.2 Wer bin ich?
16.2.3 Die Schnittstelle Runnable implementieren
16.2.4 Thread mit Runnable starten
16.2.5 Runnable parametrisieren
16.2.6 Die Klasse Thread erweitern
16.3 Thread-Eigenschaften und Zustände
16.3.1 Der Name eines Threads
16.3.2 Die Zustände eines Threads *
16.3.3 Schläfer gesucht
16.3.4 Wann Threads fertig sind
16.3.5 Einen Thread höflich mit Interrupt beenden
16.3.6 Unbehandelte Ausnahmen, Thread-Ende und UncaughtExceptionHandler
16.3.7 Der stop() von außen und die Rettung mit ThreadDeath *
16.3.8 Ein Rendezvous mit join(…) *
16.3.9 Arbeit niederlegen und wieder aufnehmen *
16.3.10 Priorität *
16.4 Der Ausführer (Executor) kommt
16.4.1 Die Schnittstelle Executor
16.4.2 Glücklich in der Gruppe – die Thread-Pools
16.4.3 Threads mit Rückgabe über Callable
16.4.4 Erinnerungen an die Zukunft – die Future-Rückgabe
16.4.5 Mehrere Callable-Objekte abarbeiten
16.4.6 CompletionService und ExecutorCompletionService
16.4.7 ScheduledExecutorService: wiederholende Aufgaben und Zeitsteuerungen
16.4.8 Asynchrones Programmieren mit CompletableFuture (CompletionStage)
16.5 Zum Weiterlesen
17 Einführung in Datenstrukturen und Algorithmen
17.1 Listen
17.1.1 Erstes Listen-Beispiel
17.1.2 Auswahlkriterium ArrayList oder LinkedList
17.1.3 Die Schnittstelle List
17.1.4 ArrayList
17.1.5 LinkedList
17.1.6 Der Array-Adapter Arrays.asList(…)
17.1.7 ListIterator *
17.1.8 toArray(…) von Collection verstehen – die Gefahr einer Falle erkennen
17.1.9 Primitive Elemente in Datenstrukturen verwalten
17.2 Mengen (Sets)
17.2.1 Ein erstes Mengen-Beispiel
17.2.2 Methoden der Schnittstelle Set
17.2.3 HashSet
17.2.4 TreeSet – die sortierte Menge
17.2.5 Die Schnittstellen NavigableSet und SortedSet
17.2.6 LinkedHashSet
17.3 Java Stream-API
17.3.1 Deklaratives Programmieren
17.3.2 Interne versus externe Iteration
17.3.3 Was ist ein Stream?
17.4 Einen Stream erzeugen
17.4.1 Parallele oder sequenzielle Streams
17.5 Terminale Operationen
17.5.1 Die Anzahl der Elemente
17.5.2 Und jetzt alle – forEachXXX(…)
17.5.3 Einzelne Elemente aus dem Strom holen
17.5.4 Existenz-Tests mit Prädikaten
17.5.5 Einen Strom auf sein kleinstes bzw. größtes Element reduzieren
17.5.6 Einen Strom mit eigenen Funktionen reduzieren
17.5.7 Ergebnisse in einen Container schreiben, Teil 1: collect(…)
17.5.8 Ergebnisse in einen Container schreiben, Teil 2: Collector und Collectors
17.5.9 Ergebnisse in einen Container schreiben, Teil 3: Gruppierungen
17.5.10 Stream-Elemente in ein Array oder einen Iterator übertragen
17.6 Intermediäre Operationen
17.6.1 Element-Vorschau
17.6.2 Filtern von Elementen
17.6.3 Statusbehaftete intermediäre Operationen
17.6.4 Präfix-Operation
17.6.5 Abbildungen
17.7 Zum Weiterlesen
18 Einführung in grafische Oberflächen
18.1 GUI-Frameworks
18.1.1 Kommandozeile
18.1.2 Grafische Benutzeroberfläche
18.1.3 Abstract Window Toolkit (AWT)
18.1.4 Java Foundation Classes und Swing
18.1.5 JavaFX
18.1.6 SWT (Standard Widget Toolkit) *
18.2 Deklarative und programmierte Oberflächen
18.2.1 GUI-Beschreibungen in JavaFX
18.2.2 Deklarative GUI-Beschreibungen für Swing?
18.3 GUI-Builder
18.3.1 GUI-Builder für JavaFX
18.3.2 GUI-Builder für Swing
18.4 Mit dem Eclipse WindowBuilder zur ersten Swing-Oberfläche
18.4.1 WindowBuilder installieren
18.4.2 Mit WindowBuilder eine GUI-Klasse hinzufügen
18.4.3 Das Layoutprogramm starten
18.4.4 Grafische Oberfläche aufbauen
18.4.5 Swing-Komponenten-Klassen
18.4.6 Funktionalität geben
18.5 Grundlegendes zum Zeichnen
18.5.1 Die paint(Graphics)-Methode für das AWT-Frame
18.5.2 Die ereignisorientierte Programmierung ändert Fensterinhalte
18.5.3 Zeichnen von Inhalten auf einen JFrame
18.5.4 Auffordern zum Neuzeichnen mit repaint(…)
18.5.5 Java 2D-API
18.6 Zum Weiterlesen
19 Einführung in Dateien und Datenströme
19.1 Alte und neue Welt in java.io und java.nio
19.1.1 java.io-Paket mit File-Klasse
19.1.2 NIO.2 und das java.nio-Paket
19.1.3 java.io.File oder java.nio.*-Typen?
19.2 Dateisysteme und Pfade
19.2.1 FileSystem und Path
19.2.2 Die Utility-Klasse Files
19.3 Dateien mit wahlfreiem Zugriff
19.3.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen
19.3.2 Aus dem RandomAccessFile lesen
19.3.3 Schreiben mit RandomAccessFile
19.3.4 Die Länge des RandomAccessFile
19.3.5 Hin und her in der Datei
19.4 Basisklassen für die Ein-/Ausgabe
19.4.1 Die vier abstrakten Basisklassen
19.4.2 Die abstrakte Basisklasse OutputStream
19.4.3 Die abstrakte Basisklasse InputStream
19.4.4 Die abstrakte Basisklasse Writer
19.4.5 Die Schnittstelle Appendable *
19.4.6 Die abstrakte Basisklasse Reader
19.4.7 Die Schnittstellen Closeable, AutoCloseable und Flushable
19.5 Lesen aus Dateien und Schreiben in Dateien
19.5.1 Byteorientierte Datenströme über Files beziehen
19.5.2 Zeichenorientierte Datenströme über Files beziehen
19.5.3 Die Funktion von OpenOption bei den Files.newXXX(…)-Methoden
19.5.4 Ressourcen aus dem Modulpfad und aus JAR-Dateien laden
19.6 Zum Weiterlesen
20 Einführung ins Datenbankmanagement mit JDBC
20.1 Relationale Datenbanken und Java-Zugriffe
20.1.1 Das relationale Modell
20.1.2 Java-APIs zum Zugriff auf relationale Datenbanken
20.1.3 Die JDBC-API und Implementierungen: JDBC-Treiber
20.1.4 H2 ist das Werkzeug auf der Insel
20.2 Eine Beispielabfrage
20.2.1 Schritte zur Datenbankabfrage
20.2.2 Mit Java auf die relationale Datenbank zugreifen
20.3 Zum Weiterlesen
21 Bits und Bytes, Mathematisches und Geld
21.1 Bits und Bytes
21.1.1 Die Bit-Operatoren Komplement, Und, Oder und XOR
21.1.2 Repräsentation ganzer Zahlen in Java – das Zweierkomplement
21.1.3 Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem
21.1.4 Auswirkung der Typumwandlung auf die Bit-Muster
21.1.5 Vorzeichenlos arbeiten
21.1.6 Die Verschiebeoperatoren
21.1.7 Ein Bit setzen, löschen, umdrehen und testen
21.1.8 Bit-Methoden der Integer- und Long-Klasse
21.2 Fließkomma-Arithmetik in Java
21.2.1 Spezialwerte für Unendlich, Null, NaN
21.2.2 Standardnotation und wissenschaftliche Notation bei Fließkommazahlen *
21.2.3 Mantisse und Exponent *
21.3 Die Eigenschaften der Klasse Math
21.3.1 Attribute
21.3.2 Absolutwerte und Vorzeichen
21.3.3 Maximum/Minimum
21.3.4 Runden von Werten
21.3.5 Rest der ganzzahligen Division *
21.3.6 Division mit Rundung in Richtung negativ unendlich, alternativer Restwert *
21.3.7 Multiply-Accumulate
21.3.8 Wurzel- und Exponentialmethoden
21.3.9 Der Logarithmus *
21.3.10 Winkelmethoden *
21.3.11 Zufallszahlen
21.4 Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle *
21.4.1 Der größte und der kleinste Wert
21.4.2 Überlauf und alles ganz exakt
21.4.3 Was bitte macht eine ulp?
21.5 Zufallszahlen: Random, SecureRandom und SplittableRandom
21.5.1 Die Klasse Random
21.5.2 Random-Objekte mit dem Samen aufbauen
21.5.3 Einzelne Zufallszahlen erzeugen
21.5.4 Pseudo-Zufallszahlen in der Normalverteilung *
21.5.5 Strom von Zufallszahlen generieren *
21.5.6 Die Klasse SecureRandom *
21.5.7 SplittableRandom *
21.6 Große Zahlen *
21.6.1 Die Klasse BigInteger
21.6.2 Beispiel: Ganz lange Fakultäten mit BigInteger
21.6.3 Große Fließkommazahlen mit BigDecimal
21.6.4 Mit MathContext komfortabel die Rechengenauigkeit setzen
21.6.5 Noch schneller rechnen durch mutable Implementierungen
21.7 Mathe bitte strikt *
21.7.1 Strikte Fließkommaberechnungen mit strictfp
21.7.2 Die Klassen Math und StrictMath
21.8 Geld und Währung
21.8.1 Geldbeträge repräsentieren
21.8.2 ISO 4217
21.8.3 Währungen in Java repräsentieren
21.9 Zum Weiterlesen
22 Testen mit JUnit
22.1 Softwaretests
22.1.1 Vorgehen beim Schreiben von Testfällen
22.2 Das Test-Framework JUnit
22.2.1 Test-Driven Development und Test-First
22.2.2 Testen, implementieren, testen, implementieren, testen, freuen
22.2.3 JUnit-Tests ausführen
22.2.4 assertXXX(…)-Methoden der Klasse Assertions
22.2.5 Exceptions testen
22.2.6 Grenzen für Ausführungszeiten festlegen
22.2.7 Beschriftungen mit @DisplayName
22.2.8 Verschachtelte Tests
22.2.9 Tests ignorieren
22.2.10 Mit Methoden der Assumptions-Klasse Tests abbrechen
22.2.11 Parametrisierte Tests
22.3 Java-Assertions-Bibliotheken und AssertJ
22.3.1 AssertJ
22.4 Aufbau größerer Testfälle
22.4.1 Fixtures
22.4.2 Sammlungen von Testklassen und Klassenorganisation
22.5 Wie gutes Design das Testen ermöglicht
22.6 Dummy, Fake, Stub und Mock
22.7 JUnit-Erweiterungen, Testzusätze
22.8 Zum Weiterlesen
23 Die Werkzeuge des JDK
23.1 Übersicht
23.1.1 Aufbau und gemeinsame Schalter
23.2 Java-Quellen übersetzen
23.2.1 Der Java-Compiler des JDK
23.2.2 Alternative Compiler
23.2.3 Native Compiler
23.3 Die Java-Laufzeitumgebung
23.3.1 Schalter der JVM
23.3.2 Der Unterschied zwischen java.exe und javaw.exe
23.4 Dokumentationskommentare mit Javadoc
23.4.1 Einen Dokumentationskommentar setzen
23.4.2 Mit dem Werkzeug javadoc eine Dokumentation erstellen
23.4.3 HTML-Tags in Dokumentationskommentaren *
23.4.4 Generierte Dateien
23.4.5 Dokumentationskommentare im Überblick *
23.4.6 Javadoc und Doclets *
23.4.7 Veraltete (deprecated) Typen und Eigenschaften
23.4.8 Javadoc-Überprüfung mit DocLint
23.5 Das Archivformat JAR
23.5.1 Das Dienstprogramm jar benutzen
23.5.2 Das Manifest
23.5.3 Applikationen in JAR-Archiven starten
23.6 jlink: der Java Linker
23.7 Zum Weiterlesen
A Java SE-Module und Paketübersicht
A.1 Alle Module von Java 14
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
Java ist auch eine Insel
