Inhalt

WWW ...

Was

Wie

Warum

Wer

1 Grundlagen

1.1 Java-Überblick

  1.1.1 Code-Design

  1.1.2 Java-Applikation

1.2 Programmstruktur

  1.2.1 Packages und Namespace

  1.2.2 Java-Code-Struktur

  1.2.3 Zugriff auf Klassen und Import

  1.2.4 Dateiorganisation und Kompilierung

  1.2.5 Ausführen einer Applikation

1.3 Primitive Datentypen

  1.3.1 Regeln zu Operationen mit Zahlen

1.4 Lexikalische Grundlagen

  1.4.1 Unicode

  1.4.2 Whitespace

  1.4.3 Kommentare

  1.4.4 Identifier

  1.4.5 Separator

  1.4.6 Literale

  1.4.7 Schlüsselwort

  1.4.8 Operatoren

1.5 Konvertierung primitiver Typen

  1.5.1 Widening Conversion

  1.5.2 Narrowing Conversion und Casting

1.6 Initialisierung von Variablen

1.7 Namenskonventionen

  1.7.1 Methodenname

1.8 Zusammenfassung

1.9 Testfragen

2 Operatoren

2.1 Überblick

  2.1.1 Regel für Operanden-Werteberechnung

2.2 Arithmetische Operatoren

  2.2 Unäre Operatoren

  2.2 Binäre Operatoren

2.3 Referenz-Variable

2.4 String-Operator

2.5 Vergleichs-Operatoren

  2.5 Relationale Operatoren

  2.5 Gleichheits-Operatoren

2.6 Typvergleich-Operator instanceof

2.7 Logische Operatoren

2.8 Bitmanipulationen

  2.8.1 Duale bzw. hexadezimale Codierung

  2.8.2 Regeln für Bit-Operationen

  2.8.3 Invertierung (Bitwise Complement)

  2.8.4 Bitwise AND, OR, XOR

  2.8.5 Bitwise-Shift-Operationen

2.9 Zuweisungen

  2.9.1 Compound-Assignment und Seiteneffekte

  2.9.1 Wirkung der einfachen Zuweisung

2.10 Ternärer Operator

2.11 Zusammenfassung

2.12 Testfragen

3 Anweisungen

3.1 Überblick über Anweisungen

3.2 Grundlegende Anweisungen

  3.2.1 Leere Anweisung

  3.2.2 Block (Compound-Statement)

  3.2.3 Ausdruck als Anweisung (Expression-Statement)

3.3 Kontrollanweisungen

  3.3.1 Selektion

  3.3.2 Iterationen

  3.3.3 Sprunganweisungen

  3.3.4 try-Anweisung

3.4 Deklaration

  3.4.1 Klassen und Interfaces

  3.4.2 Variable

  3.4.3 Methode

3.5 Aufruf einer Methode

  3.5.1 Argumente und Wertübergabe

  3.5.2 Einfacher Methoden-Aufruf

  3.5.3 Qualifizierender Methoden-Aufruf

3.6 Zusammenfassung

3.7 Testfragen

4 Modellierung und UML

4.1 Generalisierung und Spezialisierung

  4.1.1 Klassifikation: Denken in Hierarchien

  4.1.2 Dynamische Polymorphie

4.2 Klassen-Beziehungen in der UML

  4.2.1 Klasse

  4.2.2 Generalisierung und Spezialisierung

  4.2.3 Klassifikation von Beziehungen

  4.2.4 Assoziation

  4.2.5 Aggregation und Komposition

  4.2.6 Nützliche UML-Erweiterungen

4.3 Objekt-Diagramm

  4.3.1 Objekt-Notation

  4.3.2 Objekt-Diagramme

4.4 Interaktions-Modellierung

  4.4.1 Sequenz-Diagramme

4.5 Zusammenfassung

5 Vererbung

5.1 Deklaration von Subklassen

5.2 Overriding vs. Overloading

5.3 Superklasse Object

