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 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Eigene Klassen schreiben
6 Exceptions
7 Generics<T>
8 Äußere.innere Klassen
9 Besondere Klassen der Java SE
10 Architektur, Design und angewandte Objektorientierung
11 Die Klassenbibliothek
12 Bits und Bytes und Mathematisches
13 Datenstrukturen und Algorithmen
14 Threads und nebenläufige Programmierung
15 Raum und Zeit
16 Dateien, Verzeichnisse und Dateizugriffe
17 Datenströme
18 Die eXtensible Markup Language (XML)
19 Grafische Oberflächen mit Swing
20 Grafikprogrammierung
21 Netzwerkprogrammierung
22 Verteilte Programmierung mit RMI
23 JavaServer Pages und Servlets
24 Datenbankmanagement mit JDBC
25 Reflection und Annotationen
26 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Ihre Meinung?

Spacer
Java ist auch eine Insel von Christian Ullenboom
Das umfassende Handbuch
Buch: Java ist auch eine Insel

Java ist auch eine Insel
geb., mit DVD
1482 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1506-0

Nützliche Links:
Diese 9. Auflage des Java-Kultbuches wurde gründlich überarbeitet und aktualisiert. 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. So erfahren Sie einiges über Threads, Swing, Netzwerkprogrammierung, NetBeans, RMI, XML und Java, Servlets und Java Server Pages, JDBC und vieles mehr.

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

Über dieses Buch

Vorwort zur 9. Auflage

Rheinwerk Computing - Zum Seitenanfang

1 Java ist auch eine Sprache

1.1 Der erste Kontakt

1.2 Historischer Hintergrund

1.3 Eigenschaften von Java

1.3.1 Bytecode und die virtuelle Maschine
1.3.2 Objektorientierung in Java
1.3.3 Das Java-Security-Modell
1.3.4 Zeiger und Referenzen
1.3.5 Bring den Müll raus, Garbage-Collector!
1.3.6 Ausnahmebehandlung
1.3.7 Kein Präprozessor für Textersetzungen
1.3.8 Keine benutzerdefinierten überladenen Operatoren
1.3.9 Java als Sprache, Laufzeitumgebung und Standardbibliothek
1.3.10 Java ist Open Source
1.3.11 Wofür sich Java weniger eignet
1.3.12 Java im Vergleich zu anderen Sprachen
1.3.13 Java und das Web, Applets statt Apples
1.3.14 Features, Enhancements (Erweiterungen) und ein JSR
1.3.15 Entwicklung von Java und Zukunftsaussichten

1.4 Java-Plattformen: Java SE, Java EE und Java ME

1.4.1 Die Java SE-Plattform
1.4.2 Java für die Kleinen
1.4.3 Java für die ganz ganz Kleinen
1.4.4 Java für die Großen

1.5 Die Installation der Java Platform Standard Edition (Java SE)

1.5.1 Die Java SE von Oracle
1.5.2 Download des JDK
1.5.3 Java SE unter Windows installieren

1.6 Das erste Programm compilieren und testen

1.6.1 Ein Quadratzahlen-Programm
1.6.2 Der Compilerlauf
1.6.3 Die Laufzeitumgebung
1.6.4 Häufige Compiler- und Interpreterprobleme

1.7 Entwicklungsumgebungen im Allgemeinen

1.7.1 Die Entwicklungsumgebung Eclipse
1.7.2 NetBeans von Oracle
1.7.3 IntelliJ IDEA
1.7.4 Ein Wort zu Microsoft, Java und zu J++

1.8 Eclipse im Speziellen

1.8.1 Eclipse starten
1.8.2 Das erste Projekt anlegen
1.8.3 Eine Klasse hinzufügen
1.8.4 Übersetzen und Ausführen
1.8.5 JDK statt JRE
1.8.6 Start eines Programms ohne Speicheraufforderung
1.8.7 Projekt einfügen, Workspace für die Programme wechseln
1.8.8 Plugins für Eclipse

1.9 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

2 Sprachbeschreibung

2.1 Elemente der Programmiersprache Java

2.1.1 Token
2.1.2 Textkodierung durch Unicode-Zeichen
2.1.3 Literale
2.1.4 Bezeichner
2.1.5 Reservierte Schlüsselwörter
2.1.6 Zusammenfassung der lexikalischen Analyse
2.1.7 Kommentare

2.2 Anweisungen formen Programme

2.2.1 Was sind Anweisungen?
2.2.2 Klassendeklaration
2.2.3 Die Reise beginnt am main()
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 Ausdrucksanweisung
2.2.9 Erste Idee der Objektorientierung
2.2.10 Modifizierer

2.3 Datentypen, Typisierung, Variablen und Zuweisungen

2.3.1 Primitive Datentypen im Überblick
2.3.2 Variablendeklarationen
2.3.3 Variablendeklaration mit Wertinitialisierung
2.3.4 Zuweisungsoperator
2.3.5 Wahrheitswerte
2.3.6 Ganzzahlige Datentypen und Literale
2.3.7 Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem *
2.3.8 Die Fließkommazahlen »float« und »double«
2.3.9 Alphanumerische Zeichen
2.3.10 Gute Namen, schlechte Namen

2.4 Blöcke, Initialisierung und Sichtbarkeit

2.4.1 Gruppieren von Anweisungen mit Blöcken
2.4.2 Initialisierung von lokalen Variablen
2.4.3 Sichtbarkeit und Gültigkeitsbereich

2.5 Ausdrücke, Operanden und Operatoren

2.5.1 Ausdrücke
2.5.2 Arithmetische Operatoren
2.5.3 Unäres Minus und Plus
2.5.4 Zuweisung mit Operation
2.5.5 Präfix- oder Postfix-Inkrement und -Dekrement
2.5.6 Die relationalen Operatoren und die Gleichheitsoperatoren
2.5.7 Logische Operatoren: Nicht, Und,Oder, Xor
2.5.8 Der Rang der Operatoren in der Auswertungsreihenfolge
2.5.9 Die Typanpassung (das Casting)
2.5.10 Überladenes Plus für Strings
2.5.11 Operator vermisst *

2.6 Bedingte Anweisungen oder Fallunterscheidungen

2.6.1 Die if-Anweisung
2.6.2 Die Alternative mit einer if-else-Anweisung wählen
2.6.3 Der Bedingungsoperator
2.6.4 Die switch-Anweisung bietet die Alternative

2.7 Schleifen

2.7.1 Die while-Schleife
2.7.2 Die do-while-Schleife
2.7.3 Die for-Schleife
2.7.4 Schleifenbedingungen und Vergleiche mit ==
2.7.5 Ausbruch planen mit break und Wiedereinstieg mit »continue«
2.7.6 »break« und »continue« mit Marken *

2.8 Methoden einer Klasse

2.8.1 Bestandteil einer Methode
2.8.2 Signatur-Beschreibung in der Java-API
2.8.3 Aufruf einer Methode
2.8.4 Methoden ohne Parameter deklarieren
2.8.5 Statische Methoden (Klassenmethoden)
2.8.6 Parameter, Argument und Wertübergabe
2.8.7 Methoden vorzeitig mit return beenden
2.8.8 Nicht erreichbarer Quellcode bei Methoden
2.8.9 Rückgabewerte
2.8.10 Methoden überladen
2.8.11 Vorgegebener Wert für nicht aufgeführte Argumente *
2.8.12 Finale lokale Variablen
2.8.13 Rekursive Methoden *
2.8.14 Die Türme von Hanoi *

2.9 Zum Weiterlesen

Rheinwerk Computing - 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 Die Klasse Point

3.3 Die UML (Unified Modeling Language) *

3.3.1 Hintergrund und Geschichte zur 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 new-Operator anlegen
3.4.2 Garbage-Collector (GC) – Es ist dann mal weg
3.4.3 Deklarieren von Referenzvariablen
3.4.4 Zugriff auf Variablen und Methoden mit dem ».«
3.4.5 Konstruktoren nutzen

3.5 Mit Referenzen arbeiten, Identität und Gleichheit

