O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Der Weg zum Java-Profi, 4th Edition

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 9 nicht fehlen.

Table of Contents

  1. Cover
  2. Die Autorin
  3. Titel
  4. Impressum
  5. Inhaltsübersicht
  6. Inhaltsverzeichnis
  7. Vorwort zur 4. Auflage
  8. 1 Einleitung
    1. 1.1 Über dieses Buch
    2. 1.1.1 Motivation
    3. 1.1.2 Was leistet dieses Buch und was nicht?
    4. 1.1.3 Wie und was soll mithilfe des Buchs gelernt werden?
    5. 1.1.4 Wer sollte dieses Buch lesen?
    6. 1.2 Aufbau des Buchs
    7. 1.3 Konventionen und ausführbare Programme
  9. I Java-Grundlagen, Analyse und Design
    1. 2 Professionelle Arbeitsumgebung
    2. 2.1 Vorteile von IDEs am Beispiel von Eclipse
    3. 2.2 Projektorganisation
    4. 2.2.1 Projektstruktur in Eclipse
    5. 2.2.2 Projektstruktur für Maven und Gradle
    6. 2.3 Einsatz von Versionsverwaltungen
    7. 2.3.1 Arbeiten mit zentralen Versionsverwaltungen
    8. 2.3.2 Dezentrale Versionsverwaltungen
    9. 2.3.3 VCS und DVCS im Vergleich
    10. 2.4 Einsatz eines Unit-Test-Frameworks
    11. 2.4.1 Das JUnit-Framework
    12. 2.4.2 Vorteile von Unit Tests
    13. 2.5 Debugging
    14. 2.5.1 Fehlersuche mit einem Debugger
    15. 2.5.2 Remote Debugging
    16. 2.6 Deployment von Java-Applikationen
    17. 2.6.1 Das JAR-Tool im Kurzüberblick
    18. 2.6.2 JAR inspizieren und ändern, Inhalt extrahieren
    19. 2.6.3 Metainformationen und das Manifest
    20. 2.6.4 Inspizieren einer JAR-Datei
    21. 2.7 Einsatz eines IDE-unabhängigen Build-Prozesses
    22. 2.7.1 Maven im Überblick
    23. 2.7.2 Builds mit Gradle
    24. 2.7.3 Vorteile von Maven und Gradle
    25. 2.8 Weiterführende Literatur
    26. 3 Objektorientiertes Design
    27. 3.1 OO-Grundlagen
    28. 3.1.1 Grundbegriffe
    29. 3.1.2 Beispielentwurf: Ein Zähler
    30. 3.1.3 Vom imperativen zum objektorientierten Entwurf
    31. 3.1.4 Diskussion der OO-Grundgedanken
    32. 3.1.5 Wissenswertes zum Objektzustand
    33. 3.2 Grundlegende OO-Techniken
    34. 3.2.1 Schnittstellen (Interfaces)
    35. 3.2.2 Basisklassen und abstrakte Basisklassen
    36. 3.2.3 Interfaces und abstrakte Basisklassen
    37. 3.3 Wissenswertes zu Vererbung
    38. 3.3.1 Probleme durch Vererbung
    39. 3.3.2 Delegation statt Vererbung
    40. 3.4 Fortgeschrittenere OO-Techniken
    41. 3.4.1 Read-only-Interface
    42. 3.4.2 Immutable-Klasse
    43. 3.4.3 Marker-Interface
    44. 3.4.4 Konstantensammlungen und Aufzählungen
    45. 3.4.5 Value Object (Data Transfer Object)
    46. 3.5 Prinzipien guten OO-Designs
    47. 3.5.1 Geheimnisprinzip nach Parnas
    48. 3.5.2 Law of Demeter
    49. 3.5.3 SOLID-Prinzipien
    50. 3.6 Formen der Varianz
    51. 3.6.1 Grundlagen der Varianz
    52. 3.6.2 Kovariante Rückgabewerte
    53. 3.7 Generische Typen (Generics)
    54. 3.7.1 Einführung
    55. 3.7.2 Generics und Auswirkungen der Type Erasure
    56. 3.8 Weiterführende Literatur
    57. 4 Java-Grundlagen
    58. 4.1 Die Klasse Object
    59. 4.1.1 Die Methode toString()
    60. 4.1.2 Die Methode equals()
    61. 4.2 Primitive Typen und Wrapper-Klassen
    62. 4.2.1 Grundlagen
    63. 4.2.2 Konvertierung von Werten
    64. 4.2.3 Wissenswertes zu Auto-Boxing und Auto-Unboxing
    65. 4.2.4 Ausgabe und Verarbeitung von Zahlen
    66. 4.3 Stringverarbeitung
    67. 4.3.1 Die Klasse String
    68. 4.3.2 Die Klassen StringBuffer und StringBuilder
    69. 4.3.3 Ausgaben mit format() und printf()
    70. 4.3.4 Die Methode split() und reguläre Ausdrücke
    71. 4.4 Datumsverarbeitung
    72. 4.4.1 Fallstricke der Datums-APIs
    73. 4.4.2 Das Date-API
    74. 4.4.3 Das Calendar-API
    75. 4.5 Varianten innerer Klassen
    76. 4.6 Ein- und Ausgabe (I/O)
    77. 4.6.1 Dateibehandlung und die Klasse File
    78. 4.6.2 Ein- und Ausgabestreams im Überblick
    79. 4.6.3 Zeichencodierungen bei der Ein- und Ausgabe
    80. 4.6.4 Speichern und Laden von Daten und Objekten
    81. 4.6.5 Dateiverarbeitung in JDK 7
    82. 4.6.6 Erweiterungen im NIO und der Klasse Files in JDK 8
    83. 4.7 Fehlerbehandlung
    84. 4.7.1 Einstieg in die Fehlerbehandlung
    85. 4.7.2 Checked Exceptions und Unchecked Exceptions
    86. 4.7.3 Exception Handling und Ressourcenfreigabe
    87. 4.7.4 Besonderheiten beim Exception Handling mit JDK 7
    88. 4.7.5 Assertions
    89. 4.8 Weiterführende Literatur
    90. 5 Lambdas, Methodenreferenzen und Defaultmethoden
    91. 5.1 Einstieg in Lambdas
    92. 5.1.1 Syntax von Lambdas
    93. 5.1.2 Functional Interfaces und SAM-Typen
    94. 5.1.3 Exceptions in Lambdas
    95. 5.2 Syntaxerweiterungen in Interfaces
    96. 5.2.1 Defaultmethoden
    97. 5.2.2 Statische Methoden in Interfaces
    98. 5.3 Methodenreferenzen
    99. 5.4 Externe vs. interne Iteration
    100. 5.5 Wichtige Functional Interfaces für Collections
    101. 5.5.1 Das Interface Predicate<T>
    102. 5.5.2 Das Interface UnaryOperator<T>
    103. 5.5.3 Fazit
  10. II Bausteine stabiler Java-Applikationen
    1. 6 Das Collections-Framework
    2. 6.1 Datenstrukturen und Containerklasse
    3. 6.1.1 Wahl einer geeigneten Datenstruktur
    4. 6.1.2 Arrays
    5. 6.1.3 Das Interface Collection
    6. 6.1.4 Das Interface Iterator
    7. 6.1.5 Listen und das Interface List
    8. 6.1.6 Mengen und das Interface Set
    9. 6.1.7 Grundlagen von hashbasierten Containern
    10. 6.1.8 Grundlagen automatisch sortierender Container
    11. 6.1.9 Die Methoden equals(), hashCode() und compareTo() im Zusammenspiel
    12. 6.1.10 Schlüssel-Wert-Abbildungen und das Interface Map
    13. 6.1.11 Erweiterungen am Beispiel der Klasse HashMap
    14. 6.1.12 Erweiterungen im Interface Map mit JDK 8
    15. 6.1.13 Entscheidungshilfe zur Wahl von Datenstrukturen
    16. 6.2 Suchen und Sortieren
    17. 6.2.1 Suchen
    18. 6.2.2 Sortieren von Arrays und Listen
    19. 6.2.3 Sortieren mit Komparatoren
    20. 6.2.4 Erweiterungen im Interface Comparator mit JDK 8
    21. 6.3 Utility-Klassen und Hilfsmethoden
    22. 6.3.1 Nützliche Hilfsmethoden
    23. 6.3.2 Dekorierer synchronized, unmodifiable und checked
    24. 6.3.3 Vordefinierte Algorithmen in der Klasse Collections
    25. 6.4 Containerklassen: Generics und Varianz
    26. 6.5 Die Klasse Optional
    27. 6.5.1 Grundlagen zur Klasse Optional
    28. 6.5.2 Weiterführendes Beispiel und Diskussion
    29. 6.5.3 Verkettete Methodenaufrufe
    30. 6.6 Fallstricke im Collections-Framework
    31. 6.6.1 Wissenswertes zu Arrays
    32. 6.6.2 Wissenswertes zu Stack, Queue und Deque
    33. 6.7 Weiterführende Literatur
    34. 7 Bulk Operations on Collections
    35. 7.1 Streams
    36. 7.1.1 Streams erzeugen – Create Operations
    37. 7.1.2 Intermediate und Terminal Operations im Überblick
    38. 7.1.3 Zustandslose Intermediate Operations
    39. 7.1.4 Zustandsbehaftete Intermediate Operations
    40. 7.1.5 Terminal Operations
    41. 7.1.6 Wissenswertes zur Parallelverarbeitung
    42. 7.2 Filter-Map-Reduce
    43. 7.2.1 Herkömmliche Realisierung
    44. 7.2.2 Filter-Map-Reduce mit JDK 8
    45. 7.3 Praxisbeispiele
    46. 7.3.1 Aufbereiten von Gruppierungen und Histogrammen
    47. 7.3.2 Maps nach Wert sortieren
    48. 7.3.3 Verarbeitung von ZIP-Dateien
    49. 8 Applikationsbausteine
    50. 8.1 Einsatz von Bibliotheken
    51. 8.2 Google Guava im Kurzüberblick
    52. 8.2.1 String-Aktionen
    53. 8.2.2 Stringkonkatenation und -extraktion
    54. 8.2.3 Erweiterungen für Collections
    55. 8.2.4 Weitere Utility-Funktionalitäten
    56. 8.3 Wertebereichs- und Parameterprüfungen
    57. 8.3.1 Prüfung einfacher Wertebereiche und Wertemengen
    58. 8.3.2 Prüfung komplexerer Wertebereiche
    59. 8.4 Logging-Frameworks
    60. 8.4.1 Apache log4j2
    61. 8.4.2 Tipps und Tricks zum Einsatz von Logging mit log4j2
    62. 8.5 Konfigurationsparameter und -dateien
    63. 8.5.1 Einlesen von Kommandozeilenparametern
    64. 8.5.2 Verarbeitung von Properties
    65. 8.5.3 Die Klasse Preferences
    66. 8.5.4 Weitere Möglichkeiten zur Konfigurationsverwaltung
    67. 9 Multithreading
    68. 9.1 Threads und Runnables
    69. 9.1.1 Definition der auszuführenden Aufgabe
    70. 9.1.2 Start, Ausführung und Ende von Threads
    71. 9.1.3 Lebenszyklus von Threads und Thread-Zustände
    72. 9.1.4 Unterbrechungswünsche durch Aufruf von interrupt()
    73. 9.2 Zusammenarbeit von Threads
    74. 9.2.1 Konkurrierende Datenzugriffe
    75. 9.2.2 Locks, Monitore und kritische Bereiche
    76. 9.2.3 Deadlocks und Starvation
    77. 9.2.4 Kritische Bereiche und das Interface Lock
    78. 9.3 Kommunikation von Threads
    79. 9.3.1 Kommunikation mit Synchronisation
    80. 9.3.2 Kommunikation über die Methoden wait(), notify() und notifyAll()
    81. 9.3.3 Abstimmung von Threads
    82. 9.3.4 Unerwartete IllegalMonitorStateExceptions
    83. 9.4 Das Java-Memory-Modell
    84. 9.4.1 Sichtbarkeit
    85. 9.4.2 Atomarität
    86. 9.4.3 Reorderings
    87. 9.5 Besonderheiten bei Threads
    88. 9.5.1 Verschiedene Arten von Threads
    89. 9.5.2 Exceptions in Threads
    90. 9.5.3 Sicheres Beenden von Threads
    91. 9.5.4 Zeitgesteuerte Ausführung
    92. 9.6 Die Concurrency Utilities
    93. 9.6.1 Concurrent Collections
    94. 9.6.2 Das Executor-Framework
    95. 9.6.3 Das Fork-Join-Framework
    96. 9.6.4 Erweiterungen im Bereich Concurrency mit JDK 8
    97. 9.7 Weiterführende Literatur
    98. 10 Fortgeschrittene Java-Themen
    99. 10.1 Crashkurs Reflection
    100. 10.1.1 Grundlagen
    101. 10.1.2 Zugriff auf Methoden und Attribute
    102. 10.1.3 Spezialfälle
    103. 10.1.4 Type Erasure und Typinformationen bei Generics
    104. 10.2 Annotations
    105. 10.2.1 Einführung in Annotations
    106. 10.2.2 Standard-Annotations des JDKs
    107. 10.2.3 Definition eigener Annotations
    108. 10.2.4 Annotation zur Laufzeit auslesen
    109. 10.3 Serialisierung
    110. 10.3.1 Grundlagen der Serialisierung
    111. 10.3.2 Die Serialisierung anpassen
    112. 10.3.3 Versionsverwaltung der Serialisierung
    113. 10.3.4 Optimierung der Serialisierung
    114. 10.4 Garbage Collection
    115. 10.4.1 Grundlagen zur Garbage Collection
    116. 10.4.2 Herkömmliche Algorithmen zur Garbage Collection
    117. 10.4.3 Einflussfaktoren auf die Garbage Collection
    118. 10.4.4 Der Garbage Collector »G1«
    119. 10.4.5 Memory Leaks: Gibt es die auch in Java?!
    120. 10.5 Dynamic Proxies
    121. 10.5.1 Statischer Proxy
    122. 10.5.2 Dynamischer Proxy
    123. 10.6 »Nashorn« – die JavaScript-Engine
    124. 10.7 Weiterführende Literatur
    125. 11 Datumsverarbeitung seit JDK 8
    126. 11.1 Überblick über die neu eingeführten Typen
    127. 11.1.1 Neue Aufzählungen, Klassen und Interfaces
    128. 11.1.2 Die Aufzählungen DayOfWeek und Month
    129. 11.1.3 Die Klassen MonthDay, YearMonth und Year
    130. 11.1.4 Die Klasse Instant
    131. 11.1.5 Die Klasse Duration
    132. 11.1.6 Die Aufzählung ChronoUnit
    133. 11.1.7 Die Klassen LocalDate, LocalTime und LocalDateTime
    134. 11.1.8 Die Klasse Period
    135. 11.1.9 Die Klasse ZonedDateTime
    136. 11.1.10 Zeitzonen und die Klassen ZoneId und ZoneOffset
    137. 11.1.11 Die Klasse Clock
    138. 11.1.12 Formatierung und Parsing
    139. 11.2 Datumsarithmetik
    140. 11.3 Interoperabilität mit Legacy-Code
    141. 12 GUIs mit JavaFX
    142. 12.1 Einführung – JavaFX im Überblick
    143. 12.1.1 Grundsätzliche Konzepte
    144. 12.1.2 Layoutmanagement
    145. 12.2 Deklarativer Aufbau des GUIs
    146. 12.2.1 Deklarative Beschreibung von GUIs
    147. 12.2.2 Hello-World-Beispiel mit FXML
    148. 12.2.3 Diskussion: Design und Funktionalität strikt trennen
    149. 12.3 Rich-Client Experience
    150. 12.3.1 Gestaltung mit CSS
    151. 12.3.2 Effekte
    152. 12.3.3 Animationen
    153. 12.3.4 Zeichnen in JavaFX-Komponenten
    154. 12.4 Properties, Bindings und Observable Collections
    155. 12.4.1 Properties
    156. 12.4.2 Bindings
    157. 12.4.3 Observable Collections
    158. 12.4.4 Dynamisches Filtern von ObservableList
    159. 12.5 Wichtige Bedienelemente
    160. 12.5.1 Dialoge
    161. 12.5.2 Formatierte Eingabe in TextFields
    162. 12.5.3 Die Bedienelemente ComboBox und ListView
    163. 12.5.4 Tabellen und das Bedienelement TableView
    164. 12.5.5 Das Bedienelement TreeTableView
    165. 12.5.6 Menüs
    166. 12.6 Multithreading in JavaFX
    167. 12.6.1 Das Interface Worker
    168. 12.6.2 Die Klasse Task<V>
    169. 12.7 Von Swing zu JavaFX
    170. 12.7.1 JavaFX in Swing einbinden
    171. 12.7.2 Swing in JavaFX einbinden
    172. 12.8 Weiterführende Literatur
    173. 13 Basiswissen Internationalisierung
    174. 13.1 Internationalisierung im Überblick
    175. 13.1.1 Grundlagen und Normen
    176. 13.1.2 Die Klasse Locale
    177. 13.1.3 Die Klasse PropertyResourceBundle
    178. 13.1.4 Formatierte Ein- und Ausgabe
    179. 13.1.5 Zahlen und die Klasse NumberFormat
    180. 13.1.6 Datumswerte und die Klasse DateFormat
    181. 13.1.7 Textmeldungen und die Klasse MessageFormat
    182. 13.1.8 Stringvergleiche mit der Klasse Collator
    183. 13.2 Programmbausteine zur Internationalisierung
    184. 13.2.1 Unterstützung mehrerer Datumsformate
    185. 13.2.2 Nutzung mehrerer Sprachdateien
  11. III Neuerungen in Java 9
    1. 14 Ergänzungen in Java 9
    2. 14.1 Syntaxerweiterungen
    3. 14.1.1 Anonyme innere Klassen und der Diamond Operator
    4. 14.1.2 Erweiterung der @Deprecated-Annotation
    5. 14.1.3 Private Methoden in Interfaces
    6. 14.2 Neues und Änderungen im JDK
    7. 14.2.1 Das neue Process-API
    8. 14.2.2 Neuerungen im Stream-API
    9. 14.2.3 Erweiterungen rund um die Klasse Optional
    10. 14.2.4 Erweiterungen in der Klasse InputStream
    11. 14.2.5 Erweiterungen in der Klasse Objects
    12. 14.2.6 Erweiterungen in der Klasse CompletableFuture
    13. 14.2.7 Collection-Factory-Methoden
    14. 14.3 Änderungen in der JVM
    15. 14.3.1 Garbage Collection
    16. 14.3.2 Browser-Plugin ist deprecated
    17. 14.3.3 Änderung des Versionsschemas
    18. 14.3.4 HTML5 Javadoc
    19. 14.3.5 Java + REPL => jshell
    20. 14.4 Fazit
    21. 15 Modularisierung mit Project Jigsaw
    22. 15.1 Grundlagen
    23. 15.1.1 Begrifflichkeiten
    24. 15.1.2 Ziele von Project Jigsaw
    25. 15.2 Modularisierung im Überblick
    26. 15.2.1 Grundlagen zu Project Jigsaw
    27. 15.2.2 Beispiel mit zwei Modulen
    28. 15.2.3 Packaging
    29. 15.2.4 Linking
    30. 15.2.5 Abhängigkeiten und Modulgraphen
    31. 15.2.6 Module des JDKs einbinden
    32. 15.2.7 Arten von Modulen
    33. 15.3 Sichtbarkeiten und Zugriffsschutz
    34. 15.3.1 Sichtbarkeiten
    35. 15.3.2 Zugriffsschutz und Reflection
    36. 15.4 Kompatibilität und Migration
    37. 15.4.1 Kompatibilitätsmodus
    38. 15.4.2 Migrationsszenarien
    39. 15.4.3 Fallstrick bei der Bottom-up-Migration
    40. 15.4.4 Beispiel: Migration mit Automatic Modules
    41. 15.4.5 Beispiel: Automatic und Unnamed Module
    42. 15.4.6 Mögliche Schwierigkeiten bei Migrationen
    43. 15.4.7 Fazit
    44. 15.5 Zusammenfassung
  12. IV Fallstricke und Lösungen im Praxisalltag
    1. 16 Bad Smells
    2. 16.1 Programmdesign
    3. 16.1.1 Bad Smell: Verwenden von Magic Numbers
    4. 16.1.2 Bad Smell: Konstanten in Interfaces definieren
    5. 16.1.3 Bad Smell: Zusammengehörende Konstanten nicht als Typ definiert
    6. 16.1.4 Bad Smell: Programmcode im Logging-Code
    7. 16.1.5 Bad Smell: Dominanter Logging-Code
    8. 16.1.6 Bad Smell: Unvollständige Betrachtung aller Alternativen
    9. 16.1.7 Bad Smell: Unvollständige Änderungen nach Copy-Paste
    10. 16.1.8 Bad Smell: Casts auf unbekannte Subtypen
    11. 16.1.9 Bad Smell: Pre-/Post-Increment in komplexeren Statements
    12. 16.1.10 Bad Smell: Keine Klammern um Blöcke
    13. 16.1.11 Bad Smell: Mehrere aufeinanderfolgende Parameter gleichen Typs
    14. 16.1.12 Bad Smell: Grundloser Einsatz von Reflection
    15. 16.1.13 Bad Smell: System.exit() mitten im Programm
    16. 16.1.14 Bad Smell: Variablendeklaration nicht im kleinstmöglichen Sichtbarkeitsbereich
    17. 16.2 Klassendesign
    18. 16.2.1 Bad Smell: Unnötigerweise veränderliche Attribute
    19. 16.2.2 Bad Smell: Herausgabe von this im Konstruktor
    20. 16.2.3 Bad Smell: Aufruf abstrakter Methoden im Konstruktor
    21. 16.2.4 Bad Smell: Referenzierung von Subklassen in Basisklassen
    22. 16.2.5 Bad Smell: Mix abstrakter und konkreter Basisklassen
    23. 16.2.6 Bad Smell: Öffentlicher Defaultkonstruktor lediglich zum Zugriff auf Hilfsmethoden
    24. 16.3 Fehlerbehandlung und Exception Handling
    25. 16.3.1 Bad Smell: Unbehandelte Exception
    26. 16.3.2 Bad Smell: Unpassender Exception-Typ
    27. 16.3.3 Bad Smell: Exceptions zur Steuerung des Kontrollflusses
    28. 16.3.4 Bad Smell: Fangen der allgemeinsten Exception
    29. 16.3.5 Bad Smell: Rückgabe von null statt Exception im Fehlerfall
    30. 16.3.6 Bad Smell: Unbedachte Rückgabe von null
    31. 16.3.7 Bad Smell: Sonderbehandlung von Randfällen
    32. 16.3.8 Bad Smell: Keine Gültigkeitsprüfung von Eingabeparametern
    33. 16.3.9 Bad Smell: Fehlerhafte Fehlerbehandlung
    34. 16.3.10 Bad Smell: I/O ohne finally oder ARM
    35. 16.3.11 Bad Smell: Resource Leaks durch Exceptions im Konstruktor
    36. 16.4 Häufige Fallstricke
    37. 16.5 Weiterführende Literatur
    38. 17 Refactorings
    39. 17.1 Refactorings am Beispiel
    40. 17.2 Das Standardvorgehen
    41. 17.3 Kombination von Basis-Refactorings
    42. 17.3.1 Refactoring-Beispiel: Ausgangslage und Ziel
    43. 17.3.2 Auflösen der Abhängigkeiten
    44. 17.3.3 Vereinfachungen
    45. 17.3.4 Verlagern von Funktionalität
    46. 17.4 Der Refactoring-Katalog
    47. 17.4.1 Reduziere die Sichtbarkeit von Attributen
    48. 17.4.2 Minimiere veränderliche Attribute
    49. 17.4.3 Reduziere die Sichtbarkeit von Methoden
    50. 17.4.4 Ersetze Mutator- durch Business-Methode
    51. 17.4.5 Minimiere Zustandsänderungen
    52. 17.4.6 Führe ein Interface ein
    53. 17.4.7 Spalte ein Interface auf
    54. 17.4.8 Führe ein Read-only-Interface ein
    55. 17.4.9 Führe ein Read-Write-Interface ein
    56. 17.4.10 Lagere Funktionalität in Hilfsmethoden aus
    57. 17.4.11 Trenne Informationsbeschaffung und -verarbeitung
    58. 17.4.12 Wandle Konstantensammlung in enum um
    59. 17.4.13 Entferne Exceptions zur Steuerung des Kontrollflusses
    60. 17.4.14 Wandle in Utility-Klasse mit statischen Hilfsmethoden um
    61. 17.4.15 Löse if-else / instanceof durch Polymorphie auf
    62. 17.5 Defensives Programmieren
    63. 17.5.1 Führe eine Zustandsprüfung ein
    64. 17.5.2 Überprüfe Eingabeparameter
    65. 17.6 Falllstricke bei Refactorings
    66. 17.7 Weiterführende Literatur
    67. 18 Entwurfsmuster
    68. 18.1 Erzeugungsmuster
    69. 18.1.1 Erzeugungsmethode
    70. 18.1.2 Fabrikmethode (Factory method)
    71. 18.1.3 Erbauer (Builder)
    72. 18.1.4 Singleton
    73. 18.1.5 Prototyp (Prototype)
    74. 18.2 Strukturmuster
    75. 18.2.1 Fassade (Façade)
    76. 18.2.2 Adapter
    77. 18.2.3 Dekorierer (Decorator)
    78. 18.2.4 Kompositum (Composite)
    79. 18.3 Verhaltensmuster
    80. 18.3.1 Iterator
    81. 18.3.2 Null-Objekt (Null Object)
    82. 18.3.3 Schablonenmethode (Template method)
    83. 18.3.4 Strategie (Strategy)
    84. 18.3.5 Befehl (Command)
    85. 18.3.6 Proxy
    86. 18.3.7 Beobachter (Observer)
    87. 18.3.8 MVC-Architektur
    88. 18.4 Weiterführende Literatur
  13. V Qualitätssicherungsmaßnahmen
    1. 19 Programmierstil und Coding Conventions
    2. 19.1 Grundregeln eines guten Programmierstils
    3. 19.1.1 Keep It Human-Readable
    4. 19.1.2 Keep It Simple And Short (KISS)
    5. 19.1.3 Keep It Natural
    6. 19.1.4 Keep It Clean
    7. 19.2 Die Psychologie beim Sourcecode-Layout
    8. 19.2.1 Gesetz der Ähnlichkeit
    9. 19.2.2 Gesetz der Nähe
    10. 19.3 Coding Conventions
    11. 19.3.1 Grundlegende Namens- und Formatierungsregeln
    12. 19.3.2 Namensgebung
    13. 19.3.3 Dokumentation
    14. 19.3.4 Programmdesign
    15. 19.3.5 Klassendesign
    16. 19.3.6 Parameterlisten
    17. 19.3.7 Logik und Kontrollfluss
    18. 19.4 Sourcecode-Prüfung mit Tools
    19. 19.4.1 Metriken
    20. 19.4.2 Sourcecode-Prüfung im Build-Prozess
    21. 20 Unit Tests
    22. 20.1 Testen im Überblick
    23. 20.1.1 Was versteht man unter Testen?
    24. 20.1.2 Testarten im Überblick
    25. 20.1.3 Zuständigkeiten beim Testen
    26. 20.1.4 Testen und Qualität
    27. 20.2 Wissenswertes zu Testfällen
    28. 20.2.1 Testfälle mit JUnit 4 definieren
    29. 20.2.2 Problem der Kombinatorik
    30. 20.3 Motivation für Unit Tests aus der Praxis
    31. 20.4 JUnit Rules und parametrierte Tests
    32. 20.4.1 JUnit Rules im Überblick
    33. 20.4.2 Parametrierte Tests
    34. 20.5 Fortgeschrittene Unit-Test-Techniken
    35. 20.5.1 Stellvertreterobjekte / Test-Doubles
    36. 20.5.2 Vorarbeiten für das Testen mit Stubs und Mocks
    37. 20.5.3 Die Technik EXTRACT AND OVERRIDE
    38. 20.5.4 Einstieg in das Testen mit Mocks und Mockito
    39. 20.5.5 Abhängigkeiten mit Mockito auflösen
    40. 20.5.6 Unit Tests von privaten Methoden
    41. 20.6 Unit Tests mit Threads und Timing
    42. 20.6.1 Funktionale Erweiterung: Aggregation und Versand
    43. 20.6.2 Test der Aggregation und des Versands
    44. 20.6.3 Test des nebenläufigen Versands
    45. 20.7 Test Smells
    46. 20.8 Nützliche Tools für Unit Tests
    47. 20.8.1 Hamcrest
    48. 20.8.2 MoreUnit
    49. 20.8.3 Infinitest
    50. 20.8.4 JaCoCo
    51. 20.8.5 EclEmma
    52. 20.9 Ausblick auf JUnit 5
    53. 20.9.1 Einführendes Beispiel
    54. 20.9.2 Wichtige Neuerungen in JUnit 5 im Überblick
    55. 20.10 Weiterführende Literatur
    56. 21 Codereviews
    57. 21.1 Definition
    58. 21.2 Probleme und Tipps zur Durchführung
    59. 21.3 Vorteile von Codereviews
    60. 21.4 Codereview-Checkliste
    61. 22 Optimierungen
    62. 22.1 Grundlagen
    63. 22.1.1 Optimierungsebenen und Einflussfaktoren
    64. 22.1.2 Optimierungstechniken
    65. 22.1.3 CPU-bound-Optimierungsebenen am Beispiel
    66. 22.1.4 Messungen – Erkennen kritischer Bereiche
    67. 22.1.5 Abschätzungen mit der O-Notation
    68. 22.2 Einsatz geeigneter Datenstrukturen
    69. 22.2.1 Einfluss von Arrays und Listen
    70. 22.2.2 Optimierungen für Set und Map
    71. 22.2.3 Design eines Zugriffsinterface
    72. 22.3 Lazy Initialization
    73. 22.3.1 Lazy Initialization am Beispiel
    74. 22.3.2 Konsequenzen des Einsatzes der Lazy Initialization
    75. 22.3.3 Lazy Initialization mithilfe des PROXY-Musters
    76. 22.4 Optimierungen am Beispiel
    77. 22.5 I/O-bound-Optimierungen
    78. 22.5.1 Technik – Wahl passender Strategien
    79. 22.5.2 Technik – Caching und Pooling
    80. 22.5.3 Technik – Vermeidung unnötiger Aktionen
    81. 22.6 Memory-bound-Optimierungen
    82. 22.6.1 Technik – Wahl passender Strategien
    83. 22.6.2 Technik – Caching und Pooling
    84. 22.6.3 Optimierungen der Stringverarbeitung
    85. 22.6.4 Technik – Vermeidung unnötiger Aktionen
    86. 22.7 CPU-bound-Optimierungen
    87. 22.7.1 Technik – Wahl passender Strategien
    88. 22.7.2 Technik – Caching und Pooling
    89. 22.7.3 Technik – Vermeidung unnötiger Aktionen
    90. 22.8 Weiterführende Literatur
    91. 23 Schlussgedanken
  14. VI Anhang
    1. A Grundlagen zur Java Virtual Machine
    2. A.1 Wissenswertes rund um die Java Virtual Machine
    3. A.1.1 Ausführung eines Java-Programms
    4. A.1.2 Sicherheit und Speicherverwaltung
    5. A.1.3 Sicherheit und Classloading
  15. Literaturverzeichnis
  16. Index
  17. Fußnoten