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 – Teil IV

Book Description

  • Basiert auf jahrelanger Tätigkeit als Softwareentwickler- Vermeiden von Fallstricken und Vermittlung von Best-Practices bei der Programmierung- Fundierter Überblick über Profithemen, die man sonst nicht in Java-Büchern findet.

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
    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 Programmierstil und Coding Conventions
      1. 2.1 Grundregeln eines guten Programmierstils
        1. 2.1.1 Keep It Human-Readable
        2. 2.1.2 Keep It Simple And Short
        3. 2.1.3 Keep It Natural
        4. 2.1.4 Keep It Clean
      2. 2.2 Die Psychologie beim Sourcecode-Layout
        1. 2.2.1 Faktor der Ähnlichkeit
        2. 2.2.2 Faktor der Nähe
          1. Beispiel 1
          2. Beispiel 2
      3. 2.3 Coding Conventions
        1. 2.3.1 Grundlegende Namens- und Formatierungsregeln
          1. Ausnahmen für die Formatierung
          2. Namensregeln
        2. 2.3.2 Namensgebung
          1. Vermeide Namenskürzel
          2. Vermeide Variablennamen, die nur den Typ wiederholen
          3. Verwende sinnvolle, konsistente Namen
          4. Benenne Klassen nach ihrer Funktion
          5. Verwende für Containerklassen einen Pluralnamen
        3. 2.3.3 Dokumentation
          1. Verwende kurze, aussagekräftige Kommentare
          2. Vermeide Kommentare, die nur den Ablauf beschreiben
          3. Dokumentiere alle Methoden im öffentlichen Interface der Klasse
        4. 2.3.4 Programmdesign
          1. Halte den Sourcecode sauber
          2. Vermeide Seiteneffekte
          3. Vermeide übermäßige Debug- und Log-Ausgaben
          4. Vermeide Ausgaben per System.out
          5. Verwende final
          6. Vermeide Magic Numbers und Strings
          7. Hilf dem Garbage Collector
          8. Überprüfe Eingabeparameter auf Gültigkeit
          9. Verwende Assertions oder Exceptions zur Zusicherung für Pre- und Post-Conditions
          10. Prüfe Rückgabewerte und behandle Fehlersituationen
          11. Bevorzuge wenige return-Anweisungen
          12. Vermeide die sorglose Rückgabe von null
          13. Prüfe Referenzen auf null
          14. Behandle auftretende Exceptions wenn möglich
          15. Vermeide catch (Exception ex) und catch (Throwable th)
          16. Vermeide return in catch/finally-Blöcken
        5. 2.3.5 Klassendesign
          1. Bevorzuge lokale Variablen gegenüber Attributen
          2. Vermeide statische Attribute
          3. Greife auf Attribute bevorzugt über Methoden zu
          4. Vermeide feingranulare Änderungen am Objektzustand
          5. Liefere keine Referenzen auf interne Datenstrukturen zurück
          6. Minimiere Zustandsänderungen
          7. Programmiere gegen Interfaces oder abstrakte Klassen
          8. Verstecke Implementierungsdetails
          9. Sorge für Lesbarkeit und die richtige Abstraktionsebene
          10. Halte das Interface übersichtlich
          11. Vermeide zu viele Referenzen auf andere Klassen
          12. Beachte die maximale Methodenlänge von ca. 30 – 50 Zeilen
          13. Beachte die maximale Klassenlänge von ca. 500 – 1000 Zeilen
        6. 2.3.6 Parameterlisten
          1. Halte die Parameterliste kurz
          2. Vermeide überflüssige Parameter
          3. Vermeide mehrere gleiche Typen aufeinander folgend in der Parameterliste
          4. Halte die Reihenfolge von Parametern bei Methodenaufrufen konsistent
        7. 2.3.7 Logik und Kontrollfluss
          1. Vermeide explizite true-/false-Literale in if-/while-Anweisungen
          2. Verwende möglichst wenige else if-Anweisungen
          3. Verwende nicht mehr als drei bis vier Logikauswertungen in einem if
          4. Verwende den Conditional-Operator mit Bedacht
          5. Fazit
      4. 2.4 Sourcecode-Überprüfung mit Tools
        1. Sourcecode-Checker und statische Analyse
        2. 2.4.1 Metriken
        3. 2.4.2 Sourcecode-Überprüfung im Build-Prozess
          1. Basiskonfiguration für Eclipse
          2. Das Tool Checkstyle
          3. Das Tool PMD
          4. Das Tool FindBugs
          5. PMD vs. FindBugs
          6. Das Tool Metrics
    2. 3 Unit Tests
      1. 3.1 Überblick
        1. 3.1.1 Arten von Tests
          1. Zuständigkeiten beim Testen
          2. Konkretisierung des Begriffs des Unit Test
        2. 3.1.2 Äußere vs. innere Qualität
        3. 3.1.3 Auswirkungen von Unit Tests auf die Qualität
          1. Auswirkungen von Unit Tests auf das API-Design
          2. Zusammenspiel von Unit Tests und Integrationstests
      2. 3.2 Motivation für Unit Tests aus der Praxis
        1. 3.2.1 Unit Tests für Neuentwicklungen
          1. Auswertung von Statustelegrammen
          2. Schritt 1: Korrekturen der Abhängigkeiten und Lesbarkeit
          3. Schritt 2: Erstellen erster Unit Tests
          4. Schritt 3: Unit Tests um Testfälle A bis F erweitern
          5. Schritt 4: Unit Tests um Testfälle für die Konvertierung 0 bis F erweitern
          6. Schritt 5: Testfälle für Eingabewertea bisf
          7. Schritt 6: Implementierung erweitern um Konvertierunga bisf
          8. Fazit
        2. 3.2.2 Unit Tests und Legacy-Code
          1. Vorarbeiten: Analyse
          2. Schritt 1: Schreiben von ersten Unit Tests
          3. Schritt 2: Herausfaktorieren einer durch Unit Tests prüfbaren Methode
          4. Schritt 3: Anpassungen für bessere Wart- und Lesbarkeit
          5. Schritt 4: Fehlersuche und -korrektur durch Log-Auswertung
          6. Schritt 5: Komplettierung der Unit Tests
          7. Fazit: Positive Effekte beim Einsatz von Unit Tests
      3. 3.3 Fortgeschrittene Unit-Test-Techniken
        1. 3.3.1 Testen mit Stubs
          1. Vorbereitungen zur Testbarkeit – Lösen von Abhängigkeiten
        2. 3.3.2 Testen mit Mocks
          1. Aufzeichnung von Erwartungen
          2. Durchführung von Tests
          3. Fazit
        3. 3.3.3 Unit Tests von privaten Methoden
      4. 3.4 Unit Tests mit Threads und Timing
        1. Realisierung der Funktionalität
        2. Vorbereitungen zum Test der KlasseMessageConcatenator
        3. Definition von Unit Tests für die KlasseMessageConcatenator
        4. Fazit
      5. 3.5 Nützliche Tools für Unit Tests
        1. 3.5.1 Hamcrest
          1. Hamcrest in Aktion: Der erste Test
          2. Übersicht über die wichtigsten Matcher
          3. Definition eigener Matcher
          4. Generierte Fehlermeldungen
        2. 3.5.2 Infinitest
        3. 3.5.3 Cobertura
          1. Bewertung der Messergebnisse und Ermittlung fehlender Testfälle
          2. Auswirkungen auf die Qualität
          3. Ausführen von Cobertura
      6. 3.6 Weiterführende Literatur
    3. 4 Codereviews
      1. 4.1 Definition
        1. Durchführung
        2. Vorteile
        3. Psychologische Aspekte und Probleme
      2. 4.2 Probleme und Tipps zur Durchführung
      3. 4.3 Vorteile von Codereviews
        1. Fazit
      4. 4.4 Codereview-Tools
        1. Das Tool Code Collaborator
        2. Das Tool Crucible
        3. Das Tool Jupiter
        4. Fazit
      5. 4.5 Codereview-Checkliste
    4. 5 Optimierungen
      1. 5.1 Grundlagen
        1. 5.1.1 Optimierungsebenen und Einflussfaktoren
        2. 5.1.2 Optimierungstechniken
        3. 5.1.3 CPU-bound-Optimierungsebenen am Beispiel
          1. Diskussion
        4. 5.1.4 Messungen – Erkennen kritischer Bereiche
          1. Die »80-zu-20-Regel«
          2. Messungen des Zeitverhaltens
          3. Messungen des Speicherbedarfs
          4. Profiling-Tools
          5. Validierung von Änderungen
          6. Skalierbarkeit
        5. 5.1.5 Abschätzungen mit der O-Notation
          1. Komplexitätsklassen
          2. Auswirkungen der Komplexität auf die Programmlaufzeit
      2. 5.2 Einsatz geeigneter Datenstrukturen
        1. 5.2.1 Einfluss von Arrays und Listen
          1. Die Klassen ArrayList und Vector
          2. Die Klasse LinkedList
          3. Betrachtung von Vor- und Nachteilen
        2. 5.2.2 Optimierungen für Set und Map
          1. HashSet und HashMap
          2. ConcurrentHashMap
          3. TreeSet und TreeMap
          4. ConcurrentSkipListSet und ConcurrentSkipListMap
        3. 5.2.3 API-Design Collection vs. Iterator
      3. 5.3 Lazy Initialization
        1. 5.3.1 Lazy Initialization am Beispiel
          1. Analyse
          2. Einführen von Lazy Initialization
        2. 5.3.2 Konsequenzen des Einsatzes der Lazy Initialization
          1. Synchronisationsprobleme
          2. Initialisierungsprobleme
        3. 5.3.3 Lazy Initialization mithilfe des PROXY-Musters
          1. Empfehlungen
          2. Fazit
      4. 5.4 Optimierungen am Beispiel
        1. Problemkontext
        2. Analyse
        3. I/O-bound-Optimierungen
        4. Memory-bound-Optimierungen
        5. Fazit
      5. 5.5 I/O-bound-Optimierungen
        1. 5.5.1 Technik – Wahl passender Strategien
          1. Optimierungen beim Einsatz von Streams
          2. Kompression und Zip-Archive
          3. Optimierungen der Serialisierung
        2. 5.5.2 Technik – Caching und Pooling
        3. 5.5.3 Technik – Vermeidung unnötiger Aktionen
          1. Optimierungen beim Logging
          2. Reduktion von Remote Calls
      6. 5.6 Memory-bound-Optimierungen
        1. 5.6.1 Technik – Wahl passender Strategien
          1. Größe und Nutzung des Hauptspeichers
          2. Optimierungen der Garbage Collection
        2. 5.6.2 Technik – Caching und Pooling
          1. Objekt-Caching
        3. 5.6.3 Optimierungen der Stringverarbeitung
          1. StringBuffer / StringBuilder als Abhilfe?
          2. Diskussion
        4. 5.6.4 Technik – Vermeidung unnötiger Aktionen
          1. Reduziere die Kosten der Objekterzeugung
          2. Bevorzuge primitive Datentypen
      7. 5.7 CPU-bound-Optimierungen
        1. 5.7.1 Technik – Wahl passender Strategien
        2. 5.7.2 Technik – Caching und Pooling
        3. 5.7.3 Technik – Vermeidung unnötiger Aktionen
      8. 5.8 Weiterführende Literatur
  8. Teil II Anhang
    1. A Überblick über den Softwareentwicklungsprozess
      1. A.1 Vorgehensmodelle
        1. A.1.1 Aufgaben und Phasen beim Softwareentwurf
        2. A.1.2 Wasserfallmodell und V-Modell
          1. Das Wasserfallmodell
          2. Das V-Modell
          3. Probleme beider Modelle
        3. A.1.3 Extreme Programming (XP)
        4. A.1.4 Test-Driven Development (TDD)
        5. A.1.5 Diskussion
    2. Literaturverzeichnis
    3. Index
  9. Fußnoten
    1. Kapitel 2
    2. Kapitel 3
    3. Kapitel 5
    4. A Überblick über den Softwareentwicklungsprozess