3.5.1 Die null-Referenz
3.5.2 null-Referenzen testen
3.5.3 Zuweisungen bei Referenzen
3.5.4 Methoden mit nicht-primitiven Parametern
3.5.5 Identität von Objekten
3.5.6 Gleichheit und die Methode »equals()«

3.6 Kompilationseinheiten, Imports und Pakete schnüren

3.6.1 Volle Qualifizierung und import-Deklaration
3.6.2 Mit import p1.p2.* alle Typen eines Pakets erreichen
3.6.3 Hierarchische Strukturen über Pakete
3.6.4 Die package-Deklaration
3.6.5 Unbenanntes Paket (default package)
3.6.6 Klassen mit gleichen Namen in unterschiedlichen Paketen *
3.6.7 Compilationseinheit (Compilation Unit)
3.6.8 Statischer Import
3.6.9 Eine Verzeichnisstruktur für eigene Projekte *

3.7 Arrays

3.7.1 Deklaration von Arrays
3.7.2 Arrays mit Inhalt
3.7.3 Die Länge eines Arrays über das Attribut length auslesen
3.7.4 Zugriff auf die Elemente über den Index
3.7.5 Array-Objekte mit new erzeugen
3.7.6 Fehler bei Arrays
3.7.7 Die erweiterte for-Schleife
3.7.8 Arrays mit nicht-primitiven Elementen
3.7.9 Mehrdimensionale Arrays *
3.7.10 Vorinitialisierte Arrays *
3.7.11 Mehrere Rückgabewerte *
3.7.12 Methode mit variabler Argumentanzahl (Vararg)
3.7.13 Klonen kann sich lohnen – Arrays vermehren *
3.7.14 Feldinhalte kopieren *
3.7.15 Die Klasse Arrays zum Vergleichen, Füllen und Suchen nutzen

3.8 Der Einstiegspunkt für das Laufzeitsystem: »main()«

3.8.1 Kommandozeilenargumente verarbeiten
3.8.2 Der Rückgabewert von »main()« und »System.exit()«

3.9 Annotationen

3.9.1 Annotationstypen @Override, @Deprecated, @SuppressWarnings

3.10 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

4 Der Umgang mit Zeichenketten

4.1 Einzelne Zeichen behandeln

4.1.1 Von ASCII über ISO-8859-1 zu Unicode
4.1.2 Die Character-Klasse

4.2 Strings und deren Anwendung

4.2.1 String-Literale als String-Objekte für konstante Zeichenketten
4.2.2 String-Länge und Test auf Leerstring
4.2.3 Nach enthaltenen Zeichen und Zeichenfolgen suchen
4.2.4 Gut, dass wir verglichen haben
4.2.5 Phonetische Vergleiche
4.2.6 String-Teile extrahieren
4.2.7 Strings anhängen, Groß-/Kleinschreibung und Leerraum
4.2.8 Suchen und ersetzen
4.2.9 String-Objekte mit Konstruktoren neu anlegen *

4.3 Konvertieren zwischen Primitiven und Strings

4.3.1 Unterschiedliche Typen in String-Repräsentationen konvertieren
4.3.2 Stringinhalt in primitiven Wert konvertieren
4.3.3 Unterschiedliche Ausgabeformate (Binär, Hex, Oktal) *

4.4 Veränderbare Zeichenketten mit StringBuilder und StringBuffer

4.4.1 Anlegen von StringBuilder/StringBuffer-Objekten
4.4.2 StringBuilder/StringBuffer in andere Zeichenkettenformate konvertieren
4.4.3 Daten anhängen
4.4.4 Zeichen(folgen) setzen, erfragen, löschen und umdrehen
4.4.5 Länge und Kapazität eines StringBuilder/StringBuffer-Objekts *
4.4.6 Vergleichen von String mit StringBuilder und StringBuffer
4.4.7 »hashCode()« bei StringBuilder/StringBuffer *

4.5 CharSequence als Basistyp *

4.6 Sprachabhängiges Vergleichen und Normalisierung *

4.6.1 Die Klasse »Collator«
4.6.2 Effiziente interne Speicherung für die Sortierung
4.6.3 Normalisierung

4.7 Reguläre Ausdrücke

4.7.1 Arbeiten mit der Fassade: String#matches()
4.7.2 Die Klassen Pattern und Matcher
4.7.3 Finden und nicht matchen
4.7.4 Gierige und nicht gierige Operatoren *
4.7.5 Mit MatchResult alle Ergebnisse einsammeln *
4.7.6 Suchen und Ersetzen mit Mustern

4.8 Zerlegen von Zeichenketten

4.8.1 Splitten von Zeichenketten mit »split()«
4.8.2 Die Klasse Scanner
4.8.3 Die Klasse StringTokenizer *
4.8.4 BreakIterator als Zeichen-, Wort-, Zeilen- und Satztrenner *

4.9 Zeichenkodierungen, XML/HTML-Entitys, Base64 *

4.9.1 Unicode und 8-Bit-Abbildungen
4.9.2 Konvertieren mit »OutputStreamWriter«-Klassen
4.9.3 Das Paket »java.nio.charset«
4.9.4 XML/HTML-Entitys ausmaskieren
4.9.5 Base64-Kodierung

4.10 Ausgaben formatieren

4.10.1 Formatieren und Ausgeben mit »format()«
4.10.2 Die Formatter-Klasse *
4.10.3 Formatieren mit Masken *
4.10.4 Format-Klassen
4.10.5 Zahlen, Prozente und Währungen mit »NumberFormat« und »DecimalFormat« formatieren *

4.11 Zum Weiterlesen

Rheinwerk Computing - 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 Statische Methoden 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 öffentliche statische finale Variablen
5.4.2 Typ(un)sichere Aufzählungen *
5.4.3 Aufzählungen mit »enum«

5.5 Objekte anlegen und zerstören

5.5.1 Konstruktoren schreiben
5.5.2 Der vorgegebene Konstruktor (engl. »default constructor«)
5.5.3 Parametrisierte und überladene Konstruktoren
5.5.4 Copy-Konstruktor
5.5.5 Einen anderen Konstruktor der gleichen Klasse mit »this()« aufrufen
5.5.6 Ihr fehlt uns nicht – der Garbage-Collector
5.5.7 Private Konstruktoren, Utility-Klassen, Singleton, Fabriken

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 Assoziationen zwischen Objekten

5.7.1 Unidirektionale 1:1-Beziehung
5.7.2 Bidirektionale 1:1-Beziehungen
5.7.3 Unidirektionale 1:n-Beziehung

5.8 Vererbung

5.8.1 Vererbung in Java
5.8.2 Spielobjekte modellieren
5.8.3 Die implizite Basisklasse »java.lang.Object«
5.8.4 Einfach- und Mehrfachvererbung *
5.8.5 Die Sichtbarkeit »protected«
5.8.6 Konstruktoren in der Vererbung und »super()«

5.9 Typen in Hierarchien

5.9.1 Automatische und explizite Typanpassung
5.9.2 Das Substitutionsprinzip
5.9.3 Typen mit dem binären Operator »instanceof «testen

5.10 Methoden überschreiben

5.10.1 Methoden in Unterklassen mit neuem Verhalten ausstatten
5.10.2 Mit »super« an die Eltern
5.10.3 Finale Klassen und finale Methoden
5.10.4 Kovariante Rückgabetypen
5.10.5 Array-Typen und Kovarianz *

5.11 Dynamisches Binden

5.11.1 Gebunden an »toString()«
5.11.2 Implementierung von »System.out.println(Object)«
5.11.3 Nicht dynamisch gebunden bei privaten, statischen und finalen Methoden
5.11.4 Dynamisch gebunden auch bei Konstruktoraufrufen *
5.11.5 Eine letzte Spielerei mit Javas dynamischer Bindung und überschatteten Attributen *

5.12 Abstrakte Klassen und abstrakte Methoden

5.12.1 Abstrakte Klassen
5.12.2 Abstrakte Methoden

5.13 Schnittstellen

