Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger. 
Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Imperative Sprachkonzepte
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Eigene Klassen schreiben
6 Objektorientierte Beziehungsfragen
7 Ausnahmen müssen sein
8 Äußere.innere Klassen
9 Besondere Typen der Java SE
10 Generics<T>
11 Lambda-Ausdrücke und funktionale Programmierung
12 Architektur, Design und angewandte Objektorientierung
13 Komponenten, JavaBeans und Module
14 Die Klassenbibliothek
15 Einführung in die nebenläufige Programmierung
16 Einführung in Datenstrukturen und Algorithmen
17 Einführung in grafische Oberflächen
18 Einführung in Dateien und Datenströme
19 Einführung ins Datenbankmanagement mit JDBC
20 Einführung in <XML>
21 Testen mit JUnit
22 Bits und Bytes und Mathematisches
23 Die Werkzeuge des JDK
A Java SE-Paketübersicht
Stichwortverzeichnis


Download:

- Beispielprogramme, ca. 35,4 MB


Buch bestellen
Ihre Meinung?



Spacer
 
Java ist auch eine Insel von Christian Ullenboom

Einführung, Ausbildung, Praxis
Buch: Java ist auch eine Insel


Java ist auch eine Insel

Diese 12. Auflage des Java-Kultbuches wurde gründlich überarbeitet zur Java-Version 8. Besonders Java-Einsteiger, Studenten und Umsteiger profitieren von diesem umfassenden Standardwerk. Die Einführung in die Sprache Java ist anschaulich und konsequent praxisorientiert.



Die »Insel« lässt auch in dieser Auflage keine Wünsche offen: Neben der Behandlung der Sprache Java gibt es kompakte Einführungen in Spezialthemen.



Nutzen Sie die HTML-Version der Insel (inkl. Syntax-Highlighting) zum Reinschnuppern oder als immer verfügbare Ergänzung zu Ihrem Buch.



 

Die gedruckte Version des Buches erhalten Sie in unserem Online-Shop – versandkostenfrei innerhalb Deutschlands und Österreichs.

Zum Online-Shop

Inhaltsverzeichnis

Vorwort

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

A   Java SE-Paketübersicht

 

Zum Seitenanfang

Stichwortverzeichnis

 


Ihr Kommentar

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

>> Zum Feedback-Formular
 

 

 


Copyright © Rheinwerk Verlag GmbH 2017

Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

 

[Rheinwerk Computing]



Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de