Der Weg zum Java-Profi – Teil III

Table of contents

1. Cover
2. Titel
3. Impressum
4. Inhaltsverzeichnis
5. Vorwort
   1. Aufbau dieser Auskopplung
   2. Hinweise
   3. Anregungen und Kritik
6. 1 Einleitung zum Gesamtbuch
   1. 1.1 Über dieses Buch
      1. 1.1.1 Motivation
      2. 1.1.2 Was leistet dieses Buch und was nicht?
      3. 1.1.3 Wie und was soll mithilfe des Buchs gelernt werden?
      4. 1.1.4 Wer sollte dieses Buch lesen?
   2. 1.2 Aufbau des Buchs
      1. 1.2.1 Gliederung des Buchs
      2. 1.2.2 Kapitelübersicht
         1. Teil I – Java-Grundlagen, Analyse und Design
         2. Teil II – Bausteine stabiler Java-Applikationen
         3. Teil III – Fallstricke und Lösungen im Praxisalltag
         4. Teil IV – Qualitätssicherungsmaßnahmen
         5. Teil V – Anhang
   3. 1.3 Konventionen
      1. Verwendete Zeichensätze
      2. Verwendete Abkürzungen
      3. Verwendete Java-Umgebungen und -Versionen
      4. Verwendete Klassen aus dem JDK
      5. Sourcecode und ausführbare Programme
   4. 1.4 Danksagungen
      1. Anregungen und Kritik