5.13.1 Schnittstellen deklarieren
5.13.2 Implementieren von Schnittstellen
5.13.3 Markierungsschnittstellen *
5.13.4 Ein Polymorphie-Beispiel mit Schnittstellen
5.13.5 Die Mehrfachvererbung bei Schnittstellen *
5.13.6 Keine Kollisionsgefahr bei Mehrfachvererbung *
5.13.7 Erweitern von Interfaces – Subinterfaces
5.13.8 Konstantendeklarationen bei Schnittstellen
5.13.9 Initialisierung von Schnittstellenkonstanten *
5.13.10 Abstrakte Klassen und Schnittstellen im Vergleich

5.14 Dokumentationskommentare mit JavaDoc

5.14.1 Einen Dokumentationskommentar setzen
5.14.2 Mit dem Werkzeug javadoc eine Dokumentation erstellen
5.14.3 HTML-Tags in Dokumentationskommentaren *
5.14.4 Generierte Dateien
5.14.5 Dokumentationskommentare im Überblick *
5.14.6 JavaDoc und Doclets *
5.14.7 Veraltete (deprecated) Typen und Eigenschaften
Rheinwerk Computing - Zum Seitenanfang

6 Exceptions

6.1 Problembereiche einzäunen

6.1.1 Exceptions in Java mit try und catch
6.1.2 Eine NumberFormatException auffangen
6.1.3 Ablauf einer Ausnahmesituation
6.1.4 Eigenschaften vom Exception-Objekt
6.1.5 Wiederholung abgebrochener Bereiche *
6.1.6 Mehrere Ausnahmen auffangen
6.1.7 throws im Methodenkopf angeben
6.1.8 Abschlussbehandlung mit »finally«

6.2 Die Klassenhierarchie der Fehler

6.2.1 Die Exception-Hierarchie
6.2.2 Oberausnahmen auffangen
6.2.3 Alles geht als Exception durch
6.2.4 Zusammenfassen gleicher catch-Blöcke

6.3 RuntimeException muss nicht aufgefangen werden

6.3.1 Beispiele für RuntimeException-Klassen
6.3.2 Kann man abfangen, muss man aber nicht

6.4 Harte Fehler: Error *

6.5 Auslösen eigener Exceptions

6.5.1 Mit throw Ausnahmen auslösen
6.5.2 Vorhandene Runtime-Fehlertypen kennen und nutzen
6.5.3 Parameter testen und gute Fehlermeldungen
6.5.4 Neue Exception-Klassen deklarieren
6.5.5 Eigene Ausnahmen als Unterklassen von Exception oder RuntimeException?
6.5.6 Abfangen und weiterleiten *
6.5.7 Geschachtelte Ausnahmen *

6.6 Assertions *

6.6.1 Assertions in eigenen Programmen nutzen
6.6.2 Assertions aktivieren
Rheinwerk Computing - Zum Seitenanfang

7 Generics<T>

7.1 Einführung in Java Generics

7.1.1 Mensch versus Maschine: Typprüfung des Compilers und der Laufzeitumgebung
7.1.2 Taschen
7.1.3 Generische Typen deklarieren
7.1.4 Generics nutzen
7.1.5 Generische Schnittstellen
7.1.6 Generische Methoden/Konstruktoren und Typ-Inferenz
Rheinwerk Computing - Zum Seitenanfang

8 Äußere.innere Klassen

8.1 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen

8.1.1 Statische innere Klassen und Schnittstellen
8.1.2 Mitglieds- oder Elementklassen
8.1.3 Lokale Klassen
8.1.4 Anonyme innere Klassen
8.1.5 Zugriff auf lokale Variablen aus lokalen inneren und anonymen Klassen *
8.1.6 »this« und Vererbung *
Rheinwerk Computing - Zum Seitenanfang

9 Besondere Klassen der Java SE

9.1 Vergleichen von Objekten

9.1.1 Natürlich geordnet oder nicht?
9.1.2 Die Schnittstelle Comparable
9.1.3 Die Schnittstelle Comparator
9.1.4 Rückgabewerte kodieren die Ordnung

9.2 Wrapper-Klassen und Autoboxing

9.2.1 Wrapper-Objekte erzeugen
9.2.2 Konvertierungen in eine String-Repräsentation
9.2.3 Die Basisklasse Number für numerische Wrapper-Objekte
9.2.4 Vergleiche durchführen mit »compare()«, »compareTo()« und »equals()«
9.2.5 Die Klasse Integer
9.2.6 Die Klassen Double und Float für Fließkommazahlen
9.2.7 Die Boolean-Klasse
9.2.8 Autoboxing: Boxing und Unboxing

9.3 Object ist die Mutter aller Klassen

9.3.1 Klassenobjekte
9.3.2 Objektidentifikation mit »toString()«
9.3.3 Objektgleichheit mit »equals()« und Identität
9.3.4 Klonen eines Objekts mit »clone()« *
9.3.5 Hashcodes über »hashCode()« liefern *
9.3.6 Aufräumen mit »finalize()« *
9.3.7 Synchronisation *

9.4 Die Spezial-Oberklasse Enum

9.4.1 Methoden auf Enum-Objekten
9.4.2 »Enum« mit eigenen Konstruktoren und Methoden *

9.5 Erweitertes »for« und »Iterable«

9.5.1 Die Schnittstelle »Iterable«
9.5.2 Einen eigenen Iterable implementieren *

9.6 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

10 Architektur, Design und angewandte Objektorientierung

10.1 Architektur, Design und Implementierung

10.2 Design-Pattern (Entwurfsmuster)

10.2.1 Motivation für Design-Pattern
10.2.2 Das Beobachter-Pattern (Observer/Observable)
10.2.3 Ereignisse über Listener

10.3 JavaBean

10.3.1 Properties (Eigenschaften)
10.3.2 Einfache Eigenschaften
10.3.3 Indizierte Eigenschaften
10.3.4 Gebundene Eigenschaften und PropertyChangeListener
10.3.5 Veto-Eigenschaften – dagegen!
10.3.6 Ein POJO (Plain Old Java Object) ohne technische Abhängigkeiten

10.4 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

11 Die Klassenbibliothek

11.1 Die Java-Klassenphilosophie

11.1.1 Übersicht über die Pakete der Standardbibliothek

11.2 Klassenlader (Class Loader)

11.2.1 Woher die kleinen Klassen kommen
11.2.2 Setzen des Klassenpfades
11.2.3 Die wichtigsten drei Typen von Klassenladern
11.2.4 Die Klasse java.lang.ClassLoader *
11.2.5 Hot Deployment mit dem URL-Classloader *
11.2.6 Das Verzeichnis jre/lib/endorsed *

11.3 Die Utility-Klasse System und Properties

11.3.1 Systemeigenschaften der Java-Umgebung
11.3.2 line.separator
11.3.3 Property von der Konsole aus setzen *
11.3.4 Umgebungsvariablen des Betriebssystems *

11.4 Einfache Benutzereingaben

11.4.1 Grafischer Eingabedialog über JOptionPane
11.4.2 Geschützte Passwort-Eingaben mit der Klasse »Console« *

11.5 Ausführen externer Programme *

11.5.1 »ProcessBuilder« und Prozesskontrolle mit Process
11.5.2 Einen Browser, E-Mail-Client oder Editor aufrufen

11.6 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

12 Bits und Bytes und Mathematisches

12.1 Bits und Bytes *

12.1.1 Die Bit-Operatoren Komplement, Und, Oder und Xor
12.1.2 Repräsentation ganzer Zahlen in Java – das Zweierkomplement
12.1.3 Auswirkung der Typanpassung auf die Bitmuster
12.1.4 »byte« als vorzeichenlosen Datentyp nutzen
12.1.5 Die Verschiebeoperatoren
12.1.6 Ein Bit setzen, löschen, umdrehen und testen
12.1.7 Bit-Methoden der Integer- und Long-Klasse

12.2 Fließkommaarithmetik in Java

12.2.1 Spezialwerte für Unendlich, Null, NaN
12.2.2 Standard-Notation und wissenschaftliche Notation bei Fließkommazahlen *
12.2.3 Mantisse und Exponent *

