You are previewing Der Weg zum Java-Profi.
O'Reilly logo
Der Weg zum Java-Profi

Book Description

Diese umfassende Einführung in die professionelle Java-Programmierung vermittelt Ihnen das notwendige Wissen, um stabile und erweiterbare Softwaresysteme auf Java-SE-Basis zu bauen. Praxisnahe Beispiele helfen dabei, das Gelernte rasch umzusetzen. Die Neuauflage wurde durchgehend überarbeitet, aktualisiert und erweitert. Natürlich darf das aktuelle Java 8 nicht fehlen.

Table of Contents

    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
    3. 1.3 Konventionen und ausführbare Programme
      1. 2.1 Vorteile von IDEs am Beispiel von Eclipse
      2. 2.2 Projektorganisation
        1. 2.2.1 Projektstruktur in Eclipse und Ant
        2. 2.2.2 Projektstruktur für Maven und Gradle
      3. 2.3 Einsatz von Versionsverwaltungen
        1. 2.3.1 Arbeiten mit zentralen Versionsverwaltungen
        2. 2.3.2 Dezentrale Versionsverwaltungen
        3. 2.3.3 VCS und DVCS im Vergleich
      4. 2.4 Einsatz eines Unit-Test-Frameworks
        1. 2.4.1 Das JUnit-Framework
        2. 2.4.2 Vorteile von Unit Tests
      5. 2.5 Debugging
        1. 2.5.1 Fehlersuche mit einem Debugger
        2. 2.5.2 Remote Debugging
      6. 2.6 Deployment von Java-Applikationen
        1. 2.6.1 Das JAR-Tool im Kurzüberblick
        2. 2.6.2 JAR inspizieren und ändern, Inhalt extrahieren
        3. 2.6.3 Metainformationen und das Manifest
        4. 2.6.4 Inspizieren einer JAR-Datei
      7. 2.7 Einsatz eines IDE-unabhängigen Build-Prozesses
        1. 2.7.1 Ant im Überblick
        2. 2.7.2 Maven im Überblick
        3. 2.7.3 Builds mit Gradle
        4. 2.7.4 Vergleich von Ant, Maven und Gradle
      8. 2.8 Weiterführende Literatur
      1. 3.1 OO-Grundlagen
        1. 3.1.1 Grundbegriffe
        2. 3.1.2 Beispielentwurf: Ein Zähler
        3. 3.1.3 Vom imperativen zum objektorientierten Entwurf
        4. 3.1.4 Diskussion der OO-Grundgedanken
        5. 3.1.5 Wissenswertes zum Objektzustand
      2. 3.2 Grundlegende OO-Techniken
        1. 3.2.1 Schnittstellen (Interfaces)
        2. 3.2.2 Basisklassen und abstrakte Basisklassen
        3. 3.2.3 Interfaces und abstrakte Basisklassen
      3. 3.3 Wissenswertes zu Vererbung
        1. 3.3.1 Probleme durch Vererbung
        2. 3.3.2 Delegation statt Vererbung
      4. 3.4 Fortgeschrittenere OO-Techniken
        1. 3.4.1 Read-only-Interface
        2. 3.4.2 Immutable-Klasse
        3. 3.4.3 Marker-Interface
        4. 3.4.4 Konstantensammlungen und Aufzählungen
        5. 3.4.5 Value Object (Data Transfer Object)
      5. 3.5 Prinzipien guten OO-Designs
        1. 3.5.1 Geheimnisprinzip nach Parnas
        2. 3.5.2 Law of Demeter
        3. 3.5.3 SOLID-Prinzipien
      6. 3.6 Formen der Varianz
        1. 3.6.1 Grundlagen der Varianz
        2. 3.6.2 Kovariante Rückgabewerte
      7. 3.7 Generische Typen (Generics)
        1. 3.7.1 Einführung
        2. 3.7.2 Generics und Auswirkungen der Type Erasure
      8. 3.8 Weiterführende Literatur
      1. 4.1 Die Klasse Object
        1. 4.1.1 Die Methode toString()
        2. 4.1.2 Die Methode equals()
      2. 4.2 Primitive Typen und Wrapper-Klassen
        1. 4.2.1 Grundlagen
        2. 4.2.2 Konvertierung von Werten
        3. 4.2.3 Wissenswertes zu Auto-Boxing und Auto-Unboxing
        4. 4.2.4 Ausgabe und Verarbeitung von Zahlen
      3. 4.3 Stringverarbeitung
        1. 4.3.1 Die Klasse String
        2. 4.3.2 Die Klassen StringBuffer und StringBuilder
        3. 4.3.3 Ausgaben mit format() und printf()
        4. 4.3.4 Die Klasse StringTokenizer
        5. 4.3.5 Die Methode split() und das 1x1 der regulären Ausdrücke
      4. 4.4 Datumsverarbeitung
        1. 4.4.1 Fallstricke der Datums-APIs
        2. 4.4.2 Das Date-API
        3. 4.4.3 Das Calendar-API
      5. 4.5 Innere Interfaces und innere Klassen
        1. 4.5.1 Varianten innerer Klassen
        2. 4.5.2 Innere Interfaces
        3. 4.5.3 Designbeispiel mit inneren Klassen und Interfaces
        4. 4.5.4 Lokal definierte Klassen und Interfaces
      6. 4.6 Ein- und Ausgabe (I/O)
        1. 4.6.1 Dateibehandlung und die Klasse File
        2. 4.6.2 Ein- und Ausgabestreams im Überblick
        3. 4.6.3 Zeichencodierungen bei der Ein- und Ausgabe
        4. 4.6.4 Speichern und Laden von Daten und Objekten
        5. 4.6.5 Dateiverarbeitung in JDK 7
      7. 4.7 Fehlerbehandlung
        1. 4.7.1 Einstieg in die Fehlerbehandlung
        2. 4.7.2 Checked Exceptions und Unchecked Exceptions
        3. 4.7.3 Exception Handling und Ressourcenfreigabe
        4. 4.7.4 Besonderheiten beim Exception Handling mit JDK 7
        5. 4.7.5 Assertions
      8. 4.8 Weiterführende Literatur
      1. 5.1 Datenstrukturen und Containerklasse
        1. 5.1.1 Wahl einer geeigneten Datenstruktur
        2. 5.1.2 Arrays
        3. 5.1.3 Das Interface Collection
        4. 5.1.4 Das Interface Iterator
        5. 5.1.5 Listen und das Interface List
        6. 5.1.6 Mengen und das Interface Set
        7. 5.1.7 Grundlagen von hashbasierten Containern
        8. 5.1.8 Grundlagen automatisch sortierender Container
        9. 5.1.9 Die Methoden equals(), hashCode() und compareTo() im Zusammenspiel
        10. 5.1.10 Schlüssel-Wert-Abbildungen und das Interface Map
        11. 5.1.11 Erweiterungen am Beispiel der Klasse HashMap
        12. 5.1.12 Entscheidungshilfe zur Wahl von Datenstrukturen
      2. 5.2 Suchen, Sortieren und Filtern
        1. 5.2.1 Suchen
        2. 5.2.2 Sortieren von Arrays und Listen
        3. 5.2.3 Sortieren mit Komparatoren
        4. 5.2.4 Filtern von Collections
      3. 5.3 Utility-Klassen und Hilfsmethoden
        1. 5.3.1 Nützliche Hilfsmethoden
        2. 5.3.2 Dekorierer synchronized, unmodifiable und checked
        3. 5.3.3 Vordefinierte Algorithmen
      4. 5.4 Containerklassen: Generics und Varianz
      5. 5.5 Fallstricke im Collections-Framework
        1. 5.5.1 Wissenswertes zu Arrays
        2. 5.5.2 Wissenswertes zu Stack, Queue und Deque
      6. 5.6 Weiterführende Literatur
      1. 6.1 Einsatz von Bibliotheken
      2. 6.2 Google Guava im Kurzüberblick
        1. 6.2.1 String-Aktionen
        2. 6.2.2 String-Konkatenation und -Extraktion
        3. 6.2.3 Erweiterungen für Collections
        4. 6.2.4 Weitere Utility-Funktionalitäten
      3. 6.3 Wertebereichs- und Parameterprüfungen
        1. 6.3.1 Prüfung einfacher Wertebereiche und Wertemengen
        2. 6.3.2 Prüfung komplexerer Wertebereiche
      4. 6.4 Logging-Frameworks
        1. 6.4.1 Apache log4j
        2. 6.4.2 Tipps und Tricks zum Einsatz von Logging mit log4j
      5. 6.5 Konfigurationsparameter und -dateien
        1. 6.5.1 Einlesen von Kommandozeilenparametern
        2. 6.5.2 Verarbeitung von Properties
        3. 6.5.3 Die Klasse Preferences
        4. 6.5.4 Weitere Möglichkeiten zur Konfigurationsverwaltung
      1. 7.1 Threads und Runnables
        1. 7.1.1 Definition der auszuführenden Aufgabe
        2. 7.1.2 Start, Ausführung und Ende von Threads
        3. 7.1.3 Lebenszyklus von Threads und Thread-Zustände
        4. 7.1.4 Unterbrechungswünsche durch Aufruf von interrupt()
      2. 7.2 Zusammenarbeit von Threads
        1. 7.2.1 Konkurrierende Datenzugriffe
        2. 7.2.2 Locks, Monitore und kritische Bereiche
        3. 7.2.3 Deadlocks und Starvation
        4. 7.2.4 Kritische Bereiche und das Interface Lock
      3. 7.3 Kommunikation von Threads
        1. 7.3.1 Kommunikation mit Synchronisation
        2. 7.3.2 Kommunikation über die Methoden wait(), notify() und notifyAll()
        3. 7.3.3 Abstimmung von Threads
        4. 7.3.4 Unerwartete IllegalMonitorStateExceptions
      4. 7.4 Das Java-Memory-Modell
        1. 7.4.1 Sichtbarkeit
        2. 7.4.2 Atomarität
        3. 7.4.3 Reorderings
      5. 7.5 Besonderheiten bei Threads
        1. 7.5.1 Verschiedene Arten von Threads
        2. 7.5.2 Exceptions in Threads
        3. 7.5.3 Sicheres Beenden von Threads
        4. 7.5.4 Zeitgesteuerte Ausführung
      6. 7.6 Die Concurrency Utilities
        1. 7.6.1 Concurrent Collections
        2. 7.6.2 Das Executor-Framework
        3. 7.6.3 Das Fork-Join-Framework
      7. 7.7 Weiterführende Literatur
      1. 8.1 Crashkurs Reflection
        1. 8.1.1 Grundlagen
        2. 8.1.2 Zugriff auf Methoden und Attribute
        3. 8.1.3 Spezialfälle
        4. 8.1.4 Type Erasure und Typinformationen bei Generics
      2. 8.2 Annotations
        1. 8.2.1 Einführung in Annotations
        2. 8.2.2 Standard-Annotations des JDKs
        3. 8.2.3 Definition eigener Annotations
        4. 8.2.4 Annotation zur Laufzeit auslesen
      3. 8.3 Serialisierung
        1. 8.3.1 Grundlagen der Serialisierung
        2. 8.3.2 Die Serialisierung anpassen
        3. 8.3.3 Versionsverwaltung der Serialisierung
        4. 8.3.4 Optimierung der Serialisierung
      4. 8.4 Objektkopien und das Interface Cloneable
        1. 8.4.1 Das Interface Cloneable
        2. 8.4.2 Alternativen zur Methode clone()
      5. 8.5 Garbage Collection
        1. 8.5.1 Grundlagen zur Garbage Collection
        2. 8.5.2 Herkömmliche Algorithmen zur Garbage Collection
        3. 8.5.3 Einflussfaktoren auf die Garbage Collection
        4. 8.5.4 Der Garbage Collector »G1«
        5. 8.5.5 Memory Leaks: Gibt es die auch in Java?!
        6. 8.5.6 Objektzerstörung und finalize()
      6. 8.6 Weiterführende Literatur
      1. 9.1 Grundlagen zu grafischen Oberflächen
        1. 9.1.1 Überblick: Bedienelemente und Container
        2. 9.1.2 Einführung in das Layoutmanagement
        3. 9.1.3 Komplexere Layouts (Kombination von Layoutmanagern)
        4. 9.1.4 Grundlagen zur Ereignisbehandlung
        5. 9.1.5 Weitere gebräuchliche Event Listener
        6. 9.1.6 Varianten der Ereignisverarbeitung
      2. 9.2 Multithreading und Swing
        1. 9.2.1 Crashkurs Event Handling in Swing
        2. 9.2.2 Ausführen von Aktionen
        3. 9.2.3 Die Klasse SwingWorker
      3. 9.3 Zeichnen in GUI-Komponenten
        1. 9.3.1 Generelles zum Zeichnen in GUI-Komponenten
        2. 9.3.2 Kurzeinführung in Java 2D
        3. 9.3.3 Bedienelemente mit Java 2D selbst erstellen
      4. 9.4 Komplexe Bedienelemente
        1. 9.4.1 Grundlagen
        2. 9.4.2 Die Klasse JList
        3. 9.4.3 Die Klasse JTable
        4. 9.4.4 Die Klasse JTree
      5. 9.5 Weiterführende Literatur
      1. 10.1 Internationalisierung im Überblick
        1. 10.1.1 Grundlagen und Normen
        2. 10.1.2 Die Klasse Locale
        3. 10.1.3 Die Klasse PropertyResourceBundle
        4. 10.1.4 Formatierte Ein- und Ausgabe
        5. 10.1.5 Zahlen und die Klasse NumberFormat
        6. 10.1.6 Datumswerte und die Klasse DateFormat
        7. 10.1.7 Textmeldungen und die Klasse MessageFormat
        8. 10.1.8 Stringvergleiche mit der Klasse Collator
      2. 10.2 Programmbausteine zur Internationalisierung
        1. 10.2.1 Unterstützung mehrerer Datumsformate
        2. 10.2.2 Nutzung mehrerer Sprachdateien
      1. 11.1 Einstieg in Lambdas
        1. 11.1.1 Lambdas am Beispiel
        2. 11.1.2 Functional Interfaces und SAM-Typen
        3. 11.1.3 Type Inference und Kurzformen der Syntax
        4. 11.1.4 Lambdas als Parameter und als Rückgabewerte
        5. 11.1.5 Unterschiede: Lambdas vs. anonyme innere Klassen
      2. 11.2 Defaultmethoden
        1. 11.2.1 Interface-Erweiterungen
        2. 11.2.2 Vorgabe von Standardverhalten
        3. 11.2.3 Erweiterte Möglichkeiten durch Defaultmethoden
        4. 11.2.4 Spezialfall: Was passiert bei Konflikten?
        5. 11.2.5 Vorteile und Gefahren von Defaultmethoden
        6. 11.2.6 Statische Methoden in Interfaces
      3. 11.3 Methodenreferenzen
      4. 11.4 Fazit
      1. 12.1 Externe vs. interne Iteration
        1. 12.1.1 Externe Iteration
        2. 12.1.2 Interne Iteration
        3. 12.1.3 Externe vs. interne Iteration an einem Beispiel
      2. 12.2 Collections-Erweiterungen
        1. 12.2.1 Das Interface Predicate<T>
        2. 12.2.2 Die Methode Collection.removeIf()
        3. 12.2.3 Das Interface UnaryOperator<T>
        4. 12.2.4 Die Methode List.replaceAll()
      3. 12.3 Streams
        1. 12.3.1 Streams erzeugen — Create Operations
        2. 12.3.2 Intermediate und Terminal Operations im Überblick
        3. 12.3.3 Zustandslose Intermediate Operations
        4. 12.3.4 Zustandsbehaftete Intermediate Operations
        5. 12.3.5 Terminal Operations
        6. 12.3.6 Wissenswertes zur Parallelverarbeitung
      4. 12.4 Filter-Map-Reduce
        1. 12.4.1 Herkömmliche Realisierung
        2. 12.4.2 Filter-Map-Reduce mit JDK 8
      5. 12.5 Fallstricke bei Lambdas und funktionaler Programmierung
        1. 12.5.1 Java-Fehlermeldungen werden zu komplex
        2. 12.5.2 Fallstrick: Imperative Lösung 1:1 funktional umsetzen
      6. 12.6 Fazit
      1. 13.1 Datumsverarbeitung vor JSR-310
      2. 13.2 Überblick über die neu eingeführten Klassen
        1. 13.2.1 Die Klasse Instant
        2. 13.2.2 Die Aufzählung ChronoUnit
        3. 13.2.3 Die Klasse Duration
        4. 13.2.4 Die Klassen LocalDate, LocalTime und LocalDateTime
        5. 13.2.5 Die Aufzählungen DayOfWeek und Month
        6. 13.2.6 Die Klassen YearMonth, MonthDay und Year
        7. 13.2.7 Die Klasse Period
        8. 13.2.8 Die Klasse Clock
        9. 13.2.9 Die Klasse ZonedDateTime
        10. 13.2.10 Beispiel: Berechnung einer Zeitdifferenz
        11. 13.2.11 Interoperabilität mit Legacy-Code
      3. 13.3 Fazit
      1. 14.1 Einführung – JavaFX im Überblick
        1. 14.1.1 Motivation für JavaFX und Historisches
        2. 14.1.2 Grundsätzliche Konzepte
        3. 14.1.3 Layoutmanagement
      2. 14.2 Deklarativer Aufbau des GUIs
        1. 14.2.1 Deklarative Beschreibung von GUIs
        2. 14.2.2 Hello-World-Beispiel mit FXML
        3. 14.2.3 Diskussion: Design und Funktionalität strikt trennen
      3. 14.3 Rich-Client Experience
        1. 14.3.1 Gestaltung mit CSS
        2. 14.3.2 Effekte
        3. 14.3.3 Animationen
      4. 14.4 Neuerungen in JavaFX 8
        1. 14.4.1 Unterstützung von Lambdas als EventHandler
        2. 14.4.2 Texteffekte
        3. 14.4.3 Neue Controls
        4. 14.4.4 JavaFX 3D
      5. 14.5 Fazit
      1. 15.1 Erweiterungen im Interface Comparator<T>
      2. 15.2 Die Klasse Optional<T>
        1. 15.2.1 Grundlagen zur Klasse Optional<T>
        2. 15.2.2 Weiterführendes Beispiel und Diskussion
      3. 15.3 Parallele Operationen auf Arrays
      4. 15.4 Erweiterungen im Interface Map<K,V>
      5. 15.5 Erweiterungen im NIO und der Klasse Files
      6. 15.6 Erweiterungen im Bereich Concurrency
      7. 15.7 »Nashorn« – die neue JavaScript-Engine
      8. 15.8 Keine Permanent Generation mehr
      9. 15.9 Erweiterungen im Bereich Reflection
      10. 15.10 Base64-Codierungen
      11. 15.11 Änderungen bei Annotations
      1. 16.1 Programmdesign
        1. 16.1.1 Bad Smell: Verwenden von Magic Numbers
        2. 16.1.2 Bad Smell: Konstanten in Interfaces definieren
        3. 16.1.3 Bad Smell: Zusammengehörende Konstanten nicht als Typ definiert
        4. 16.1.4 Bad Smell: Programmcode im Logging-Code
        5. 16.1.5 Bad Smell: Dominanter Logging-Code
        6. 16.1.6 Bad Smell: Unvollständige Betrachtung aller Alternativen
        7. 16.1.7 Bad Smell: Unvollständige Änderungen nach Copy-Paste
        8. 16.1.8 Bad Smell: Casts auf unbekannte Subtypen
        9. 16.1.9 Bad Smell: Pre-/Post-Increment in komplexeren Statements
        10. 16.1.10 Bad Smell: Keine Klammern um Blöcke
        11. 16.1.11 Bad Smell: Mehrere aufeinanderfolgende Parameter gleichen Typs
        12. 16.1.12 Bad Smell: Grundloser Einsatz von Reflection
        13. 16.1.13 Bad Smell: System.exit() mitten im Programm
        14. 16.1.14 Bad Smell: Variablendeklaration nicht im kleinstmöglichen Sichtbarkeitsbereich
      2. 16.2 Klassendesign
        1. 16.2.1 Bad Smell: Unnötigerweise veränderliche Attribute
        2. 16.2.2 Bad Smell: Herausgabe von this im Konstruktor
        3. 16.2.3 Bad Smell: Aufruf abstrakter Methoden im Konstruktor
        4. 16.2.4 Bad Smell: Referenzierung von Subklassen in Basisklassen
        5. 16.2.5 Bad Smell: Mix abstrakter und konkreter Basisklassen
        6. 16.2.6 Bad Smell: Öffentlicher Defaultkonstruktor lediglich zum Zugriff auf Hilfsmethoden
      3. 16.3 Fehlerbehandlung und Exception Handling
        1. 16.3.1 Bad Smell: Unbehandelte Exception
        2. 16.3.2 Bad Smell: Unpassender Exception-Typ
        3. 16.3.3 Bad Smell: Exceptions zur Steuerung des Kontrollflusses
        4. 16.3.4 Bad Smell: Fangen der allgemeinsten Exception
        5. 16.3.5 Bad Smell: Rückgabe von null statt Exception im Fehlerfall
        6. 16.3.6 Bad Smell: Unbedachte Rückgabe von null
        7. 16.3.7 Bad Smell: Sonderbehandlung von Randfällen
        8. 16.3.8 Bad Smell: Keine Gültigkeitsprüfung von Eingabeparametern
        9. 16.3.9 Bad Smell: Fehlerhafte Fehlerbehandlung
        10. 16.3.10 Bad Smell: I/O ohne finally
        11. 16.3.11 Bad Smell: Resource Leaks durch Exceptions im Konstruktor
      4. 16.4 Häufige Fallstricke
      5. 16.5 Weiterführende Literatur
      1. 17.1 Refactorings am Beispiel
      2. 17.2 Das Standardvorgehen
      3. 17.3 Kombination von Basis-Refactorings
        1. 17.3.1 Refactoring-Beispiel: Ausgangslage und Ziel
        2. 17.3.2 Auflösen der Abhängigkeiten
        3. 17.3.3 Vereinfachungen
        4. 17.3.4 Verlagern von Funktionalität
      4. 17.4 Der Refactoring-Katalog
        1. 17.4.1 Reduziere die Sichtbarkeit von Attributen
        2. 17.4.2 Minimiere veränderliche Attribute
        3. 17.4.3 Reduziere die Sichtbarkeit von Methoden
        4. 17.4.4 Ersetze Mutator- durch Business-Methode
        5. 17.4.5 Minimiere Zustandsänderungen
        6. 17.4.6 Führe ein Interface ein
        7. 17.4.7 Spalte ein Interface auf
        8. 17.4.8 Führe ein Read-only-Interface ein
        9. 17.4.9 Führe ein Read-Write-Interface ein
        10. 17.4.10 Lagere Funktionalität in Hilfsmethoden aus
        11. 17.4.11 Trenne Informationsbeschaffung und -verarbeitung
        12. 17.4.12 Wandle Konstantensammlung in enum um
        13. 17.4.13 Entferne Exceptions zur Steuerung des Kontrollflusses
        14. 17.4.14 Wandle in Utility-Klasse mit statischen Hilfsmethoden um
      5. 17.5 Defensives Programmieren
        1. 17.5.1 Führe eine Zustandsprüfung ein
        2. 17.5.2 Überprüfe Eingabeparameter
      6. 17.6 Weiterführende Literatur
      1. 18.1 Erzeugungsmuster
        1. 18.1.1 Erzeugungsmethode
        2. 18.1.2 Fabrikmethode (Factory method)
        3. 18.1.3 Erbauer (Builder)
        4. 18.1.4 Singleton
        5. 18.1.5 Prototyp (Prototype)
      2. 18.2 Strukturmuster
        1. 18.2.1 Fassade (Façade)
        2. 18.2.2 Adapter
        3. 18.2.3 Dekorierer (Decorator)
        4. 18.2.4 Kompositum (Composite)
      3. 18.3 Verhaltensmuster
        1. 18.3.1 Iterator
        2. 18.3.2 Null-Objekt (Null Object)
        3. 18.3.3 Schablonenmethode (Template method)
        4. 18.3.4 Strategie (Strategy)
        5. 18.3.5 Befehl (Command)
        6. 18.3.6 Proxy
        7. 18.3.7 Beobachter (Observer)
        8. 18.3.8 MVC-Architektur
      4. 18.4 Weiterführende Literatur
      1. 19.1 Grundregeln eines guten Programmierstils
        1. 19.1.1 Keep It Human-Readable
        2. 19.1.2 Keep It Simple And Short (KISS)
        3. 19.1.3 Keep It Natural
        4. 19.1.4 Keep It Clean
      2. 19.2 Die Psychologie beim Sourcecode-Layout
        1. 19.2.1 Gesetz der Ähnlichkeit
        2. 19.2.2 Gesetz der Nähe
      3. 19.3 Coding Conventions
        1. 19.3.1 Grundlegende Namens- und Formatierungsregeln
        2. 19.3.2 Namensgebung
        3. 19.3.3 Dokumentation
        4. 19.3.4 Programmdesign
        5. 19.3.5 Klassendesign
        6. 19.3.6 Parameterlisten
        7. 19.3.7 Logik und Kontrollfluss
      4. 19.4 Sourcecode-Prüfung mit Tools
        1. 19.4.1 Metriken
        2. 19.4.2 Sourcecode-Prüfung im Build-Prozess
      1. 20.1 Testen im Überblick
        1. 20.1.1 Was versteht man unter Testen?
        2. 20.1.2 Testarten im Überblick
        3. 20.1.3 Zuständigkeiten beim Testen
        4. 20.1.4 Testen und Qualität
      2. 20.2 Wissenswertes zu Testfällen
        1. 20.2.1 Test-Driven Development (TDD) im Überblick
        2. 20.2.2 Testfälle mit JUnit 4 definieren
        3. 20.2.3 Problem der Komplexität
      3. 20.3 Motivation für Unit Tests aus der Praxis
        1. 20.3.1 Unit Tests für Weiterentwicklungen
        2. 20.3.2 Unit Tests und Legacy-Code
      4. 20.4 Fortgeschrittene Unit-Test-Techniken
        1. 20.4.1 Test-Doubles
        2. 20.4.2 Testen mit Stubs
        3. 20.4.3 Testen mit Mocks
        4. 20.4.4 Unit Tests von privaten Methoden
      5. 20.5 Unit Tests mit Threads und Timing
      6. 20.6 Test Smells
      7. 20.7 JUnit Rules und parametrierte Tests
        1. 20.7.1 JUnit Rules im Überblick
        2. 20.7.2 Parametrierte Tests
      8. 20.8 Nützliche Tools für Unit Tests
        1. 20.8.1 Hamcrest
        2. 20.8.2 MoreUnit
        3. 20.8.3 Infinitest
        4. 20.8.4 Cobertura
        5. 20.8.5 EclEmma
      9. 20.9 Schlussgedanken
      10. 20.10 Weiterführende Literatur
      1. 21.1 Definition
      2. 21.2 Probleme und Tipps zur Durchführung
      3. 21.3 Vorteile von Codereviews
      4. 21.4 Codereview-Tools
      5. 21.5 Codereview-Checkliste
      1. 22.1 Grundlagen
        1. 22.1.1 Optimierungsebenen und Einflussfaktoren
        2. 22.1.2 Optimierungstechniken
        3. 22.1.3 CPU-bound-Optimierungsebenen am Beispiel
        4. 22.1.4 Messungen – Erkennen kritischer Bereiche
        5. 22.1.5 Abschätzungen mit der O-Notation
      2. 22.2 Einsatz geeigneter Datenstrukturen
        1. 22.2.1 Einfluss von Arrays und Listen
        2. 22.2.2 Optimierungen für Set und Map
        3. 22.2.3 Design eines Zugriffsinterface
      3. 22.3 Lazy Initialization
        1. 22.3.1 Lazy Initialization am Beispiel
        2. 22.3.2 Konsequenzen des Einsatzes der Lazy Initialization
        3. 22.3.3 Lazy Initialization mithilfe des PROXY-Musters
      4. 22.4 Optimierungen am Beispiel
      5. 22.5 I/O-bound-Optimierungen
        1. 22.5.1 Technik – Wahl passender Strategien
        2. 22.5.2 Technik – Caching und Pooling
        3. 22.5.3 Technik – Vermeidung unnötiger Aktionen
      6. 22.6 Memory-bound-Optimierungen
        1. 22.6.1 Technik – Wahl passender Strategien
        2. 22.6.2 Technik – Caching und Pooling
        3. 22.6.3 Optimierungen der Stringverarbeitung
        4. 22.6.4 Technik – Vermeidung unnötiger Aktionen
      7. 22.7 CPU-bound-Optimierungen
        1. 22.7.1 Technik – Wahl passender Strategien
        2. 22.7.2 Technik – Caching und Pooling
        3. 22.7.3 Technik – Vermeidung unnötiger Aktionen
      8. 22.8 Weiterführende Literatur
      1. A.1 Die UML im Überblick
      2. A.2 Strukturdiagramme – statische Modelle
        1. A.2.1 Klassendiagramme
        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
        2. A.3.2 Sequenzdiagramme
        3. A.3.3 Kommunikationsdiagramme
        4. A.3.4 Zustandsdiagramme
        5. A.3.5 Aktivitätsdiagramme
      4. A.4 Weiterführende Literatur
      1. B.1 Vorgehensmodelle
        1. B.1.1 Aufgaben und Phasen beim Softwareentwurf
        2. B.1.2 Wasserfallmodell und V-Modell
        3. B.1.3 Extreme Programming (XP)
        4. B.1.4 Test-Driven Development (TDD)
      1. C.1 Wissenswertes rund um die Java Virtual Machine
        1. C.1.1 Ausführung eines Java-Programms
        2. C.1.2 Sicherheit und Speicherverwaltung
        3. C.1.3 Sicherheit und Classloading