5.4 Vererbung und Modifikatoren

  5.4.1 abstract

  5.4.2 final

  5.4.3 Zugriffs-Modifikatoren (Access-Modifier)

  5.4.4 Unverträglichkeiten von Modifikatoren

5.5 Konstruktoren

  5.5.1 Default-Konstruktor

  5.5.2 Deklaration und Initialisierungs-Regeln

  5.5.3 Signatur-Regel für Konstruktoren

  5.5.4 Zusammenarbeit von Konstruktoren

5.6 Pros und Kons der Initialisierung

  5.6.1 Design-Pros

  5.6.2 Design-Kons

5.7 Initialisierer

  5.7.1 Instanz-Initialisierer

  5.7.2 Statischer Initialisierer

5.8 Overriding vs. Shadowing

  5.8.1 Statischer vs. virtueller Aufruf von Methoden

  5.8.2 Shadowing von Feldern und super

  5.8.3 Aufruf überschriebener Methoden mittels super

5.9 Speicherverwaltung

  5.9.1 Garbage Collection

  5.9.2 GC und Finalization

  5.9.3 Alternative zu finalize

  5.9.4 Einsatz von finalize

5.10 Kapselung (Encapsulation)

5.11 Zusammenfassung

5.12 Testfragen

6 Interfaces und Pattern

6.1 Interface: Definition und Regeln

  6.1.1 Beispiele zu den Interface-Regeln

6.2 Referenz-Konvertierung und -Casting

  6.2.1 Regeln zur Referenz-Konvertierung

  6.2.2 Regeln zum Referenz-Casting

  6.2.3 Exemplarische Konvertierungs- und Cast-Beispiele

6.3 API: Interface vs. Klasse

  6.3.1 Beispiel JDK: Löschen bzw. Ändern im API

  6.3.2 Erweiterungen im API

6.4 Interface vs. Vererbung

  6.4.1 Service-Beziehung auf Basis von Vererbung

  6.4.2 Service-Beziehung auf Basis von Interfaces

  6.4.3 Nachteile der Vererbung

6.5 Design-Pattern: generelle Entwurfsmuster

6.6 Interface-Pattern

  6.6.1 Filter-Template, Kollektion

  6.6.2 Interface – eine Firewall?

6.7 Delegation-Pattern

  6.7.1 Probleme bei der Vererbung: zwei Beispiele

  6.7.2 Delegation vs. Vererbung

6.8 Vererbung, Interfaces und Delegation

6.9 Immutable

6.10 Marker-Interface

  6.10.1 Sticker-Interface: Erweiterung des Marker-Interfaces

  6.10.2 Marker-Interface Cloneable

6.11 Factory-Pattern

  6.11.1 Ein »Teile-Fabrik«-Beispiel

6.12 Konzeptionelle Schwächen von Interfaces

  6.12.1 Constraints (Zusicherungen)

  6.12.2 Interfaces bieten keinen Zugriffsschutz

  6.12.3 Ein Template-Dilemma

6.13 Zusammenfassung

6.14 Testfragen

7 Ausnahmen

7.1 Konzeption

7.2 Ausnahme-Mechanismus

  7.2.1 Ausnahme-Auslösung (exception throwing)

  7.2.2 Ausnahme-Behandlung (exception handling)

7.3 Details zur Ausnahme-Behandlung

  7.3.1 catch-Reihenfolge

  7.3.2 Geschachtelte Ausnahmen

  7.3.3 finally und unbehandelte Ausnahmen

  7.3.4 Rethrowing in catch

7.4 Ausnahme-Kategorien in Java

  7.4.1 Hierarchie-Konzept

  7.4.2 Checked vs. unchecked Exceptions

  7.4.3 Basisklasse Throwable

  7.4.4 Ausnahmen vom Typ Error

  7.4.5 Ausnahmen vom Typ Exception

  7.4.6 Ausnahmen vom Typ RuntimeException

  7.4.7 Checked Exceptions

7.5 Overriding von Ausnahmen

7.6 Deklaration neuer Ausnahmen