12.3 Die Eigenschaften der Klasse Math

12.3.1 Attribute
12.3.2 Absolutwerte und Vorzeichen
12.3.3 Maximum/Minimum
12.3.4 Runden von Werten
12.3.5 Wurzel und Exponentialmethoden
12.3.6 Der Logarithmus *
12.3.7 Rest der ganzzahligen Division *
12.3.8 Winkelmethoden *
12.3.9 Zufallszahlen

12.4 Mathe bitte strikt *

12.4.1 Strikte Fließkommaberechungungen mit strictfp
12.4.2 Die Klassen Math und StrictMath

12.5 Die Random-Klasse

12.5.1 Objekte aufbauen mit dem Samen
12.5.2 Zufallszahlen erzeugen
12.5.3 Pseudo-Zufallszahlen in der Normalverteilung *

12.6 Große Zahlen *

12.6.1 Die Klasse BigInteger
12.6.2 Methoden von BigInteger
12.6.3 Ganz lange Fakultäten
12.6.4 Große Fließkommazahlen mit BigDecimal
12.6.5 Mit MathContext komfortabel die Rechengenauigkeit setzen

12.7 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

13 Datenstrukturen und Algorithmen

13.1 Datenstrukturen und die Collection-API

13.1.1 Designprinzip mit Schnittstellen, abstrakten und konkreten Klassen
13.1.2 Die Basis-Schnittstellen Collection und Map
13.1.3 Das erste Programm mit Container-Klassen
13.1.4 Die Schnittstelle Collection und Kernkonzepte
13.1.5 Schnittstellen, die Collection erweitern, und Map
13.1.6 Konkrete Container-Klassen
13.1.7 Welche Container-Klasse nehmen?
13.1.8 Generische Datentypen in der Collection-API
13.1.9 Die Schnittstelle »Iterable« und das erweiterte »for«

13.2 Mit einem Iterator durch die Daten wandern

13.2.1 Die Schnittstellen Enumeration und Iterator
13.2.2 Iteratoren von Sammlungen und das erweiterte »for«
13.2.3 Fail-Fast-Iterator und die ConcurrentModificationException

13.3 Listen

13.3.1 Auswahlkriterium ArrayList oder LinkedList
13.3.2 Die Schnittstelle List
13.3.3 ListIterator *
13.3.4 ArrayList
13.3.5 LinkedList
13.3.6 Der Feld-Adapter »Arrays.asList()«
13.3.7 »toArray()« von Collection verstehen – die Gefahr einer Falle erkennen
13.3.8 Primitive Elemente in den Collection-Datenstrukturen

13.4 Datenstrukturen mit Ordnung

13.4.1 Algorithmen mit Such- und Sortiermöglichkeiten
13.4.2 Den größten und kleinsten Wert einer Collection finden
13.4.3 Sortieren

13.5 Mengen (Sets)

13.5.1 HashSet
13.5.2 TreeSet – die Menge durch Bäume
13.5.3 LinkedHashSet

13.6 Stack (Kellerspeicher, Stapel)

13.6.1 Die Methoden von »Stack«
13.6.2 Ein »Stack« ist ein »Vector« – aha!

13.7 Queues (Schlangen) und Deques

13.7.1 Die Schnittstelle »Queue«
13.7.2 Blockierende Queues und Prioritätswarteschlangen
13.7.3 »Deque«-Klassen

13.8 Assoziative Speicher

13.8.1 Die Klassen »HashMap« und »TreeMap«
13.8.2 Einfügen und Abfragen der Datenstruktur
13.8.3 Über die Bedeutung von »equals()«, »hashCode()«
13.8.4 IdentityHashMap
13.8.5 Das Problem von veränderten Elementen
13.8.6 Aufzählungen und Ansichten des Assoziativspeichers
13.8.7 Der Gleichheitstest, Hash-Wert und Klon einer Hash-Tabelle*
13.8.8 Die Arbeitsweise einer Hash-Tabelle *

13.9 Die Properties-Klasse

13.9.1 Properties setzen und lesen
13.9.2 Properties verketten
13.9.3 Hierarchische Eigenschaften
13.9.4 Eigenschaften ausgeben *
13.9.5 Properties laden und speichern

13.10 Algorithmen in Collections

13.10.1 Nicht-änderbare Datenstrukturen
13.10.2 Null Object Pattern und leere Sammlungen zurückgeben
13.10.3 Mit der Halbierungssuche nach Elementen fahnden
13.10.4 Ersetzen, Kopieren, Füllen, Umdrehen, Rotieren, Durchmischen *
13.10.5 Häufigkeit eines Elements *
13.10.6 nCopies() *
13.10.7 Singletons *

13.11 Synchronisation der Datenstrukturen

13.11.1 Lock-free-Algorithmen aus java.util.concurrent
13.11.2 Wrapper zur Synchronisation
13.11.3 »CopyOnWriteArrayList« und »CopyOnWriteArraySet«

13.12 Die Klasse »BitSet« für Bitmengen *

13.12.1 Ein »BitSet« anlegen, füllen und erfragen
13.12.2 Mengenorientierte Operationen
13.12.3 Methodenübersicht
13.12.4 Primzahlen in einem BitSet verwalten

13.13 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

14 Threads und nebenläufige Programmierung

14.1 Nebenläufigkeit

14.1.1 Threads und Prozesse
14.1.2 Wie parallele Programme die Geschwindigkeit steigern können
14.1.3 Was Java für Nebenläufigkeit alles bietet

14.2 Threads erzeugen

14.2.1 Threads über die Schnittstelle Runnable implementieren
14.2.2 Thread mit Runnable starten
14.2.3 Die Klasse Thread erweitern

14.3 Thread-Eigenschaften und -Zustände

14.3.1 Der Name eines Threads
14.3.2 Wer bin ich?
14.3.3 Die Zustände eines Threads *
14.3.4 Schläfer gesucht
14.3.5 Mit »yield()« auf Rechenzeit verzichten
14.3.6 Der Thread als Dämon
14.3.7 Das Ende eines Threads
14.3.8 Einen Thread höflich mit Interrupt beenden
14.3.9 »UncaughtExceptionHandler« für unbehandelte Ausnahmen
14.3.10 Der »stop()« von außen und die Rettung mit ThreadDeath *
14.3.11 Ein Rendezvous mit »join()« *
14.3.12 Arbeit niederlegen und wieder aufnehmen *
14.3.13 Priorität *

14.4 Der Ausführer (Executor) kommt

14.4.1 Die Schnittstelle »Executor«
14.4.2 Die Thread-Pools
14.4.3 Threads mit Rückgabe über Callable
14.4.4 Mehrere Callable abarbeiten
14.4.5 Mit ScheduledExecutorService wiederholende Ausgaben und Zeitsteuerungen

14.5 Synchronisation über kritische Abschnitte

14.5.1 Gemeinsam genutzte Daten
14.5.2 Probleme beim gemeinsamen Zugriff und kritische Abschnitte
14.5.3 Punkte parallel initialisieren
14.5.4 »i++« sieht atomar aus, ist es aber nicht *
14.5.5 Kritische Abschnitte schützen
14.5.6 Schützen mit ReentrantLock
14.5.7 Synchronisieren mit »synchronized«
14.5.8 Synchronized-Methoden der Klasse »StringBuffer« *
14.5.9 Mit synchronized synchronisierte Blöcke
14.5.10 Dann machen wir doch gleich alles synchronisiert!
14.5.11 Lock-Freigabe im Fall von Exceptions
14.5.12 Deadlocks
14.5.13 Mit »synchronized« nachträglich synchronisieren *
14.5.14 Monitore sind reentrant – gut für die Geschwindigkeit *
14.5.15 Synchronisierte Methodenaufrufe zusammenfassen *

14.6 Synchronisation über Warten und Benachrichtigen

14.6.1 Die Schnittstelle »Condition«
14.6.2 It’s Disco-Time *
14.6.3 Warten mit »wait()« und Aufwecken mit »notify()« *
14.6.4 Falls der Lock fehlt: IllegalMonitorStateException *

