Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
Liebe Leser!
Inhaltsverzeichnis
Vorwort
Über dieses Buch
Vorwort zur 12. Auflage
Vorwort zur 11. Auflage
1 Java ist auch eine Sprache
1.1 Historischer Hintergrund
1.2 Warum Java gut ist – die zentralen Eigenschaften
1.2.1 Bytecode
1.2.2 Ausführung des Bytecodes durch eine virtuelle Maschine
1.2.3 Plattformunabhängigkeit
1.2.4 Java als Sprache, Laufzeitumgebung und Standardbibliothek
1.2.5 Objektorientierung in Java
1.2.6 Java ist verbreitet und bekannt
1.2.7 Java ist schnell – Optimierung und Just-in-time-Compilation
1.2.8 Das Java-Security-Modell
1.2.9 Zeiger und Referenzen
1.2.10 Bring den Müll raus, Garbage-Collector!
1.2.11 Ausnahmebehandlung
1.2.12 Angebot an Bibliotheken und Werkzeugen
1.2.13 Einfache Syntax der Programmiersprache Java
1.2.14 Java ist Open Source
1.2.15 Wofür sich Java weniger eignet
1.2.16 Java im Vergleich zu anderen Sprachen *
1.2.17 Java und das Web, Applets und JavaFX
1.2.18 Features, Enhancements (Erweiterungen) und ein JSR
1.2.19 Die Entwicklung von Java und seine Zukunftsaussichten
1.3 Java-Plattformen: Java SE, Java EE, Java ME und Java Card
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.4.4 JDK/JRE deinstallieren
1.4.5 JDK unter Linux installieren
1.4.6 JDK unter Max OS X installieren
1.5 Das erste Programm compilieren und testen
1.5.1 Compilertest
1.5.2 Ein Quadratzahlen-Programm
1.5.3 Der Compilerlauf
1.5.4 Die Laufzeitumgebung
1.5.5 Häufige Compiler- und Interpreter-Probleme
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 entpacken und starten
1.7.2 Das erste Projekt anlegen
1.7.3 Verzeichnisstruktur für Java-Projekte *
1.7.4 Eine Klasse hinzufügen
1.7.5 Übersetzen und ausführen
1.7.6 Projekt einfügen, Workspace für die Programme wechseln
1.7.7 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.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(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 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 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.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 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 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 Der Zusammenhang von new, Heap und Garbage-Collector
3.4.3 Deklarieren von Referenzvariablen
3.4.4 Jetzt mach mal ’nen Punkt: Zugriff auf Objektattribute und -methoden
3.4.5 Überblick über Point-Methoden
3.4.6 Konstruktoren nutzen
3.5 ZZZZZnake
3.6 Pakete schnüren, Imports und Kompilationseinheiten
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
3.6.6 Die package-Deklaration
3.6.7 Unbenanntes Paket (default package)
3.6.8 Klassen mit gleichen Namen in unterschiedlichen Paketen *
3.6.9 Kompilationseinheit (Compilation Unit)
3.6.10 Statischer Import *
3.7 Mit Referenzen arbeiten, Identität und Gleichheit (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 Gleichheit (Gleichwertigkeit) 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 Array-Fehler
3.8.8 Arrays als Methodenparameter
3.8.9 Vorinitialisierte Arrays
3.8.10 Die erweiterte for-Schleife
3.8.11 Arrays mit nichtprimitiven Elementen
3.8.12 Methode mit variabler Argumentanzahl (Vararg)
3.8.13 Mehrdimensionale Arrays *
3.8.14 Nichtrechteckige Arrays *
3.8.15 Die Wahrheit über die Array-Initialisierung *
3.8.16 Mehrere Rückgabewerte *
3.8.17 Klonen kann sich lohnen – Arrays vermehren *
3.8.18 Array-Inhalte 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(int) *
3.10 Grundlagen von Annotationen und Generics
3.10.1 Generics
3.10.2 Annotationen
3.10.3 Annotationstypen aus java.lang
3.10.4 @Deprecated
3.10.5 @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 Java-Versionen gehen mit Unicode-Standard Hand in Hand *
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 Leer-String
4.4.4 Zugriff auf ein bestimmtes Zeichen mit charAt(int)
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 String-Teile extrahieren
4.4.9 Strings anhängen, zusammenfügen, Groß-/Kleinschreibung und Leerraum
4.4.10 Gesucht, gefunden, ersetzt
4.4.11 String-Objekte mit Konstruktoren erzeugen *
4.5 Veränderbare Zeichenketten mit StringBuilder und StringBuffer
4.5.1 Anlegen von StringBuilder-/StringBuffer-Objekten
4.5.2 StringBuilder/StringBuffer in andere Zeichenkettenformate konvertieren
4.5.3 Zeichen(folgen) erfragen
4.5.4 Daten anhängen
4.5.5 Zeichen(folgen) setzen, löschen und umdrehen
4.5.6 Länge und Kapazität eines StringBuilder-/StringBuffer-Objekts *
4.5.7 Vergleichen von String mit StringBuilder und StringBuffer
4.5.8 hashCode() bei StringBuilder/StringBuffer *
4.6 CharSequence als Basistyp
4.7 Konvertieren zwischen Primitiven und Strings
4.7.1 Unterschiedliche Typen in String-Repräsentationen konvertieren
4.7.2 String-Inhalt in einen primitiven Wert konvertieren
4.7.3 String-Repräsentation im Format Binär, Hex, Oktal *
4.7.4 parseXXX(…)- und printXXX()-Methoden in DatatypeConverter *
4.8 Strings zusammenhängen (konkatenieren)
4.8.1 Strings mit StringJoiner
4.9 Zerlegen von Zeichenketten
4.9.1 Splitten von Zeichenketten mit split(…)
4.9.2 Yes we can, yes we scan – die Klasse Scanner
4.10 Ausgaben formatieren
4.10.1 Formatieren und Ausgeben mit format()
4.11 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 Eine für alle – statische Methode 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 statische finale Variablen
5.4.2 Typunsichere Aufzählungen
5.4.3 Aufzählungstypen: Typsichere Aufzählungen mit enum
5.5 Objekte anlegen und zerstören
5.5.1 Konstruktoren schreiben
5.5.2 Verwandtschaft von Methode und Konstruktor
5.5.3 Der vorgegebene Konstruktor (default constructor)
5.5.4 Parametrisierte und überladene Konstruktoren
5.5.5 Copy-Konstruktor
5.5.6 Einen anderen Konstruktor der gleichen Klasse mit this(…) aufrufen
5.5.7 Ihr fehlt uns nicht – der Garbage-Collector
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 Zum Weiterlesen
6 Objektorientierte Beziehungsfragen
6.1 Assoziationen zwischen Objekten
6.1.1 Unidirektionale 1:1-Beziehung
6.1.2 Zwei Freunde müsst ihr werden – bidirektionale 1:1-Beziehungen
6.1.3 Unidirektionale 1:n-Beziehung
6.2 Vererbung
6.2.1 Vererbung in Java
6.2.2 Spielobjekte modellieren
6.2.3 Die implizite Basisklasse java.lang.Object
6.2.4 Einfach- und Mehrfachvererbung *
6.2.5 Die Sichtbarkeit protected
6.2.6 Konstruktoren in der Vererbung und super(…)
6.3 Typen in Hierarchien
6.3.1 Automatische und explizite Typumwandlung
6.3.2 Das Substitutionsprinzip
6.3.3 Typen mit dem instanceof-Operator testen
6.4 Methoden überschreiben
6.4.1 Methoden in Unterklassen mit neuem Verhalten ausstatten
6.4.2 Mit super an die Eltern
6.4.3 Finale Klassen und finale Methoden
6.4.4 Kovariante Rückgabetypen
6.4.5 Array-Typen und Kovarianz *
6.5 Drum prüfe, wer sich ewig dynamisch bindet
6.5.1 Gebunden an toString()
6.5.2 Implementierung von System.out.println(Object)
6.5.3 Nicht dynamisch gebunden bei privaten, statischen und finalen Methoden
6.5.4 Dynamisch gebunden auch bei Konstruktoraufrufen *
6.5.5 Eine letzte Spielerei mit Javas dynamischer Bindung und überdeckten Attributen *
6.6 Abstrakte Klassen und abstrakte Methoden
6.6.1 Abstrakte Klassen
6.6.2 Abstrakte Methoden
6.7 Schnittstellen
6.7.1 Schnittstellen deklarieren
6.7.2 Implementieren von Schnittstellen
6.7.3 Ein Polymorphie-Beispiel mit Schnittstellen
6.7.4 Die Mehrfachvererbung bei Schnittstellen
6.7.5 Keine Kollisionsgefahr bei Mehrfachvererbung *
6.7.6 Erweitern von Interfaces – Subinterfaces
6.7.7 Konstantendeklarationen bei Schnittstellen
6.7.8 Statische ausprogrammierte Methoden in Schnittstellen
6.7.9 Erweitern von Schnittstellen
6.7.10 Default-Methoden
6.7.11 Erweiterte Schnittstellen deklarieren und nutzen
6.7.12 Erweiterte Schnittstellen, Mehrfachvererbung und Mehrdeutigkeiten *
6.7.13 Bausteine bilden mit Default-Methoden *
6.7.14 Initialisierung von Schnittstellenkonstanten *
6.7.15 Markierungsschnittstellen *
6.7.16 (Abstrakte) Klassen und Schnittstellen im Vergleich
6.8 Zum Weiterlesen
7 Ausnahmen müssen sein
7.1 Problembereiche einzäunen
7.1.1 Exceptions in Java mit try und catch
7.1.2 Eine NumberFormatException auffangen
7.1.3 Eigenschaften vom Exception-Objekt
7.1.4 Wiederholung abgebrochener Bereiche *
7.1.5 Mehrere Ausnahmen auffangen
7.1.6 Ablauf einer Ausnahmesituation
7.1.7 throws im Methodenkopf angeben
7.1.8 Abschlussbehandlung mit finally
7.2 RuntimeException muss nicht aufgefangen werden
7.2.1 Beispiele für RuntimeException-Klassen
7.2.2 Kann man abfangen, muss man aber nicht
7.3 Die Klassenhierarchie der Fehler
7.3.1 Die Exception-Hierarchie
7.3.2 Oberausnahmen auffangen
7.3.3 Schon gefangen?
7.3.4 Alles geht als Exception durch
7.3.5 Zusammenfassen gleicher catch-Blöcke mit dem multi-catch
7.4 Harte Fehler – Error *
7.5 Auslösen eigener Exceptions
7.5.1 Mit throw Ausnahmen auslösen
7.5.2 Vorhandene Runtime-Fehlertypen kennen und nutzen
7.5.3 Parameter testen und gute Fehlermeldungen
7.5.4 Neue Exception-Klassen deklarieren
7.5.5 Eigene Ausnahmen als Unterklassen von Exception oder RuntimeException?
7.5.6 Ausnahmen abfangen und weiterleiten *
7.5.7 Aufruf-Stack von Ausnahmen verändern *
7.5.8 Präzises rethrow *
7.5.9 Geschachtelte Ausnahmen *
7.6 Automatisches Ressourcen-Management (try mit Ressourcen)
7.6.1 try mit Ressourcen
7.6.2 Die Schnittstelle AutoCloseable
7.6.3 Mehrere Ressourcen nutzen
7.6.4 try mit Ressourcen auf null-Ressourcen
7.6.5 Unterdrückte Ausnahmen *
7.7 Besonderheiten bei der Ausnahmebehandlung *
7.7.1 Rückgabewerte bei ausgelösten Ausnahmen
7.7.2 Ausnahmen und Rückgaben verschwinden – das Duo return und finally
7.7.3 throws bei überschriebenen Methoden
7.7.4 Nicht erreichbare catch-Klauseln
7.8 Den Stack-Trace erfragen *
7.8.1 StackTraceElement
7.8.2 printStackTrace(…)
7.8.3 StackTraceElement vom Thread erfragen
7.9 Assertions *
7.9.1 Assertions in eigenen Programmen nutzen
7.9.2 Assertions aktivieren
7.10 Zum Weiterlesen
8 Äußere.innere Klassen
8.1 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen
8.2 Statische innere Klassen und Schnittstellen
8.3 Mitglieds- oder Elementklassen
8.3.1 Exemplare innerer Klassen erzeugen
8.3.2 Die this-Referenz
8.3.3 Vom Compiler generierte Klassendateien *
8.3.4 Erlaubte Modifizierer bei äußeren und inneren Klassen
8.3.5 Innere Klassen greifen auf private Eigenschaften zu
8.4 Lokale Klassen
8.4.1 Beispiel mit eigener Klassendeklaration
8.4.2 Lokale Klasse für einen Timer nutzen
8.5 Anonyme innere Klassen
8.5.1 Nutzung einer anonymen inneren Klasse für den Timer
8.5.2 Umsetzung innerer anonymer Klassen *
8.5.3 Konstruktoren innerer anonymer Klassen
8.6 Zugriff auf lokale Variablen aus lokalen inneren und anonymen Klassen *
8.7 this in Unterklassen *
8.8 Zum Weiterlesen
9 Besondere Typen der Java SE
9.1 Object ist die Mutter aller Klassen
9.1.1 Klassenobjekte
9.1.2 Objektidentifikation mit toString()
9.1.3 Objektgleichheit mit equals(…) und Identität
9.1.4 Klonen eines Objekts mit clone() *
9.1.5 Hashwerte über hashCode() liefern *
9.1.6 System.identityHashCode(…) und das Problem der nicht eindeutigen Objektverweise *
9.1.7 Aufräumen mit finalize() *
9.1.8 Synchronisation *
9.2 Die Utility-Klasse java.util.Objects
9.3 Vergleichen von Objekten
9.3.1 Natürlich geordnet oder nicht?
9.3.2 Die Schnittstelle Comparable
9.3.3 Die Schnittstelle Comparator
9.3.4 Rückgabewerte kodieren die Ordnung
9.3.5 Statische und Default-Methoden in Comparator
9.4 Wrapper-Klassen und Autoboxing
9.4.1 Wrapper-Objekte erzeugen
9.4.2 Konvertierungen in eine String-Repräsentation
9.4.3 Von einer String-Repräsentation parsen
9.4.4 Die Basisklasse Number für numerische Wrapper-Objekte
9.4.5 Vergleiche durchführen mit compare(…), compareTo(…), equals(…) und Hashwerten
9.4.6 Statische Reduzierungsmethoden in Wrapper-Klassen
9.4.7 Die Größe eines primitiven Typs in den Wrapper-Konstanten SIZE und BYTES
9.4.8 Behandeln von vorzeichenlosen Zahlen *
9.4.9 Die Klasse Integer
9.4.10 Die Klassen Double und Float für Fließkommazahlen
9.4.11 Die Long-Klasse
9.4.12 Die Boolean-Klasse
9.4.13 Autoboxing: Boxing und Unboxing
9.5 Iterator, Iterable *
9.5.1 Die Schnittstelle Iterator
9.5.2 Wer den Iterator liefert
9.5.3 Die Schnittstelle Iterable
9.5.4 Erweitertes for und Iterable
9.5.5 Interne Iteration
9.5.6 Einen eigenen Iterable implementieren *
9.6 Die Spezial-Oberklasse Enum
9.6.1 Methoden auf Enum-Objekten
9.6.2 Aufzählungen mit eigenen Methoden und Initialisierern *
9.6.3 enum mit eigenen Konstruktoren *
9.7 Zum Weiterlesen
10 Generics<T>
10.1 Einführung in Java Generics
10.1.1 Mensch versus Maschine – Typprüfung des Compilers und der Laufzeitumgebung
10.1.2 Taschen
10.1.3 Generische Typen deklarieren
10.1.4 Generics nutzen
10.1.5 Diamonds are forever
10.1.6 Generische Schnittstellen
10.1.7 Generische Methoden/Konstruktoren und Typ-Inferenz
10.2 Umsetzen der Generics, Typlöschung und Raw-Types
10.2.1 Realisierungsmöglichkeiten
10.2.2 Typlöschung (Type Erasure)
10.2.3 Probleme der Typlöschung
10.2.4 Raw-Type
10.3 Einschränken der Typen über Bounds
10.3.1 Einfache Einschränkungen mit extends
10.3.2 Weitere Obertypen mit &
10.4 Typparameter in der throws-Klausel *
10.4.1 Deklaration einer Klasse mit Typvariable <E extends Exception>
10.4.2 Parametrisierter Typ bei Typvariable <E extends Exception>
10.5 Generics und Vererbung, Invarianz
10.5.1 Arrays sind kovariant
10.5.2 Generics sind nicht kovariant, sondern invariant
10.5.3 Wildcards mit ?
10.5.4 Bounded Wildcards
10.5.5 Bounded-Wildcard-Typen und Bounded-Typvariablen
10.5.6 Das LESS-Prinzip
10.5.7 Enum<E extends Enum<E>> *
10.6 Konsequenzen der Typlöschung: Typ-Token, Arrays und Brücken *
10.6.1 Typ-Token
10.6.2 Super-Type-Token
10.6.3 Generics und Arrays
10.6.4 Brückenmethoden
10.6.5 Zum Weiterlesen
11 Lambda-Ausdrücke und funktionale Programmierung
11.1 Code = Daten
11.2 Funktionale Schnittstellen und Lambda-Ausdrücke im Detail
11.2.1 Funktionale Schnittstellen
11.2.2 Typ eines Lambda-Ausdrucks ergibt sich durch Zieltyp
11.2.3 Annotation @FunctionalInterface
11.2.4 Syntax für Lambda-Ausdrücke
11.2.5 Die Umgebung der Lambda-Ausdrücke und Variablenzugriffe
11.2.6 Ausnahmen in Lambda-Ausdrücken
11.2.7 Klassen mit einer abstrakten Methode als funktionale Schnittstelle? *
11.3 Methodenreferenz
11.3.1 Varianten von Methodenreferenzen
11.4 Konstruktorreferenz
11.4.1 Standard- und parametrisierte Konstruktoren
11.4.2 Nützliche vordefinierte Schnittstellen für Konstruktorreferenzen
11.5 Implementierung von Lambda-Ausdrücken *
11.6 Funktionale Programmierung mit Java
11.6.1 Programmierparadigmen: imperativ oder deklarativ
11.6.2 Funktionale Programmierung und funktionale Programmiersprachen
11.6.3 Funktionale Programmierung in Java am Beispiel vom Comparator
11.6.4 Lambda-Ausdrücke als Funktionen sehen
11.7 Funktionale Schnittstelle aus dem java.util.function-Paket
11.7.1 Blöcke mit Code und die funktionale Schnittstelle java.util.function.Consumer
11.7.2 Supplier
11.7.3 Prädikate und java.util.function.Predicate
11.7.4 Funktionen und die allgemeine funktionale Schnittstelle java.util.function.Function
11.7.5 Ein bisschen Bi …
11.7.6 Funktionale Schnittstellen mit Primitiven
11.8 Optional ist keine Nullnummer
11.8.1 Optional-Typ
11.8.2 Primitive optionale Typen
11.8.3 Erstmal funktional mit Optional
11.9 Was ist jetzt so funktional?
11.10 Zum Weiterlesen
12 Architektur, Design und angewandte Objektorientierung
12.1 Architektur, Design und Implementierung
12.2 Design-Pattern (Entwurfsmuster)
12.2.1 Motivation für Design-Pattern
12.2.2 Singleton
12.2.3 Fabrikmethoden
12.2.4 Das Beobachter-Pattern (Observer/Observable)
12.2.5 Ereignisse über Listener
12.3 Zum Weiterlesen
13 Komponenten, JavaBeans und Module
13.1 JavaBeans
13.1.1 Properties (Eigenschaften)
13.1.2 Einfache Eigenschaften
13.1.3 Indizierte Eigenschaften
13.1.4 Gebundene Eigenschaften und PropertyChangeListener
13.1.5 Veto-Eigenschaften – dagegen!
13.2 JavaFX Properties
13.2.1 javafx.beans-Paket mit XXXProperty-Klassen
13.2.2 Property-Veränderungen registrieren
13.2.3 Beans-Binding
13.2.4 Property-Schnittstelle und bindXXX(…)-Methoden
13.2.5 XXXProperty-Beziehungen (für Typ-Fetischisten) *
13.2.6 Ausblick
13.3 Klassenlader (Class Loader) und Klassenpfad
13.3.1 Klassenladen auf Abruf
13.3.2 JAR-Dateien
13.3.3 Woher die kleinen Klassen kommen: die Suchorte und spezielle Klassenlader
13.3.4 Setzen des Klassenpfades
13.4 Zum Weiterlesen
14 Die Klassenbibliothek
14.1 Die Java-Klassenphilosophie
14.1.1 Übersicht über die Pakete der Standardbibliothek
14.1.2 Compact-Profile
14.2 Sprachen der Länder
14.2.1 Sprachen und Regionen über Locale-Objekte
14.3 Die Klasse Date
14.3.1 Objekte erzeugen und Methoden nutzen
14.3.2 Date-Objekte sind nicht immutable
14.4 Calendar und GregorianCalendar
14.4.1 Die abstrakte Klasse Calendar
14.4.2 Calendar nach Date und Millisekunden fragen
14.4.3 Abfragen und Setzen von Datumselementen über Feldbezeichner
14.4.4 Kalender-Exemplare bauen über den Calendar.Builder
14.4.5 Der gregorianische Kalender
14.4.6 Date-Time-API
14.4.7 Menschenzeit und Maschinenzeit
14.5 Die Utility-Klasse System und Properties
14.5.1 Systemeigenschaften der Java-Umgebung
14.5.2 Zeilenumbruchzeichen, line.separator
14.5.3 Eigene Properties von der Konsole aus setzen *
14.5.4 Umgebungsvariablen des Betriebssystems *
14.5.5 Einfache Zeitmessung und Profiling *
14.6 Einfache Benutzereingaben
14.6.1 Grafischer Eingabedialog über JOptionPane
14.6.2 Geschützte Passwort-Eingaben mit der Klasse Console *
14.7 Benutzereinstellungen *
14.7.1 Benutzereinstellungen mit der Preferences-API
14.7.2 Einträge einfügen, auslesen und löschen
14.7.3 Auslesen der Daten und Schreiben in einem anderen Format
14.7.4 Auf Ereignisse horchen
14.7.5 Zugriff auf die gesamte Windows-Registry
14.8 Zum Weiterlesen
15 Einführung in die nebenläufige Programmierung
15.1 Nebenläufigkeit und Parallelität
15.1.1 Multitasking, Prozesse, Threads
15.1.2 Threads und Prozesse
15.1.3 Wie nebenläufige Programme die Geschwindigkeit steigern können
15.1.4 Was Java für Nebenläufigkeit alles bietet
15.2 Threads erzeugen
15.2.1 Threads über die Schnittstelle Runnable implementieren
15.2.2 Thread mit Runnable starten
15.2.3 Die Klasse Thread erweitern
15.3 Thread-Eigenschaften und Zustände
15.3.1 Der Name eines Threads
15.3.2 Wer bin ich?
15.3.3 Schläfer gesucht
15.3.4 Mit yield() auf Rechenzeit verzichten
15.3.5 Der Thread als Dämon
15.3.6 Freiheit für den Thread – das Ende
15.3.7 Einen Thread höflich mit Interrupt beenden
15.3.8 UncaughtExceptionHandler für unbehandelte Ausnahmen
15.4 Der Ausführer (Executor) kommt
15.4.1 Die Schnittstelle Executor
15.4.2 Glücklich in der Gruppe – die Thread-Pools
15.4.3 Threads mit Rückgabe über Callable
15.4.4 Mehrere Callables abarbeiten
15.4.5 ScheduledExecutorService für wiederholende Ausgaben und Zeitsteuerungen nutzen
15.5 Synchronisation über kritische Abschnitte
15.5.1 Gemeinsam genutzte Daten
15.5.2 Probleme beim gemeinsamen Zugriff und kritische Abschnitte
15.5.3 Punkte nebenläufig initialisieren
15.5.4 Kritische Abschnitte schützen
15.5.5 Kritische Abschnitte mit ReentrantLock schützen
15.5.6 Synchronisieren mit synchronized
15.5.7 Mit synchronized synchronisierte Blöcke
15.5.8 Dann machen wir doch gleich alles synchronisiert!
15.5.9 Lock-Freigabe im Fall von Exceptions
15.5.10 Deadlocks
15.6 Zum Weiterlesen
16 Einführung in Datenstrukturen und Algorithmen
16.1 Listen
16.1.1 Erstes Listenbeispiel
16.1.2 Auswahlkriterium ArrayList oder LinkedList
16.1.3 Die Schnittstelle List
16.1.4 ArrayList
16.1.5 LinkedList
16.1.6 Der Feld-Adapter Arrays.asList(…)
16.1.7 toArray(…) von Collection verstehen – die Gefahr einer Falle erkennen
16.1.8 Primitive Elemente in Datenstrukturen verwalten
16.2 Mengen (Sets)
16.2.1 Ein erstes Mengenbeispiel
16.2.2 Methoden der Schnittstelle Set
16.2.3 HashSet
16.2.4 TreeSet – die sortierte Menge
16.2.5 Die Schnittstellen NavigableSet und SortedSet
16.2.6 LinkedHashSet
16.3 Assoziative Speicher
16.3.1 Die Klassen HashMap und TreeMap
16.3.2 Einfügen und Abfragen des Assoziativspeichers
16.3.3 Über die Bedeutung von equals(…) und hashCode() bei Elementen
16.3.4 Eigene Objekte hashen
16.3.5 LinkedHashMap und LRU-Implementierungen
16.3.6 IdentityHashMap
16.3.7 Das Problem veränderter Elemente
16.3.8 Aufzählungen und Ansichten des Assoziativspeichers
16.3.9 Die Properties-Klasse
16.4 Mit einem Iterator durch die Daten wandern
16.5 Algorithmen in Collections
16.5.1 Die Bedeutung von Ordnung mit Comparator und Comparable
16.5.2 Sortieren
16.5.3 Den größten und kleinsten Wert einer Collection finden
16.5.4 Nichtänderbare Datenstrukturen, immutable oder nur lesen?
16.5.5 Null Object Pattern und leere Sammlungen/Iteratoren zurückgeben
16.5.6 Echte typsichere Container
16.5.7 Mit der Halbierungssuche nach Elementen fahnden
16.6 Zum Weiterlesen
17 Einführung in grafische Oberflächen
17.1 GUI-Frameworks
17.1.1 Kommandozeile
17.1.2 Grafische Benutzeroberfläche
17.1.3 Abstract Window Toolkit (AWT)
17.1.4 Java Foundation Classes und Swing
17.1.5 JavaFX
17.1.6 SWT (Standard Widget Toolkit) *
17.2 Deklarative und programmierte Oberflächen
17.2.1 GUI-Beschreibungen in JavaFX
17.2.2 Deklarative GUI-Beschreibungen für Swing?
17.3 GUI-Builder
17.3.1 GUI-Builder für JavaFX
17.3.2 GUI-Builder für Swing
17.4 Aller Swing-Anfang – Fenster zur Welt
17.4.1 Eine Uhr, bei der die Zeit nie vergeht
17.4.2 Swing-Fenster mit javax.swing.JFrame darstellen
17.4.3 Mit add(…) auf den Container
17.4.4 Fenster schließbar machen – setDefaultCloseOperation(int)
17.4.5 Sichtbarkeit des Fensters
17.4.6 Größe und Position des Fensters verändern
17.5 Beschriftungen (JLabel)
17.5.1 Mehrzeiliger Text, HTML in der Darstellung
17.6 Es tut sich was – Ereignisse beim AWT
17.6.1 Die Ereignisquellen und Horcher (Listener) von Swing
17.6.2 Listener implementieren
17.6.3 Listener bei dem Ereignisauslöser anmelden/abmelden
17.6.4 Adapterklassen nutzen
17.6.5 Innere Mitgliedsklassen und innere anonyme Klassen
17.6.6 Aufrufen der Listener im AWT-Event-Thread
17.7 Schaltflächen
17.7.1 Normale Schaltflächen (JButton)
17.7.2 Der aufmerksame ActionListener
17.7.3 Schaltflächen-Ereignisse vom Typ ActionEvent
17.7.4 Basisklasse AbstractButton
17.7.5 Wechselknopf (JToggleButton)
17.8 Alles Auslegungssache – die Layoutmanager
17.8.1 Übersicht über Layoutmanager
17.8.2 Zuweisen eines Layoutmanagers
17.8.3 Im Fluss mit FlowLayout
17.8.4 BoxLayout
17.8.5 Mit BorderLayout in alle Himmelsrichtungen
17.8.6 Rasteranordnung mit GridLayout
17.8.7 Weitere Layoutmanager
17.9 Textkomponenten
17.9.1 Text in einer Eingabezeile
17.9.2 Die Oberklasse der Textkomponenten (JTextComponent)
17.9.3 Geschützte Eingaben (JPasswordField)
17.9.4 Validierende Eingabefelder (JFormattedTextField)
17.9.5 Einfache mehrzeilige Textfelder (JTextArea)
17.10 Grundlegendes zum Zeichnen
17.10.1 Die paint(Graphics)-Methode für den AWT-Frame
17.10.2 Die ereignisorientierte Programmierung ändert Fensterinhalte
17.10.3 Zeichnen von Inhalten auf einen JFrame
17.10.4 Auffordern zum Neuzeichnen mit repaint(…)
17.10.5 Java 2D-API
17.11 Zum Weiterlesen
18 Einführung in Dateien und Datenströme
18.1 API für Dateien, Verzeichnisse und Verzeichnissysteme
18.1.1 java.io-Paket mit File-Klasse
18.1.2 NIO.2 und java.nio-Paket
18.2 Datei und Verzeichnis
18.2.1 FileSystem und Path
18.2.2 Die Utility-Klasse Files
18.2.3 Dateien kopieren und verschieben
18.2.4 Neue Dateien, Verzeichnisse, symbolische Verknüpfungen anlegen und löschen
18.3 Dateien mit wahlfreiem Zugriff
18.3.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen
18.3.2 Aus dem RandomAccessFile lesen
18.3.3 Schreiben mit RandomAccessFile
18.3.4 Die Länge des RandomAccessFile
18.3.5 Hin und her in der Datei
18.4 Stream-Klassen für Bytes und Zeichen
18.4.1 Lesen aus Dateien und Schreiben in Dateien
18.4.2 Byteorientierte Datenströme über Files beziehen
18.4.3 Zeichenorientierte Datenströme über Files beziehen
18.4.4 Funktion von OpenOption bei den Files.newXXX(…)-Methoden
18.4.5 Ressourcen aus dem Klassenpfad und aus JAR-Archiven laden
18.4.6 Die Schnittstellen Closeable, AutoCloseable und Flushable
18.5 Basisklassen für die Ein-/Ausgabe
18.5.1 Die abstrakten Basisklassen
18.5.2 Übersicht über Ein-/Ausgabeklassen
18.5.3 Die abstrakte Basisklasse OutputStream
18.5.4 Die abstrakte Basisklasse InputStream
18.5.5 Die abstrakte Basisklasse Writer
18.5.6 Die abstrakte Basisklasse Reader
18.6 Datenströme filtern und verketten
18.6.1 Streams als Filter verketten (verschachteln)
18.6.2 Gepufferte Ausgaben mit BufferedWriter und BufferedOutputStream
18.6.3 Gepufferte Eingaben mit BufferedReader/BufferedInputStream
18.7 Vermittler zwischen Byte-Streams und Unicode-Strömen
18.7.1 Datenkonvertierung durch den OutputStreamWriter
18.7.2 Automatische Konvertierungen mit dem InputStreamReader
18.8 Zum Weiterlesen
19 Einführung ins Datenbankmanagement mit JDBC
19.1 Relationale Datenbanken
19.1.1 Das relationale Modell
19.2 Datenbanken und Tools
19.2.1 HSQLDB
19.2.2 Eclipse Data Tools Platform (DTP) zum Durchschauen von Datenbanken
19.3 JDBC und Datenbanktreiber
19.4 Eine Beispielabfrage
19.4.1 Ein Client für die HSQLDB-Datenbank
19.5 Zum Weiterlesen
20 Einführung in <XML>
20.1 Auszeichnungssprachen
20.1.1 Die Standard Generalized Markup Language (SGML)
20.1.2 Extensible Markup Language (XML)
20.2 Eigenschaften von XML-Dokumenten
20.2.1 Elemente und Attribute
20.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten
20.2.3 Schema – die moderne Alternative zu DTD
20.2.4 Namensraum (Namespace)
20.2.5 XML-Applikationen *
20.3 Die Java-APIs für XML
20.3.1 Das Document Object Model (DOM)
20.3.2 Simple API for XML Parsing (SAX)
20.3.3 Pull-API StAX
20.3.4 Java Document Object Model (JDOM)
20.3.5 JAXP als Java-Schnittstelle zu XML
20.3.6 DOM-Bäume einlesen mit JAXP *
20.4 Java Architecture for XML Binding (JAXB)
20.4.1 Bean für JAXB aufbauen
20.4.2 Utility-Klasse JAXB
20.4.3 Ganze Objektgraphen schreiben und lesen
20.4.4 JAXBContext und Marshaller/Unmarshaller nutzen
20.4.5 Validierung
20.4.6 Weitere JAXB-Annotationen *
20.4.7 Beans aus XML-Schema-Datei generieren
20.5 XML-Dateien mit JDOM verarbeiten
20.5.1 JDOM beziehen
20.5.2 Paketübersicht *
20.5.3 Die Document-Klasse
20.5.4 Eingaben aus der Datei lesen
20.5.5 Das Dokument im XML-Format ausgeben
20.5.6 Der Dokumenttyp *
20.5.7 Elemente
20.5.8 Zugriff auf Elementinhalte
20.5.9 Liste mit Unterelementen erzeugen *
20.5.10 Neue Elemente einfügen und ändern
20.5.11 Attributinhalte lesen und ändern
20.5.12 XPath
20.6 Zum Weiterlesen
21 Testen mit JUnit
21.1 Softwaretests
21.1.1 Vorgehen beim Schreiben von Testfällen
21.2 Das Test-Framework JUnit
21.2.1 Test-Driven Development und Test-First
21.2.2 Testen, implementieren, testen, implementieren, testen, freuen
21.2.3 JUnit-Tests ausführen
21.2.4 assertXXX(…)-Methoden der Klasse Assert
21.2.5 Matcher-Objekte und Hamcrest
21.2.6 Exceptions testen
21.2.7 Tests ignorieren und Grenzen für Ausführungszeiten festlegen
21.2.8 Mit Methoden der Assume-Klasse Tests abbrechen
21.3 Wie gutes Design das Testen ermöglicht
21.4 Aufbau größerer Testfälle
21.4.1 Fixtures
21.4.2 Sammlungen von Testklassen und Klassenorganisation
21.5 Dummy, Fake, Stub und Mock
21.6 JUnit-Erweiterungen, Testzusätze
21.7 Zum Weiterlesen
22 Bits und Bytes und Mathematisches
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 Attribute
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 Richtung negativ unendlich, alternativer Restwert *
22.3.7 Wurzel- und Exponentialmethoden
22.3.8 Der Logarithmus *
22.3.9 Winkelmethoden *
22.3.10 Zufallszahlen
22.4 Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle *
22.4.1 Der größte und der kleinste Wert
22.4.2 Überlauf
22.4.3 Was bitte macht eine ulp?
22.5 Zufallszahlen: Random, SecureRandom, 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.7 Mathe bitte strikt *
22.7.1 Strikte Fließkommaberechnungen mit strictfp
22.7.2 Die Klassen Math und StrictMath
22.8 Zum Weiterlesen
23 Die Werkzeuge des JDK
23.1 Java-Quellen übersetzen
23.1.1 Java-Compiler vom JDK
23.1.2 Alternative Compiler
23.1.3 Native Compiler
23.1.4 Java-Programme in ein natives ausführbares Programm einpacken
23.2 Die Java-Laufzeitumgebung
23.2.1 Schalter der JVM
23.2.2 Der Unterschied zwischen java.exe und javaw.exe
23.3 Mit RoboVM geht’s für Java in das iOS-Land *
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.5.4 Pack200-Format *
23.6 Zum Weiterlesen
A Java SE-Paketübersicht
Stichwortverzeichnis
Rechtliche Hinweise
Autorenseite
← Prev
Back
Next →
← Prev
Back
Next →