7.7 Einsatz von Ausnahmen

  7.7.1 Missbrauch von Ausnahmen

  7.7.2 Ausnahmen zur Einhaltung von Kontrakten

  7.7.3 Kommunikation per Ausnahme

7.8 Ausnahmen-Behandlung

  7.8.1 Beispiel: Messwert-Import

  7.8.2 Design neuer Ausnahmen

  7.8.3 Ein Idiom zur Behandlungs-Strategie

  7.8.4 Behandlungs-Strategie beim Messwert-Import

7.9 Zusammenfassung

7.10 Testfragen

8 Innere Klassen

8.1 Arten von inneren Klassen

8.2 Statische innere Klassen und Interfaces

  8.2.1 Design-Beispiel: 2D-Klassen

8.3 Nicht statische innere Klassen

8.4 Member-Klassen

  8.4.1 Anlage und Zugriff auf Instanzen einer Member-Klasse

  8.4.2 Member-Klassen und Vererbung

  8.4.3 Member-Klasse vs. Instanz-Variable

8.5 Lokale Klassen

  8.5.1 Gültigkeit vs. Lebensdauer

8.6 Anonyme Klassen

  8.6.1 Zugriff auf interne Methoden anonymer Klassen

  8.6.2 Probleme mit anonymen Klassen

8.7 Firewall-Idiom: Quasi-Objekte von Interfaces

8.8 Generisches Verhalten

  8.8.1 Pluggable-Behavior-Pattern

8.9 Zusammenfassung

8.10 Testfragen

9 Threads

9.1 Grundlegende Begriffe

  9.1.1 Multi-Tasking, Multi-Threading

  9.1.2 Scheduling, Priorität und Preemption

  9.1.3 Synchronisation

9.2 Thread-Start

  9.2.1 Methoden run() und start()

9.3 Thread-Zustände

  9.3.1 Zustand: aktiv bzw. tot

  9.3.2 Zustand: schlafend

  9.3.3 Zustand: blockiert vs. nicht blockiert bei I/O

  9.3.4 Zustand: Warten auf Lock

  9.3.5 Monitor

  9.3.6 Methoden wait(), notify() bzw. notifyAll()

  9.3.7 Zustand: wartend

  9.3.8 Unterbrechen der Zustände

9.4 Thread-Methoden

  9.4.1 Konstruktoren

  9.4.2 Statische Methoden

  9.4.3 Prioritäten

  9.4.4 Instanz-Methoden

  9.4.5 Diverse Methoden im Beispiel

9.5 Race-Condition

  9.5.1 Atomare vs. nicht atomare Operationen

  9.5.2 Reentrant, Race-Condition und thread-sicher

9.6 Synchronisation und Deadlock

  9.6.1 Methoden- und Block-Synchronisation

  9.6.2 Voll- bzw. teilsynchronisierte Objekte

  9.6.3 Deadlock durch Synchronisation

9.7 Vermeidungsstrategien zu Deadlocks

  9.7.1 Ressourcen-Anordnung bei Locks

  9.7.2 Deadlocks in Objekt-Kompositionen

9.8 Guarded-Method: wait() und notify()

  9.8.1 Auswirkung der wait()-Regel

  9.8.2 Wait-Regel bzw. -Idiom

  9.8.3 Guarded-Method und Guarded-Action-Idiom

9.9 Weitere thread-sichere Maßnahmen

  9.9.1 Threads und immutable Objekte

  9.9.2 Zustandslose Methoden

  9.9.3 Thread-sichere Dekoration/Wrapper

9.10 Thread-Mechanismen

  9.10.1 Passive Objekte

  9.10.2 Aktive Objekte

  9.10.3 Aktive Client- und Server-Objekte

  9.10.4 Asynchroner Service

9.11 Client-aktivierte asynchrone Methoden

  9.11.1 One-Shot-Objekt

  9.11.2 Asynchrone Methode ohne Ergebnis