14.7 Zeitgesteuerte Abläufe

14.7.1 Die Klassen »Timer« und »TimerTask«
14.7.2 Job-Scheduler Quartz

14.8 Einen Abbruch der virtuellen Maschine erkennen

14.9 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

15 Raum und Zeit

15.1 Weltzeit *

15.2 Wichtige Datum-Klassen im Überblick

15.2.1 Der 1.1.1970
15.2.2 System.currentTimeMillis()
15.2.3 Einfach Zeitumrechnungen durch »TimeUnit«

15.3 Sprachen der Länder

15.3.1 Sprachen und Regionen über Locale-Objekte

15.4 Internationalisierung und Lokalisierung

15.4.1 ResourceBundle-Objekte und Ressource-Dateien
15.4.2 Ressource-Dateien zur Lokalisierung
15.4.3 Die Klasse »ResourceBundle«
15.4.4 Ladestrategie für ResourceBundle-Objekte

15.5 Die Klasse »Date«

15.5.1 Objekte erzeugen und Methoden nutzen
15.5.2 Date-Objekte nicht immutable

15.6 Calendar und GregorianCalendar

15.6.1 Die abstrakte Klasse »Calendar«
15.6.2 Der gregorianische Kalender
15.6.3 »Calendar« nach »Date« und Millisekunden fragen
15.6.4 Ostertage *
15.6.5 Abfragen und Setzen von Datumselementen über Feldbezeichner

15.7 Formatieren und Parsen von Datumsangaben

15.7.1 Ausgaben mit »printf()«
15.7.2 Mit »DateFormat« und »SimpleDateFormat« formatieren
15.7.3 Parsen von Datumswerten

15.8 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

16 Dateien, Verzeichnisse und Dateizugriffe

16.1 Datei und Verzeichnis

16.1.1 Dateien und Verzeichnisse mit der Klasse »File«
16.1.2 Verzeichnis oder Datei? Existiert es?
16.1.3 Verzeichnis- und Dateieigenschaften/-attribute
16.1.4 Umbenennen und Verzeichnisse anlegen
16.1.5 Verzeichnisse listen und Dateien filtern
16.1.6 Dateien berühren, neue Dateien anlegen, temporäre Dateien
16.1.7 Dateien und Verzeichnisse löschen
16.1.8 Verzeichnisse nach Dateien iterativ durchsuchen *
16.1.9 Wurzelverzeichnis, Laufwerksnamen, Plattenspeicher *
16.1.10 URL- und URI-Objekte aus einem File-Objekt ableiten *
16.1.11 Mit Locking Dateien sperren *

16.2 Dateien mit wahlfreiem Zugriff

16.2.1 Ein »RandomAccessFile« zum Lesen und Schreiben öffnen
16.2.2 Aus dem »RandomAccessFile« lesen
16.2.3 Schreiben mit »RandomAccessFile«
16.2.4 Die Länge des »RandomAccessFile«
16.2.5 Hin und her in der Datei

16.3 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

17 Datenströme

17.1 Stream-Klassen und Reader/Writer am Beispiel von Dateien

17.1.1 Mit dem FileWriter Texte in Dateien schreiben
17.1.2 Zeichen mit der Klasse »FileReader« lesen
17.1.3 Kopieren mit »FileOutputStream« und »FileInputStream«
17.1.4 Das FileDescriptor-Objekt *

17.2 Basisklassen für die Ein-/Ausgabe

17.2.1 Die abstrakten Basisklassen
17.2.2 Übersicht über Ein-/Ausgabeklassen
17.2.3 Die abstrakte Basisklasse »OutputStream«
17.2.4 Die Schnittstellen »Closeable« und »Flushable«
17.2.5 Ein Datenschlucker *
17.2.6 Die abstrakte Basisklasse »InputStream«
17.2.7 Ressourcen aus dem Klassenpfad und aus Jar–Archiven laden
17.2.8 Ströme mit SequenceInputStream zusammensetzen *
17.2.9 Die abstrakte Basisklasse »Writer«
17.2.10 Die Schnittstelle »Appendable« *
17.2.11 Die abstrakte Basisklasse »Reader«

17.3 Formatierte Textausgaben

17.3.1 Die Klassen »PrintWriter« und »PrintStream«
17.3.2 »System.out«, »System.err« und »System.in«

17.4 Schreiben und Lesen aus Strings und Byte-Feldern

17.4.1 Mit dem »StringWriter« ein String-Objekt füllen
17.4.2 CharArrayWriter
17.4.3 »StringReader« und »CharArrayReader«
17.4.4 Mit »ByteArrayOutputStream« in ein Byte-Feld schreiben
17.4.5 Mit »ByteArrayInputStream« aus einem Byte-Feld lesen

17.5 Datenströme filtern und verketten

17.5.1 Streams als Filter verketten (verschalen)
17.5.2 Gepufferte Ausgaben mit »BufferedWriter«/»BufferedOutputStream«
17.5.3 Gepufferte Eingaben mit »BufferedReader«/»BufferedInputStream«
17.5.4 »LineNumberReader« zählt automatisch Zeilen mit *
17.5.5 Daten mit der Klasse »PushbackReader« zurücklegen *
17.5.6 DataOutputStream/DataInputStream *
17.5.7 Basisklassen für Filter *
17.5.8 Die Basisklasse »FilterWriter« *
17.5.9 Ein LowerCaseWriter *
17.5.10 Eingaben mit der Klasse »FilterReader« filtern *
17.5.11 Anwendungen für »FilterReader« und »FilterWriter« *

17.6 Vermittler zwischen Byte-Streams und Unicode-Strömen

17.6.1 Datenkonvertierung durch den »OutputStreamWriter«
17.6.2 Automatische Konvertierungen mit dem »InputStreamReader«

17.7 Kommunikation zwischen Threads mit Pipes *

17.7.1 »PipedOutputStream« und »PipedInputStream«
17.7.2 »PipedWriter« und »PipedReader«

17.8 Datenkompression *

17.8.1 Java-Unterstützung beim Komprimieren
17.8.2 Datenströme komprimieren
17.8.3 Zip-Archive
17.8.4 Jar-Archive

17.9 Prüfsummen

17.9.1 Die Schnittstelle Checksum
17.9.2 Die Klasse »CRC32«
17.9.3 Die Adler32-Klasse

17.10 Persistente Objekte und Serialisierung

17.10.1 Objekte mit der Standard-Serialisierung speichern und lesen
17.10.2 Zwei einfache Anwendungen der Serialisierung *
17.10.3 Die Schnittstelle »Serializable«
17.10.4 Nicht serialisierbare Attribute aussparen
17.10.5 Das Abspeichern selbst in die Hand nehmen
17.10.6 Tiefe Objektkopien *
17.10.7 Versionenverwaltung und die SUID
17.10.8 Wie die »ArrayList« serialisiert *
17.10.9 Probleme mit der Serialisierung

17.11 Alternative Datenaustauschformate

17.11.1 Serialisieren in XML-Dateien
17.11.2 XML-Serialisierung von JavaBeans mit JavaBeans Persistence *
17.11.3 Open-Source Bibliothek XStream *

17.12 Tokenizer *

17.12.1 StreamTokenizer

17.13 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

18 Die eXtensible Markup Language (XML)

18.1 Auszeichnungssprachen

18.1.1 Die Standard Generalized Markup Language (SGML)
18.1.2 Extensible Markup Language (XML)

18.2 Eigenschaften von XML-Dokumenten

18.2.1 Elemente und Attribute
18.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten
18.2.3 Schema – eine Alternative zu DTD
18.2.4 Namensraum (Namespace)
18.2.5 XML-Applikationen *

18.3 Die Java-APIs für XML

18.3.1 Das Document Object Model (DOM)
18.3.2 Simple API for XML Parsing (SAX)
18.3.3 Pull-API StAX
18.3.4 Java Document Object Model (JDOM)
18.3.5 JAXP als Java-Schnittstelle zu XML
18.3.6 DOM-Bäume einlesen mit JAXP *

