Rheinwerk Computing < openbook >


 
Inhaltsverzeichnis
Materialien
Vorwort
1 Java ist auch eine Sprache
2 Imperative Sprachkonzepte
3 Klassen und Objekte
4 Arrays und ihre Anwendungen
5 Der Umgang mit Zeichenketten
6 Eigene Klassen schreiben
7 Objektorientierte Beziehungsfragen
8 Ausnahmen müssen sein
9 Geschachtelte Typen
10 Besondere Typen der Java SE
11 Generics<T>
12 Lambda-Ausdrücke und funktionale Programmierung
13 Architektur, Design und angewandte Objektorientierung
14 Java Platform Module System
15 Die Klassenbibliothek
16 Einführung in die nebenläufige Programmierung
17 Einführung in Datenstrukturen und Algorithmen
18 Einführung in grafische Oberflächen
19 Einführung in Dateien und Datenströme
20 Einführung ins Datenbankmanagement mit JDBC
21 Bits und Bytes, Mathematisches und Geld
22 Testen mit JUnit
23 Die Werkzeuge des JDK
A Java SE-Module und Paketübersicht
Stichwortverzeichnis


Download:

- Listings, ca. 2,7 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 15. Auflage des Java-Kultbuches wurde wieder gründlich überarbeitet. Sie berücksichtigt alle Versionen von Java 8 bis 14. Programmiert wird mit dem freien, quelloffenen OpenJDK. Besonders Java-Einsteiger, Studierende und Umsteigerinnen 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.



 

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

Zum Rheinwerk-Shop

Inhaltsverzeichnis

Materialien

Vorwort

 

Zum Seitenanfang

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

 

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   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

 

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   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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

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

 

Zum Seitenanfang

Stichwortverzeichnis

 


Ihre Meinung?

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de

 
 Zum Rheinwerk-Shop
Zum Rheinwerk-Shop: Java ist auch eine Insel Java ist auch eine Insel

Jetzt Buch bestellen


 Buchempfehlungen
Zum Rheinwerk-Shop: Captain CiaoCiao erobert Java

Captain CiaoCiao erobert Java




Zum Rheinwerk-Shop: Java SE 9 Standard-Bibliothek

Java SE 9 Standard-Bibliothek




Zum Rheinwerk-Shop: Algorithmen in Java

Algorithmen in Java




Zum Rheinwerk-Shop: Objektorientierte Programmierung

Objektorientierte Programmierung




 Lieferung
Versandkostenfrei bestellen in Deutschland, Österreich und in die Schweiz

InfoInfo



 

 


Copyright © Rheinwerk Verlag GmbH 2021

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



Cookie-Einstellungen ändern