9.12 Server-Aktivierung

  9.12.1 Autonomes Objekt

  9.12.2 Asynchrone Methode mit Ergebnis

  9.12.3 join(): Warten ohne Polling, sofern notwendig

  9.12.4 Callback-Technik

9.13 Thread-Unterbrechung

  9.13.1 interrupt() und InterruptedException

  9.13.2 interrupt()-Probleme und Gegenmaßnahmen

  9.13.3 interrupt()-Konzept

9.14 Unbehandelte Ausnahmen in Threads

  9.14.1 ThreadGroup: uncaughtException()

9.15 Zusammenfassung

9.16 Testfragen

10 Package java.lang

10.1 Object

  10.1.1 Overriding equals()

  10.1.2 getClass() vs. instanceof

  10.1.3 Semantik von Gleichheit

  10.1.4 Beziehung zwischen equals() und hashCode()

  10.1.5 Berechnung des Hashcodes

10.2 Class

10.3 Wrapper-Klassen

10.4 String und StringBuffer

  10.4.1 Compiler-Optimierung

  10.4.2 Notwendigkeit der manuellen Optimierung

  10.4.3 Größe eines StringBuffer-Objekts

10.5 Math und StrictMath

  10.5.1 Singleton-Pattern und Lazy Initialization

  10.5.2 Singleton-Komposition

  10.5.3 Singleton und Double-Check Locking

  10.5.4 Probleme mit komplexen Zahlen

10.6 System

  10.6.1 Byte-orientierte Konsol-Ausgabe

  10.6.2 Zeichen-Codierung und Unicode

  10.6.3 Zeichen- vs. Byte-Streams

  10.6.4 Default-Codierung und System.out

  10.6.5 Byte-orientierte Eingabe mit System.in

  10.6.6 System-Properties

  10.6.7 Methode: load() bzw. loadLibrary()

  10.6.8 Methode: identityHashCode()

  10.6.9 Methode: currentTimeMillis()

  10.6.10 Methode: arraycopy()

  10.6.11 Methode: exit()

10.7 Process

10.8 Runtime

  10.8.1 Methode: exec()

10.9 Zusammenfassung

10.10 Testfragen

11 Package java.io

11.1 Überblick

11.2 File

11.3 FileDescriptor

11.4 Interfaces DataInput und DataOutput

11.5 RandomAccessFile

11.6 Stream-Konzept

11.7 Decorator-Pattern

11.8 Streams im Einsatz

11.9 Digitale Signatur für Dokumente (Byte-Streams)

  11.9.1 Package java.security

11.10 Pipe-Streams

11.11 Zusammenfassung

11.12 Testfragen

12 Serialisierung

12.1 Serialisierung: Kommunikation auf Basis von Objekten

12.2 Grundlagen der Serialisierung

  12.2.1 Standard-Serialisierung

12.3 Übertragungs-Protokolle

  12.3.1 Protokoll zu primitiven Typen

  12.3.2 Protokolle zur Objekt-Serialisierung

  12.3.3 Protokoll zu Externalizable

  12.3.4 Protokoll zu Serializable

12.4 Einfache Anpassungen von Serializable

  12.4.1 serialPersistentFields: Ersatz für transient

  12.4.2 Externalizable: Kapselung unmöglich

  12.4.3 Klasseninterne Anpassung der Default-Serialisierung

  12.4.4 Broker-Pattern: Stream-Ersatzobjekte

12.5 Klassen-Evolution

  12.5.1 Stream-Kompatibilität

12.6 Anpassungen der Object-Streams

  12.6.1 annotateClass() und resolveClass() für Klassendaten

  12.6.2 replaceObject() und resolveObject()

  12.6.3 writeObjectOverride() und readObjectOverride()

12.7 Zusammenfassung

12.8 Testfragen

13 Reflexion

13.1 Klasse, Interface und Reflexion

13.2 Übersicht über Reflexion

  13.2.1 Package java.lang.reflect

  13.2.2 Object und Class

  13.2.3 Constructor, Field und Method

  13.2.4 Modifier

  13.2.5 Array

  13.2.6 Proxy