18.4 Java Architecture for XML Binding (JAXB)

18.4.1 Bean für JAXB aufbauen
18.4.2 JAXBContext und die Marshaller
18.4.3 Ganze Objektgraphen schreiben und lesen
18.4.4 Validierung
18.4.5 Weitere JAXB-Annotationen *
18.4.6 Beans aus XML-Schema-Datei generieren

18.5 Serielle Verarbeitung mit StAX

18.5.1 Unterschiede der Verarbeitungsmodelle
18.5.2 XML-Dateien mit dem Cursor-Verfahren lesen
18.5.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten *
18.5.4 Mit Filtern arbeiten *
18.5.5 XML-Dokumente schreiben

18.6 Serielle Verarbeitung von XML mit SAX *

18.6.1 Schnittstellen von SAX
18.6.2 SAX-Parser erzeugen
18.6.3 Operationen der Schnittstelle »ContentHandler«
18.6.4 ErrorHandler und EntityResolver

18.7 XML-Dateien mit JDOM verarbeiten

18.7.1 JDOM beziehen
18.7.2 Paketübersicht *
18.7.3 Die Document-Klasse
18.7.4 Eingaben aus der Datei lesen
18.7.5 Das Dokument im XML-Format ausgeben
18.7.6 Der Dokumenttyp *
18.7.7 Elemente
18.7.8 Zugriff auf Elementinhalte
18.7.9 Liste mit Unterelementen erzeugen *
18.7.10 Neue Elemente einfügen und ändern
18.7.11 Attributinhalte lesen und ändern
18.7.12 XPath

18.8 Transformationen mit XSLT *

18.8.1 Templates und XPath als Kernelemente von XSLT
18.8.2 Umwandlung von XML-Dateien mit JDOM und JAXP

18.9 XML-Schema-Validierung *

18.9.1 SchemaFactory und Schema
18.9.2 Validator
18.9.3 Validierung unterschiedlicher Datenquellen durchführen

18.10 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

19 Grafische Oberflächen mit Swing

19.1 Das Abstract Window Toolkit und Swing

19.1.1 SwingSet-Demos
19.1.2 Abstract Window Toolkit (AWT)
19.1.3 Java Foundation Classes
19.1.4 Was Swing von AWT unterscheidet

19.2 Mit NetBeans zur ersten Oberfläche

19.2.1 Projekt anlegen
19.2.2 Gui-Klasse hinzufügen
19.2.3 Programm starten
19.2.4 Grafische Oberfläche aufbauen
19.2.5 Swing-Komponenten-Klassen
19.2.6 Funktionalität geben

19.3 Fenster unter grafischen Oberflächen

19.3.1 Swing-Fenster mit javax.swing.JFrame darstellen
19.3.2 Fenster schließbar machen – setDefaultCloseOperation()
19.3.3 Sichtbarkeit des Fensters
19.3.4 Größe und Position des Fensters verändern
19.3.5 Fenster- und Dialog-Dekoration, Transparenz *
19.3.6 Dynamisches Layout während einer Größenänderung *

19.4 Beschriftungen (JLabel)

19.4.1 Mehrzeiliger Text, HTML in der Darstellung

19.5 Icon und ImageIcon für Bilder auf Swing-Komponenten

19.5.1 Die Klasse ImageIcon
19.5.2 Die Schnittstelle Icon und eigene Icons *

19.6 Es tut sich was – Ereignisse beim AWT

19.6.1 Swings Ereignisquellen und Horcher (Listener)
19.6.2 Listener implementieren
19.6.3 Listener bei dem Ereignisauslöser anmelden/abmelden
19.6.4 Aufrufen der Listener im AWT-Event-Thread
19.6.5 Adapterklassen nutzen
19.6.6 Innere Mitgliedsklassen und innere anonyme Klassen
19.6.7 Ereignisse etwas genauer betrachtet *

19.7 Schaltflächen

19.7.1 Normale Schaltflächen (JButton)
19.7.2 Der aufmerksame »ActionListener«
19.7.3 Schaltflächen-Ereignisse vom Typ »ActionEvent«
19.7.4 Basisklasse »AbstractButton«
19.7.5 Wechselknopf (JToggleButton)

19.8 Swing Action *

19.9 JComponent und Component als Basis aller Komponenten

19.9.1 Hinzufügen von Komponenten
19.9.2 Tooltips (Kurzhinweise)
19.9.3 Rahmen (Border) *
19.9.4 Fokus und Navigation *
19.9.5 Ereignisse jeder Komponente *
19.9.6 Die Größe und Position einer Komponente *
19.9.7 Komponenten-Ereignisse *
19.9.8 Undurchsichtige (opake) Komponente *
19.9.9 Properties und Listener für Änderungen *

19.10 Container

19.10.1 Standardcontainer (JPanel)
19.10.2 Bereich mit automatischen Rollbalken (JScrollPane)
19.10.3 Reiter (JTabbedPane)
19.10.4 Teilungs-Komponente (JSplitPane)

19.11 Alles Auslegungssache: die Layoutmanager

19.11.1 Übersicht über Layoutmanager
19.11.2 Zuweisen eines Layoutmanagers
19.11.3 Im Fluss mit FlowLayout
19.11.4 BoxLayout
19.11.5 Mit BorderLayout in alle Himmelsrichtungen
19.11.6 Rasteranordnung mit GridLayout
19.11.7 Der GridBagLayoutmanager *
19.11.8 Null-Layout *
19.11.9 Weitere Layoutmanager

19.12 Rollbalken und Schieberegler

19.12.1 Schieberegler (JSlider)
19.12.2 Rollbalken (JScrollBar) *

19.13 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen

19.13.1 Kontrollfelder (JCheckBox)
19.13.2 ItemSelectable, ItemListener und das ItemEvent
19.13.3 Sich gegenseitig ausschließende Optionen (JRadioButton)

19.14 Fortschritte bei Operationen überwachen *

19.14.1 Fortschrittsbalken (JProgressBar)
19.14.2 Dialog mit Fortschrittsanzeige (ProgressMonitor)

19.15 Menüs und Symbolleisten

19.15.1 Die Menüleisten und die Einträge
19.15.2 Menüeinträge definieren
19.15.3 Einträge durch Action-Objekte beschreiben
19.15.4 Mit der Tastatur: Mnemonics und Shortcut
19.15.5 Der Tastatur-Shortcut (Accelerator)
19.15.6 Tastenkürzel (Mnemonics)
19.15.7 Symbolleisten alias Toolbars
19.15.8 Popup-Menüs

19.16 Das Model-View-Controller-Konzept

19.17 Auswahlmenüs, Listen und Spinner

19.17.1 Auswahlmenü (JComboBox)
19.17.2 Zuordnung einer Taste mit einem Eintrag *
19.17.3 Datumsauswahl
19.17.4 Listen (JList)
19.17.5 Drehfeld (JSpinner) *

19.18 Textkomponenten

19.18.1 Text in einer Eingabezeile
19.18.2 Die Oberklasse der Text-Komponenten (JTextComponent)
19.18.3 Geschützte Eingaben (JPasswordField)
19.18.4 Validierende Eingabefelder (JFormattedTextField)
19.18.5 Einfache mehrzeilige Textfelder (JTextArea)
19.18.6 Editor-Klasse (JEditorPane) *

19.19 Tabellen (JTable)

19.19.1 Ein eigenes Tabellen-Model
19.19.2 Basisklasse für eigene Modelle (AbstractTableModel)
19.19.3 Vorgefertigtes Standard-Modell (DefaultTableModel)
19.19.4 Ein eigener Renderer für Tabellen
19.19.5 Zell-Editoren
19.19.6 Größe und Umrandung der Zellen *
19.19.7 Spalteninformationen*
19.19.8 Tabellenkopf von Swing-Tabellen *
19.19.9 Selektionen einer Tabelle *
19.19.10 Automatisches Sortieren und Filtern mit RowSorter *