7. Teil I Fallstricke und Lösungen im Praxisalltag
   1. 2 Bad Smells
      1. Bad Smells am Beispiel
      2. 2.1 Programmdesign
         1. 2.1.1 Bad Smell: Verwenden von Magic Numbers
         2. 2.1.2 Bad Smell: Konstanten in Interfaces definieren
         3. 2.1.3 Bad Smell: System.exit() mitten im Programm
         4. 2.1.4 Bad Smell: Zusammengehörende Konstanten nicht als Typ definiert
         5. 2.1.5 Bad Smell: Programmcode im Logging-Code
         6. 2.1.6 Bad Smell: Unvollständige Betrachtung aller Alternativen
         7. 2.1.7 Bad Smell: Unvollständige Änderungen nach Copy-Paste
         8. 2.1.8 Bad Smell: Casts auf unbekannte Subtypen
         9. 2.1.9 Bad Smell: Pre-/Post-Increment in komplexeren Statements
         10. 2.1.10 Bad Smell: Keine Klammern um Blöcke
         11. 2.1.11 Bad Smell: Variablendeklaration nicht im kleinstmöglichen Sichtbarkeitsbereich
         12. 2.1.12 Bad Smell: Mehrere aufeinanderfolgende Parameter gleichen Typs
         13. 2.1.13 Bad Smell: Grundloser Einsatz von Reflection
      3. 2.2 Klassendesign
         1. 2.2.1 Bad Smell: Unnötigerweise veränderliche Attribute
         2. 2.2.2 Bad Smell: Aufruf abstrakter Methoden im Konstruktor
            1. Variante
            2. Verstecktere Initialisierungsprobleme
         3. 2.2.3 Bad Smell: Herausgabe von this im Konstruktor
         4. 2.2.4 Bad Smell: Referenzierung von Subklassen in Basisklassen
         5. 2.2.5 Bad Smell: Mix abstrakter und konkreter Basisklassen
         6. 2.2.6 Bad Smell: Öffentlicher Defaultkonstruktor lediglich zum Zugriff auf Hilfsmethoden
      4. 2.3 Fehlerbehandlung und Exception Handling
         1. 2.3.1 Bad Smell: Unbehandelte Exception
         2. 2.3.2 Bad Smell: Unpassender Exception-Typ
         3. 2.3.3 Bad Smell: Exceptions zur Steuerung des Kontrollflusses
         4. 2.3.4 Bad Smell: Fangen der allgemeinsten Exception
            1. Ausnahmen
            2. Vereinfachungen mit JDK 7
         5. 2.3.5 Bad Smell: Rückgabe von null statt Exception im Fehlerfall
         6. 2.3.6 Bad Smell: Unbedachte Rückgabe von null
            1. Ausbreitung dieses Bad Smells
         7. 2.3.7 Bad Smell: Sonderbehandlung von Randfällen
         8. 2.3.8 Bad Smell: Keine Gültigkeitsprüfung von Eingabeparametern
         9. 2.3.9 Bad Smell: Fehlerhafte Fehlerbehandlung
            1. Spezialfälle
         10. 2.3.10 Bad Smell: I/O ohne finally bzw. finalize()
             1. Spezialfall: Ressourcenattribute
         11. 2.3.11 Bad Smell: Resource Leaks durch Exceptions im Konstruktor
      5. 2.4 Häufige Fallstricke
         1. Fallstrick: Nutzung statischer Attribute statt Membervariablen
         2. Fallstrick: Änderung statischer Attribute im Konstruktor/in Methoden
         3. Fallstrick: Missachtung der Initialisierungsreihenfolge statischer Attribute
         4. Fallstrick: Utility-Klasse mit öffentlichem Konstruktor
         5. Fallstrick: Chaotische Konstruktor-/Methoden-Aufruffolgen
         6. Fallstrick: Einsatz von Vererbung und statischen Methoden
         7. Fallstrick: Missverständliches API durch Überladen
         8. Fallstrick: Mehrfachverkettung der ».«-Notation
         9. Fallstrick: Unnötige Komplexität
         10. Fallstrick: Objektvergleich durch Einsatz von toString() und equals()
         11. Fallstrick: Rückgabe von null in toString()-Methoden
         12. Fallstrick: Zugriff ohne Bereichsprüfung
         13. Fallstrick: Intensive Nutzung von Sprungmarken, break und continue
         14. Fallstrick: default mitten in den case-Anweisungen versteckt
         15. Fallstrick: Berechnungen in case-Anweisungen
         16. Fallstrick: Einsatz komplizierter boolescher Bedingungen
         17. Fallstrick: Einsatz doppelter Verneinung
         18. Fallstrick: Kommentierte Klammern
      6. 2.5 Weiterführende Literatur
         1. Bad Smells und Merkwürdigkeiten im Java-API
   2. 3 Refactorings
      1. Refactorings am Beispiel
      2. Schritt 1: Erstellen von Testfällen
      3. Schritt 2: Vereinfachungen durch Zusammenfassen der Bedingungen
      4. Schritt 3: Einsatz der Java-Bibliotheken zum Parsen von Zahlen
      5. Schritt 4: Behandlung ungültiger null-Eingabewerte
      6. 3.1 Das Standardvorgehen
         1. Beispiel
         2. Fazit
      7. 3.2 Der Refactoring-Katalog
         1. 3.2.1 Reduziere die Sichtbarkeit von Attributen
            1. Schritt 1: Erzeugen von Zugriffsmethoden
            2. Schritt 2: Sichtbarkeit des Attributs reduzieren
            3. Schritt 3: Korrekturen der Verwendungsstellen
            4. Schritt 4: Wiederhole Schritte 1 bis 3 für alle Attribute
            5. Fazit
            6. Sinnvolle weitere Schritte
         2. 3.2.2 Minimiere veränderliche Attribute
            1. Schritt 1: Prüfe, auf Schreibzugriffe – Definiere ein Attribut final
            2. Schritt 2: Prüfe, ob die set()-Methode entfernt werden kann
            3. Schritt 3: Prüfen interner Schreibzugriffe
            4. Schritt 4: Anpassung des Konstruktors
            5. Schritt 5: Wiederhole Schritt 1 bis 4 für alle Attribute
            6. Fazit
            7. Sinnvolle weitere Schritte
         3. 3.2.3 Reduziere die Sichtbarkeit von Methoden
            1. Einschränkungen
         4. 3.2.4 Ersetze Mutator- durch Business-Methode
         5. 3.2.5 Minimiere Zustandsänderungen (Refactoring-Kombination)
         6. 3.2.6 Führe ein Interface ein
            1. Einschränkungen
         7. 3.2.7 Aufspalten eines Interface
         8. 3.2.8 Einführen eines Read-only-Interface
         9. 3.2.9 Einführen eines Read-Write-Interface
         10. 3.2.10 Einführen von Convenience-Methoden
             1. Schritt 1: Erzeugen von Hilfsmethoden
             2. Schritt 2: Anpassen der Aufrufstellen
             3. Fazit
         11. 3.2.11 Einführen einer Zustandsprüfung
             1. Schritt 1: Implementieren einer Prüfmethode
             2. Schritt 2: Einsatz der Prüfmethode
             3. Fazit
         12. 3.2.12 Überprüfung von Eingabeparametern
             1. Schritt 1: Referenz- oder Bereichsprüfung
             2. Schritt 2: Einsatz von Aufzählungen, wenn sinnvoll und möglich
             3. Schritt 3: Angabe übergebener Werte und von Gültigkeitsbereichen
             4. Schritt 4: Herausfaktorieren von Prüfmethoden
             5. Fazit
         13. 3.2.13 Trenne Informationsbeschaffung und -verarbeitung
             1. Schritt 1: Erkennen von veränderlichen Elementen und Einführen von Hilfsvariablen
             2. Schritt 2: Zusammenfassen der set()-Methoden zu Blöcken
             3. Schritt 3: Auftrennen von Informationsbeschaffung und -verarbeitung
             4. Schritt 4: Kapseln von Informationsbeschaffung und -verarbeitung
             5. Fazit
         14. 3.2.14 Konstantensammlung in enum umwandeln
             1. Schritt 1: Sammlung in einer eigenen Konstantenklasse
             2. Schritt 2: Erzeugen eines Konstruktors und von Zugriffsmethoden
             3. Schritt 3: Umwandlung in eine enum-Aufzählung
             4. Fazit
         15. 3.2.15 Entferne Exceptions zur Steuerung des Kontrollflusses
             1. Schritt 1: Einführen eines Rückgabewerts
             2. Schritt 2: Exception Handling durch Auswertung des Rückgabewerts ersetzen
             3. Optionale Optimierungen zur Lesbarkeit
             4. Fazit
         16. 3.2.16 Umwandlung in Utility-Klasse mit statischen Hilfsmethoden
             1. Schritt 1: Umwandlung in statische Hilfsmethode
             2. Schritt 2: Erweiterung der Methodensignatur
             3. Schritt 3: Umwandlung aller Methoden in entsprechende Hilfsmethoden
             4. Schritt 4: Entfernen von Zustandsinformationen und anpassen von Konstruktoren
             5. Fazit
      8. 3.3 Weiterführende Literatur
   3. 4 Entwurfsmuster
      1. Design mit Entwurfsmustern
      2. Beispielapplikation: Image-Editor
      3. 4.1 Erzeugungsmuster
         1. 4.1.1 Erzeugungsmethode
            1. Beschreibung und Motivation
               1. Struktur
               2. Erweiterungen
               3. Bewertung
         2. 4.1.2 Fabrikmethode (Factory method)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         3. 4.1.3 Erbauer (Builder)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         4. 4.1.4 Singleton
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         5. 4.1.5 Prototyp (Prototype)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
      4. 4.2 Strukturmuster
         1. 4.2.1 Fassade (Façade)
            1. Beschreibung und Motivation
            2. Struktur
            3. Bewertung
         2. 4.2.2 Adapter
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         3. 4.2.3 Dekorierer (Decorator)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         4. 4.2.4 Kompositum (Composite)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiele
            4. Bewertung
      5. 4.3 Verhaltensmuster
         1. 4.3.1 Iterator
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Allgemeine bzw. polymorphe Iteratoren
            5. Bewertung
         2. 4.3.2 Null-Objekt (Null Object)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         3. 4.3.3 Schablonenmethode (Template method)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         4. 4.3.4 Strategie (Strategy)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Bewertung
         5. 4.3.5 Befehl (Command)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiel
            4. Ausführungskontext
            5. Erweiterungen
            6. Bewertung
         6. 4.3.6 Proxy
            1. Beschreibung und Motivation
            2. Struktur
            3. Varianten
            4. Beispiel
            5. Bewertung
         7. 4.3.7 Zuständigkeitskette (Chain of Responsibility)
            1. Beschreibung und Motivation
            2. Struktur
            3. Beispiele
            4. Bewertung
         8. 4.3.8 Beobachter (Observer)
            1. Beschreibung und Motivation
            2. Struktur
            3. Anmerkungen
            4. Beispiel: Warum ist Java-Built-In-Observer ungünstig?
            5. Verbesserungen
            6. Bewertung
         9. 4.3.9 MVC-Architektur
            1. Anmerkungen
            2. Bewertung
      6. 4.4 Weiterführende Literatur
8. Teil II Anhang
   1. A Einführung in die UML
      1. A.1 Die UML im Überblick
         1. Diagramme der UML
         2. Modellierung und Diagramm-Granularität
         3. Modellierungstools
      2. A.2 Strukturdiagramme – statische Modelle
         1. A.2.1 Klassendiagramme
            1. Elemente von Klassendiagrammen
            2. Beziehungen zwischen Klassen und Interfaces
         2. A.2.2 Objektdiagramme
         3. A.2.3 Komponentendiagramme
         4. A.2.4 Paketdiagramme
      3. A.3 Verhaltensdiagramme – dynamische Modelle
         1. A.3.1 Anwendungsfalldiagramme
            1. Granularität von Anwendungsfalldiagrammen
         2. A.3.2 Sequenzdiagramme
            1. Elemente von Sequenzdiagrammen
         3. A.3.3 Kommunikationsdiagramme
         4. A.3.4 Zustandsdiagramme
            1. Beispiel
         5. A.3.5 Aktivitätsdiagramme
            1. Beispiel
      4. A.4 Weiterführende Literatur
   2. Literaturverzeichnis
   3. Index
9. Fußnoten
   1. Kapitel 2
   2. Kapitel 3
   3. Kapitel 4
   4. A Einführung in die UML