13.3 Inspektion von Klassen und Interfaces

  13.3.1 Class-Objekt

  13.3.2 Methoden get<X> vs. getDeclared<X>

  13.3.3 Package, Superklassen und Interfaces

  13.3.4 Konstruktoren und Modifikatoren

  13.3.5 Felder

  13.3.6 Methoden

  13.3.7 Array

13.4 Manipulation von Klassen und Arrays

  13.4.1 Anlage von Objekten

  13.4.2 Lesen und Schreiben von Feldern

  13.4.3 Ausführung von Methoden

  13.4.4 InvocationTargetException

  13.4.5 Anlage von Arrays

  13.4.6 Lesen und Schreiben von Array-Komponenten

  13.4.7 Unterstützende Array-Methoden

13.5 Introspection und Kommandos

  13.5.1 Inspektion mit Hilfe der Klasse Introspector

  13.5.2 Kommandos

13.6 Command-Pattern

  13.6.1 Realisierung mittels Interfaces oder Reflexion

13.7 Dynamisches Proxy-Pattern

  13.7.1 Allgemeine Eigenschaften

  13.7.2 Dynamische Proxy-Variante

  13.7.3 Dynamische Proxy-Implementation

  13.7.4 Beispiel Broker- bzw. Façade-Proxy

13.8 Zusammenfassung

14 Collection-Framework

14.1 Aufbau

14.2 Interface-Hierarchie

  14.2.1 Unterstützende Interfaces

  14.2.2 Bedeutung der Interfaces

  14.2.3 Konventionen, Kontrakte und Constraints

  14.2.4 Kontrakte

14.3 Kollektions-Klassen

  14.3.1 Auswahl der Kollektions-Klasse

  14.3.2 Hash-Kollektionen und Tuning

  14.3.3 HashMap

  14.3.4 Listen

  14.3.5 Comparable und Comparator

  14.3.6 Bäume (Trees)

  14.3.7 Bereichs-Operationen: Bäume und Listen

14.4 Iterator-Pattern

  14.4.1 Iteratoren zu Maps

14.5 Fundamentale vs. Template-Methoden

  14.5.1 Das Template-Problem

  14.5.2 Sortieren vs. Shuffling

  14.5.3 Generische Listen-Operationen

14.6 Dekorieren von Kollektionen

  14.6.1 Synchronisierte Wrapper

  14.6.2 Immutable Wrapper

14.7 Zusammenfassung

14.8 Testfragen

15 Java Foundation Classes

15.1 Vorbemerkungen

15.2 Begriffe

15.3 Top-Level-Container

  15.3.1 JRootPane

  15.3.2 JLayeredPane

  15.3.3 JWindow

  15.3.4 JFrame vs. Frame

  15.3.5 JDialog und JOptionPane

15.4 Layout-Manager

  15.4.1 Überblick

  15.4.2 BorderLayout und FlowLayout

  15.4.3 CardLayout

  15.4.4 GridLayout

  15.4.5 GridBagLayout

  15.4.6 BoxLayout

15.5 Ereignisbehandlung

  15.5.1 Observer-Pattern

  15.5.2 Ereignis-Delegations-Modell

  15.5.3 Ereignisverarbeitung

  15.5.4 Fokus-Management

  15.5.5 Ereignisverteilung (Event-Dispatching)

  15.5.6 Ereignisbearbeitung in abgeleiteten Komponenten

15.6 MFC-Architektur

  15.6.1 Model-Delegate-Architektur in Swing

  15.6.2 BoundedRangeModel für Bars und Sliders

15.7 Multi-Threading in Swing

  15.7.1 Erlaubte Zugriffe von Threads auf Swing

  15.7.2 Notwendigkeit swing-externer Threads

  15.7.3 Kommunikation mit Swing von externen Threads

15.8 Applet

  15.8.1 Eigenschaften

  15.8.2 Erstellen eines (J)Applets

  15.8.3 Wichtige Getter-Methoden

15.9 Zusammenfassung

15.10 Chamäleon-Architektur

Index