19.20 Bäume (JTree)

19.20.1 JTree und sein TreeModel und TreeNode
19.20.2 Selektionen bemerken
19.20.3 Das TreeModel von JTree *

19.21 JRootPane und JDesktopPane *

19.21.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane)
19.21.2 JDesktopPane und die Kinder JInternalFrame
19.21.3 JLayeredPane

19.22 Dialoge und Window-Objekte

19.22.1 JWindow und JDialog
19.22.2 Modal oder nicht-modal
19.22.3 Standarddialoge mit JOptionPane
19.22.4 Der Dateiauswahldialog
19.22.5 Der Farbauswahldialog JColorChooser *

19.23 Flexibles Java-Look-and-Feel

19.23.1 Look and Feel global setzen
19.23.2 UIManager
19.23.3 Windowsoptik mit JGoodies Looks verbessern *

19.24 Swing-Komponenten neu erstellen oder verändern *

19.25 Die Zwischenablage (Clipboard)

19.25.1 Clipboard-Objekte
19.25.2 Auf den Inhalt zugreifen mit »Transferable«
19.25.3 DataFlavor ist das Format der Daten in der Zwischenablage
19.25.4 Einfügungen in der Zwischenablage erkennen
19.25.5 Drag

19.26 AWT, Swing und die Threads

19.26.1 Ereignisschlange (EventQueue) und AWT-Event-Thread
19.26.2 Swing ist nicht thread-sicher
19.26.3 »invokeLater()« und »invokeAndWait()«
19.26.4 SwingWorker
19.26.5 Eigene Ereignisse in die Queue setzen *
19.26.6 Auf alle Ereignisse hören *

19.27 Barrierefreiheit mit der Java Accessibility API

19.28 Zeitliches Ausführen mit dem javax.swing.Timer

19.29 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

20 Grafikprogrammierung

20.1 Grundlegendes zum Zeichnen

20.1.1 Die paint()-Methode für das AWT-Frame
20.1.2 Zeichnen von Inhalten auf ein JFrame
20.1.3 Auffordern zum Neuzeichnen mit »repaint()«
20.1.4 Java 2D-API

20.2 Einfache Zeichenmethoden

20.2.1 Linien
20.2.2 Rechtecke
20.2.3 Ovale und Kreisbögen
20.2.4 Polygone und Polylines

20.3 Zeichenketten schreiben und Fonts

20.3.1 Zeichenfolgen schreiben
20.3.2 Die Font-Klasse
20.3.3 Einen neuen Font aus einem gegebenen Font ableiten
20.3.4 Zeichensätze des Systems ermitteln *
20.3.5 Neue TrueType-Fonts in Java nutzen
20.3.6 Font-Metadaten durch FontMetrics *

20.4 Geometrische Objekte

20.4.1 Die Schnittstelle Shape
20.4.2 Kreisförmiges
20.4.3 Kurviges *
20.4.4 Area und die konstruktive Flächengeometrie *
20.4.5 Pfade *
20.4.6 Punkt in einer Form, Schnitt von Linien, Abstand Punkt/Linie *

20.5 Das Innere und Äußere einer Form

20.5.1 Farben und die Paint-Schnittstelle
20.5.2 Farben mit der Klasse »Color«
20.5.3 Die Farben des Systems über SystemColor *
20.5.4 Composite und Xor *
20.5.5 Dicke und Art der Linien von Formen bestimmen über »Stroke« *

20.6 Bilder

20.6.1 Eine Übersicht über die Bilder-Bibliotheken
20.6.2 Bilder mit »ImageIO« lesen
20.6.3 Ein Bild zeichnen
20.6.4 Programm-Icon/Fenster-Icon setzen
20.6.5 Splash-Screen *
20.6.6 Bilder im Speicher erzeugen *
20.6.7 Pixel für Pixel auslesen und schreiben *
20.6.8 Bilder skalieren *
20.6.9 Schreiben mit ImageIO
20.6.10 Asynchrones Laden mit getImage() und dem MediaTracker *

20.7 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

21 Netzwerkprogrammierung

21.1 Grundlegende Begriffe

21.2 URI und URL

21.2.1 Die Klasse URI
21.2.2 Die Klasse URL
21.2.3 Informationen über eine URL *
21.2.4 Der Zugriff auf die Daten über die Klasse »URL«

21.3 Die Klasse URLConnection *

21.3.1 Methoden und Anwendung von URLConnection
21.3.2 Protokoll- und Content-Handler
21.3.3 Im Detail: vom URL zur URLConnection
21.3.4 Der Protokoll-Handler für Jar-Dateien
21.3.5 Basic Authentication/Proxy-Authentifizierung

21.4 Mit GET und POST Daten übergeben *

21.4.1 Kodieren der Parameter für Serverprogramme
21.4.2 Eine Suchmaschine mit GET-Request ansprechen
21.4.3 POST-Request absenden

21.5 Host- und IP-Adressen

21.5.1 Lebt der Rechner?
21.5.2 IP-Adresse des lokalen Hosts
21.5.3 Das Netz ist Klasse …
21.5.4 NetworkInterface

21.6 Mit dem Socket zum Server

21.6.1 Das Netzwerk ist der Computer
21.6.2 Sockets
21.6.3 Eine Verbindung zum Server aufbauen
21.6.4 Server unter Spannung: die Ströme
21.6.5 Die Verbindung wieder abbauen
21.6.6 Informationen über den Socket *
21.6.7 Reine Verbindungsdaten über SocketAddress *

21.7 Client-Server-Kommunikation

21.7.1 Warten auf Verbindungen
21.7.2 Ein Multiplikationsserver
21.7.3 Blockierendes Lesen
21.7.4 Von außen erreichbar sein *

21.8 Apache HttpComponents und Commons Net

21.8.1 HttpComponents
21.8.2 Jakarta Commons Net

21.9 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

22 Verteilte Programmierung mit RMI

22.1 Entfernte Objekte und Methoden

22.1.1 Stellvertreter helfen bei entfernten Methodenaufrufen
22.1.2 Standards für entfernte Objekte

22.2 Java Remote Method Invocation

22.2.1 Zusammenspiel von Server, Registry und Client
22.2.2 Wie die Stellvertreter die Daten übertragen
22.2.3 Probleme mit entfernten Methoden
22.2.4 Nutzen von RMI bei Middleware-Lösungen
22.2.5 Zentrale Klassen und Schnittstellen
22.2.6 Entfernte und lokale Objekte im Vergleich

22.3 Auf der Serverseite

22.3.1 Entfernte Schnittstelle deklarieren
22.3.2 Remote-Objekt-Implementierung
22.3.3 Stellvertreterobjekte
22.3.4 Der Namensdienst (Registry)
22.3.5 Remote-Objekt-Implementierung exportieren und beim Namensdienst anmelden
22.3.6 Einfaches Logging
22.3.7 Aufräumen mit dem DGC

22.4 Auf der Clientseite

22.5 Entfernte Objekte übergeben und laden

22.5.1 Klassen vom RMI-Klassenlader nachladen

22.6 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

23 JavaServer Pages und Servlets

23.1 Dynamisch generierte Webseiten

23.1.1 Was sind Servlets?
23.1.2 Was sind JavaServer Pages?

23.2 Servlets und JSPs mit Tomcat entwickeln

23.2.1 Servlet-Container
23.2.2 Entwicklung der Servlet-/JSP-Spezifikationen
23.2.3 Webserver mit Servlet-Funktionalität
23.2.4 Tomcat installieren
23.2.5 Ablageort für eigene JSPs
23.2.6 Webapplikationen
23.2.7 Zuordnung von Webapplikationen zu physikalischen Verzeichnissen
23.2.8 Web-Projekt mit Eclipse IDE for Java EE Developers

23.3 Statisches und Dynamisches

23.3.1 Statischer Template-Code
23.3.2 Dynamische Inhalte
23.3.3 Kommentare

23.4 Die Expression Language (EL)

23.4.1 Operatoren der EL
23.4.2 Literale
23.4.3 Implizite EL-Objekte

23.5 Formulardaten

23.5.1 Einen Parameter auslesen
23.5.2 HTML-Formulare

23.6 Auf Beans zurückgreifen

23.6.1 Beans in JSPs anlegen
23.6.2 Properties einer Bean im EL-Ausdruck erfragen
23.6.3 Properties mit <jsp:setProperty> setzen
23.6.4 Bean-Klasse zum Testen von E-Mail-Adressen
23.6.5 Parameterwerte in Bean übertragen

23.7 JSP-Tag-Libraries

23.7.1 Standard Tag Library (JSTL)

23.8 Einbinden und Weiterleiten

23.8.1 Einbinden von Inhalten
23.8.2 Forward und Redirect
23.8.3 Applets einbinden

23.9 Skripting-Elemente in JSPs

23.9.1 Scriptlets
23.9.2 JSP-Ausdrücke
23.9.3 JSP-Deklarationen
23.9.4 Quoting
23.9.5 Entsprechende XML-Tags
23.9.6 Implizite Objekte für Scriptlets und JSP-Ausdrücke

23.10 JSP-Direktiven

23.10.1 page-Direktiven im Überblick
23.10.2 Mit JSPs Bilder generieren

23.11 Sitzungsverfolgung (Session Tracking)

23.11.1 Lösungen für Sitzungsverfolgung
23.11.2 Sitzungen in JSPs
23.11.3 Auf Session-Dateien zurückgreifen

23.12 Servlets

23.12.1 Servlets compilieren
23.12.2 Servlet-Mapping
23.12.3 Der Lebenszyklus eines Servlets
23.12.4 Mehrere Anfragen beim Servlet und die Thread-Sicherheit
23.12.5 Servlets und Sessions
23.12.6 Weiterleiten und Einbinden von Servlet-Inhalten

23.13 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

24 Datenbankmanagement mit JDBC

24.1 Relationale Datenbanken

24.1.1 Das relationale Modell

24.2 Datenbanken und Tools

24.2.1 HSQLDB
24.2.2 Weitere Datenbanken *
24.2.3 Eclipse-Plugins zum Durchschauen von Datenbanken

24.3 JDBC und Datenbanktreiber

24.3.1 Treibertypen *
24.3.2 JDBC-Versionen *

24.4 Eine Beispielabfrage

24.4.1 Schritte zur Datenbankabfrage
24.4.2 Client für HSQLDB-Datenbank
24.4.3 Datenbankbrowser und eine Beispielabfrage unter NetBeans

24.5 Mit Java an eine Datenbank andocken

24.5.1 Der Treiber-Manager *
24.5.2 Den Treiber laden
24.5.3 Eine Aufzählung aller Treiber *
24.5.4 Log-Informationen *
24.5.5 Verbindung zur Datenbank auf- und abbauen

24.6 Datenbankabfragen

24.6.1 Abfragen über das Statement-Objekt
24.6.2 Ergebnisse einer Abfrage in ResultSet
24.6.3 Java und SQL-Datentypen
24.6.4 Date, Time und Timestamp
24.6.5 Unicode in der Spalte korrekt auslesen
24.6.6 Eine SQL-NULL und »wasNull()« bei ResultSet
24.6.7 Wie viele Zeilen hat ein ResultSet? *

24.7 Elemente einer Datenbank hinzufügen und aktualisieren

24.7.1 Batch-Updates
24.7.2 Die Ausnahmen bei JDBC, SQLException und Unterklassen

24.8 Vorbereitete Anweisungen (Prepared Statements)

24.8.1 PreparedStatement-Objekte vorbereiten
24.8.2 Werte für die Platzhalter eines PreparedStatement

24.9 Transaktionen

24.10 Metadaten *

24.10.1 Metadaten über die Tabelle
24.10.2 Informationen über die Datenbank

24.11 Vorbereitete Datenbankverbindungen

24.11.1 DataSource
24.11.2 Gepoolte Verbindungen

24.12 Einführung in SQL

24.12.1 Ein Rundgang durch SQL-Abfragen
24.12.2 Datenabfrage mit der Data Query Language (DQL)
24.12.3 Tabellen mit der Data Definition Language (DDL) anlegen

24.13 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

25 Reflection und Annotationen

25.1 Metadaten

25.1.1 Metadaten durch JavaDoc-Tags

25.2 Metadaten der Klassen mit dem Class-Objekt

25.2.1 An ein Class-Objekt kommen
25.2.2 Was das Class-Objekt beschreibt *
25.2.3 Der Name der Klasse
25.2.4 »instanceof« mit Class-Objekten *
25.2.5 Oberklassen finden *
25.2.6 Implementierte Interfaces einer Klasse oder eines Interfaces *
25.2.7 Modifizierer und die Klasse »Modifier« *
25.2.8 Die Arbeit auf dem Feld *

25.3 Attribute, Methoden und Konstruktoren

25.3.1 Reflections – Gespür für Attribute einer Klasse
25.3.2 Methoden einer Klasse erfragen
25.3.3 Properties einer Bean erfragen
25.3.4 Konstruktoren einer Klasse
25.3.5 Annotationen

25.4 Objekte erzeugen und manipulieren

25.4.1 Objekte erzeugen
25.4.2 Die Belegung der Variablen erfragen
25.4.3 Eine generische eigene toString()-Methode *
25.4.4 Variablen setzen
25.4.5 Bean-Zustände kopieren *
25.4.6 Private Attribute ändern

25.5 Methoden aufrufen

25.5.1 Statische Methoden aufrufen

25.6 Eigene Annotationstypen *

25.6.1 Annotationen zum Laden von Ressourcen
25.6.2 Neue Annotationen deklarieren
25.6.3 Annotationen mit genau einem Attribut
25.6.4 Element-Werte-Paare (Attribute) hinzufügen
25.6.5 Annotationsattribute vom Typ einer Aufzählung
25.6.6 Felder von Annotationsattributen
25.6.7 Vorbelegte Attribute
25.6.8 Annotieren von Annotationstypen
25.6.9 Deklarationen für unsere Ressourcen-Annotationen
25.6.10 Annotierte Elemente auslesen
25.6.11 Auf die Annotationsattribute zugreifen
25.6.12 Komplettbeispiel zum Initialisieren von Ressourcen
25.6.13 Mögliche Nachteile von Annotationen

25.7 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

26 Dienstprogramme für die Java-Umgebung

26.1 Die Werkzeuge vom JDK

26.2 Java-Compiler und Java-Laufzeitumgebung

26.2.1 Bytecode-Compiler javac
26.2.2 Native Compiler
26.2.3 Java-Programme in ein natives ausführbares Programm einpacken
26.2.4 Der Java-Interpreter java

26.3 Das Archivformat Jar

26.3.1 Das Dienstprogramm jar benutzen
26.3.2 Das Manifest
26.3.3 Applikationen in Jar-Archiven starten
26.3.4 Applets in Jar-Archiven

26.4 Monitoringprogramme

26.4.1 jps
26.4.2 jstat
26.4.3 jmap
26.4.4 jstack
26.4.5 VisualVM

26.5 Ant

26.5.1 Bezug und Installation von Ant
26.5.2 Das Build-Skript build.xml
26.5.3 Build den Build
26.5.4 Properties
26.5.5 Externe und vordefinierte Properties
26.5.6 Weitere Ant-Tasks

26.6 Weitere Dienstprogramme

26.6.1 Sourcecode Beautifier
26.6.2 Java-Programme als Systemdienst ausführen

26.7 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

A Die Begleit-DVD

Ihr Kommentar

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

 Buchempfehlungen
Zum Katalog: Java ist auch eine Insel






 Java ist auch
 eine Insel


Zum Katalog: Java SE Bibliotheken






 Java SE Bibliotheken


Zum Katalog: Professionell entwickeln mit Java EE 7






 Professionell
 entwickeln mit
 Java EE 7


Zum Katalog: Einstieg in Eclipse






 Einstieg in
 Eclipse


Zum Katalog: Einstieg in Java






 Einstieg in
 Java


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2011
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