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. - 21 *-Rezensionen / 3000 Ex in 1 Jahr
Table of contents
- Cover
- Titel
- Impressum
- Inhaltsverzeichnis
- Vorwort zur 2. Auflage
- 1 Einleitung
-
Teil I Java-Grundlagen, Analyse und Design
-
2 Professionelle Arbeitsumgebung
- 2.1 Vorteile von IDEs am Beispiel von Eclipse
- 2.2 Projektorganisation
- 2.3 Einsatz von Versionsverwaltungen
- 2.4 Einsatz eines Unit-Test-Frameworks
- 2.5 Debugging
- 2.6 Einsatz eines IDE-unabhängigen Build-Prozesses
- 2.7 Weiterführende Literatur
-
3 Objektorientiertes Design
- 3.1 OO-Grundlagen
- 3.2 Grundlegende OO-Techniken
- 3.3 Vom imperativen zum objektorientierten Entwurf
- 3.4 Fortgeschrittenere OO-Techniken
- 3.5 Formen der Varianz
- 3.6 Generische Typen (Generics)
- 3.7 Weiterführende Literatur
-
4 Java-Grundlagen
- 4.1 Die Klasse Object
- 4.2 Primitive Datentypen und Wrapper-Klassen
- 4.3 Stringverarbeitung
- 4.4 Datumsverarbeitung
- 4.5 Interfaces und innere Klassen
- 4.6 Ein- und Ausgabe (I/O)
- 4.7 Fehlerbehandlung
- 4.8 Weiterführende Literatur
-
2 Professionelle Arbeitsumgebung
-
Teil II Bausteine stabiler Java-Applikationen
-
5 Das Collections-Framework
-
5.1 Datenstrukturen
- 5.1.1 Wahl einer geeigneten Datenstruktur
- 5.1.2 Arrays
- 5.1.3 Das Interface Collection
- 5.1.4 Listen und das Interface List
- 5.1.5 Mengen und das Interface Set
- 5.1.6 Grundlagen von hashbasierten Containern
- 5.1.7 Grundlagen automatisch sortierender Container
- 5.1.8 Die Methoden equals(), hashCode() und compareTo() im Zusammenspiel
- 5.1.9 Konkrete Realisierungen von Mengen
- 5.1.10 Schlüssel-Wert-Abbildungen und das Interface Map
- 5.1.11 Erweiterungen am Beispiel der Klasse HashMap
- 5.1.12 Entscheidungshilfe zur Wahl von Datenstrukturen
- 5.2 Suchen, Sortieren und Filtern
- 5.3 Utility-Klassen und Hilfsmethoden
- 5.4 Probleme im Collections-Framework
- 5.5 Weiterführende Literatur
-
5.1 Datenstrukturen
-
6 Applikationsbausteine
- 6.1 Einsatz von Bibliotheken am Beispiel
-
6.2 Wertebereichs- und Parameterprüfungen
- 6.2.1 Prüfung einfacher Wertebereiche und Wertemengen
-
6.2.2 Prüfung komplexerer Wertebereiche
- Definition zusammenhängender Wertebereiche in einer Klasse
- Probleme beim Erstellen einer generischen Kopie
- Problem 1: Fallstricke beim Konstruktoraufruf und der Initialisierung
- Einsatz der Klasse ValueRange in der Utility-Klasse RangeCheckUtils
- Erstellen von Unit Tests
- Erweiterung auf nicht zusammenhängende Wertebereiche
- Erweiterung der Unit Tests
- Nützliche weitere Methoden
- Fazit und Ausblick
-
6.3 Logging-Frameworks
- Vorteile von Logging-Frameworks
- 6.3.1 Apache log4j
-
6.3.2 Tipps und Tricks zum Einsatz von Logging mit log4j
- Abfrage der Log-Level
- Verwende logische Log-Kategorien
- Logging der Aufrufe an Schnittstellen zu anderen Systemen
- Automatische Auswertungsmöglichkeiten
- Verwende mehrere unterschiedliche Konfigurationsdateien
- Logging von Strings
- Logging mit Datumswerten
- Logging von Exceptions
- Stacktrace ausgeben
- Sonderbehandlung spezieller Exceptions
- 6.4 Utility-Klassen zur Dateibehandlung
- 6.5 Konfigurationsparameter und -dateien
- Format und Umwandlung der Konfigurationswerte
-
7 Multithreading
- Grundlagen zu Parallelität und Nebenläufigkeit
- 7.1 Threads und Runnables
- 7.2 Zusammenarbeit von Threads
- 7.3 Kommunikation von Threads
- 7.4 Das Java-Memory-Modell
- 7.5 Besonderheiten bei Threads
- 7.6 Die Concurrency Utilities
- 7.7 Weiterführende Literatur
-
8 Fortgeschrittene Java-Themen
- 8.1 Crashkurs Reflection
- 8.2 Annotations
- 8.3 Serialisierung
- 8.4 Objektkopien und das Interface Cloneable
- 8.5 Internationalisierung
- 8.6 Programmbausteine zur Internationalisierung
- 8.7 Garbage Collection
- 8.8 Weiterführende Literatur
-
9 Programmierung grafischer Benutzeroberflächen
-
9.1 Grundlagen zu grafischen Oberflächen
- Überblick
- Bedienelemente
- Container
- Layoutmanagement
- Ereignisbehandlung
- 9.1.1 Überblick: Bedienelemente und Container
- 9.1.2 Einführung in das Layoutmanagement
- 9.1.3 Komplexere Layouts durch Kombination von Layoutmanagern
- 9.1.4 Grundlagen zur Ereignisbehandlung
- 9.1.5 Gebräuchliche Event Listener
- 9.1.6 Varianten der Ereignisverarbeitung
- 9.2 Multithreading und Swing
- 9.3 Zeichnen in GUI-Komponenten
- 9.4 Komplexe Bedienelemente
- 9.5 Weiterführende Literatur
-
9.1 Grundlagen zu grafischen Oberflächen
-
10 Einführung in Persistenz und Datenbanken
-
10.1 Grundlagen zur Persistenz
- 10.1.1 Beschränkungen einfacher Persistenzlösungen
- 10.1.2 Modelle zur Persistierung von Objekten
- 10.1.3 Wissenswertes zur Speicherung von Daten in Tabellen relationaler Datenbanken
- 10.1.4 Abbildung zwischen Objekt- und Datenbank-Modell
- 10.1.5 Die Datenbanksysteme Java DB und HSQLDB
- 10.1.6 SQL-Grundlagen
- 10.2 Datenbankzugriffe per JDBC
- 10.3 Grundlagen zum ORM mit JDBC
- 10.4 Datenbanken und JPA
- 10.5 Weiterführende Literatur
-
10.1 Grundlagen zur Persistenz
- 11 Neuerungen in JDK 7
-
5 Das Collections-Framework
-
Teil III Fallstricke und Lösungen im Praxisalltag
-
12 Bad Smells
- Bad Smells am Beispiel
-
12.1 Programmdesign
- 12.1.1 Bad Smell: Verwenden von Magic Numbers
- 12.1.2 Bad Smell: Konstanten in Interfaces definieren
- 12.1.3 Bad Smell: System.exit() mitten im Programm
- 12.1.4 Bad Smell: Zusammengehörende Konstanten nicht als Typ definiert
- 12.1.5 Bad Smell: Programmcode im Logging-Code
- 12.1.6 Bad Smell: Unvollständige Betrachtung aller Alternativen
- 12.1.7 Bad Smell: Unvollständige Änderungen nach Copy-Paste
- 12.1.8 Bad Smell: Casts auf unbekannte Subtypen
- 12.1.9 Bad Smell: Pre-/Post-Increment in komplexeren Statements
- 12.1.10 Bad Smell: Keine Klammern um Blöcke
- 12.1.11 Bad Smell: Variablendeklaration nicht im kleinstmöglichen Sichtbarkeitsbereich
- 12.1.12 Bad Smell: Mehrere aufeinanderfolgende Parameter gleichen Typs
- 12.1.13 Bad Smell: Grundloser Einsatz von Reflection
-
12.2 Klassendesign
- 12.2.1 Bad Smell: Unnötigerweise veränderliche Attribute
- 12.2.2 Bad Smell: Aufruf abstrakter Methoden im Konstruktor
- 12.2.3 Bad Smell: Herausgabe von this im Konstruktor
- 12.2.4 Bad Smell: Referenzierung von Subklassen in Basisklassen
- 12.2.5 Bad Smell: Mix abstrakter und konkreter Basisklassen
- 12.2.6 Bad Smell: Öffentlicher Defaultkonstruktor lediglich zum Zugriff auf Hilfsmethoden
-
12.3 Fehlerbehandlung und Exception Handling
- 12.3.1 Bad Smell: Unbehandelte Exception
- 12.3.2 Bad Smell: Unpassender Exception-Typ
- 12.3.3 Bad Smell: Exceptions zur Steuerung des Kontrollflusses
- 12.3.4 Bad Smell: Fangen der allgemeinsten Exception
- 12.3.5 Bad Smell: Rückgabe von null statt Exception im Fehlerfall
- 12.3.6 Bad Smell: Unbedachte Rückgabe von null
- 12.3.7 Bad Smell: Sonderbehandlung von Randfällen
- 12.3.8 Bad Smell: Keine Gültigkeitsprüfung von Eingabeparametern
- 12.3.9 Bad Smell: Fehlerhafte Fehlerbehandlung
- 12.3.10 Bad Smell: I/O ohne finally bzw. finalize()
- 12.3.11 Bad Smell: Resource Leaks durch Exceptions im Konstruktor
-
12.4 Häufige Fallstricke
- Fallstrick: Nutzung statischer Attribute statt Membervariablen
- Fallstrick: Änderung statischer Attribute im Konstruktor/in Methoden
- Fallstrick: Missachtung der Initialisierungsreihenfolge statischer Attribute
- Fallstrick: Utility-Klasse mit öffentlichem Konstruktor
- Fallstrick: Chaotische Konstruktor-/Methoden-Aufruffolgen
- Fallstrick: Einsatz von Vererbung und statischen Methoden
- Fallstrick: Missverständliches API durch Überladen
- Fallstrick: Mehrfachverkettung der ».«-Notation
- Fallstrick: Unnötige Komplexität
- Fallstrick: Objektvergleich durch Einsatz von toString()und equals()
- Fallstrick: Rückgabe von null in toString()-Methoden
- Fallstrick: Zugriff ohne Bereichsprüfung
- Fallstrick: default mitten in den case-Anweisungen versteckt
- Fallstrick: Berechnungen in case-Anweisungen
- Fallstrick: Einsatz komplizierter boolescher Bedingungen
- Fallstrick: Einsatz doppelter Verneinung
- Fallstrick: Kommentierte Klammern
- 12.5 Weiterführende Literatur
-
13 Refactorings
- Refactorings am Beispiel
- Schritt 1: Erstellen von Testfällen
- Schritt 2: Vereinfachungen durch Zusammenfassen der Bedingungen
- Schritt 3: Einsatz der Java-Bibliotheken zum Parsen von Zahlen
- Schritt 4: Behandlung ungültiger null-Eingabewerte
- 13.1 Das Standardvorgehen
-
13.2 Der Refactoring-Katalog
- 13.2.1 Reduziere die Sichtbarkeit von Attributen
-
13.2.2 Minimiere veränderliche Attribute
- Schritt 1: Prüfe, auf Schreibzugriffe – Definiere ein Attribut final
- Schritt 2: Prüfe, ob die set() -Methode entfernt werden kann
- Schritt 3: Prüfen interner Schreibzugriffe
- Schritt 4: Anpassung des Konstruktors
- Schritt 5: Wiederhole Schritt 1 bis 4 für alle Attribute
- Fazit
- Sinnvolle weitere Schritte
- 13.2.3 Reduziere die Sichtbarkeit von Methoden
- 13.2.4 Ersetze Mutatordurch Business-Methode
- 13.2.5 Minimiere Zustandsänderungen (Refactoring-Kombination)
- 13.2.6 Führe ein Interface ein
- 13.2.7 Aufspalten eines Interface
- 13.2.8 Einführen eines Read-only-Interface
- 13.2.9 Einführen eines Read-Write-Interface
- 13.2.10 Einführen von Convenience-Methoden
- 13.2.11 Einführen einer Zustandsprüfung
- 13.2.12 Überprüfung von Eingabeparametern
- 13.2.13 Trenne Informationsbeschaffung und -verarbeitung
- 13.2.14 Konstantensammlung in enum umwandeln
- 13.2.15 Entferne Exceptions zur Steuerung des Kontrollflusses
- 13.2.16 Umwandlung in Utility-Klasse mit statischen Hilfsmethoden
- 13.3 Weiterführende Literatur
-
14 Entwurfsmuster
- Design mit Entwurfsmustern
- Beispielapplikation: Image-Editor
- 14.1 Erzeugungsmuster
- 14.2 Strukturmuster
- 14.3 Verhaltensmuster
- 14.4 Weiterführende Literatur
-
12 Bad Smells
-
Teil IV Qualitätssicherungsmaßnahmen
-
15 Programmierstil und Coding Conventions
- 15.1 Grundregeln eines guten Programmierstils
- 15.2 Die Psychologie beim Sourcecode-Layout
-
15.3 Coding Conventions
- 15.3.1 Grundlegende Namens- und Formatierungsregeln
- 15.3.2 Namensgebung
- 15.3.3 Dokumentation
-
15.3.4 Programmdesign
- Halte den Sourcecode sauber
- Vermeide Seiteneffekte
- Vermeide übermäßige Debug- und Log-Ausgaben
- Vermeide Ausgaben per System.out
- Verwende final
- Vermeide Magic Numbers und Strings
- Hilf dem Garbage Collector
- Überprüfe Eingabeparameter auf Gültigkeit
- Verwende Assertions oder Exceptions zur Zusicherung für Pre- und Post-Conditions
- Prüfe Rückgabewerte und behandle Fehlersituationen
- Bevorzuge wenige return-Anweisungen
- Vermeide die sorglose Rückgabe von null
- Prüfe Referenzen auf null
- Behandle auftretende Exceptions wenn möglich
- Vermeide catch (Exception ex) und catch (Throwable th)
- Vermeide return in catch/finally-Blöcken
-
15.3.5 Klassendesign
- Bevorzuge lokale Variablen gegenüber Attributen
- Vermeide statische Attribute
- Greife auf Attribute bevorzugt über Methoden zu
- Vermeide feingranulare Änderungen am Objektzustand
- Liefere keine Referenzen auf interne Datenstrukturen zurück
- Minimiere Zustandsänderungen
- Programmiere gegen Interfaces oder abstrakte Klassen
- Verstecke Implementierungsdetails
- Definiere abstrakte Methoden möglichst protected
- Sorge für Lesbarkeit und die richtige Abstraktionsebene
- Halte das Interface übersichtlich
- Vermeide zu viele Referenzen auf andere Klassen
- Beachte die maximale Methodenlänge von ca. 30 – 50 Zeilen
- Beachte die maximale Klassenlänge von ca. 500 – 1000 Zeilen
- 15.3.6 Parameterlisten
- 15.3.7 Logik und Kontrollfluss
- 15.4 Sourcecode-Überprüfung mit Tools
-
16 Unit Tests
- 16.1 Überblick
-
16.2 Motivation für Unit Tests aus der Praxis
-
16.2.1 Unit Tests für Neuentwicklungen
- Auswertung von Statustelegrammen
- Schritt 1: Korrekturen der Abhängigkeiten und Lesbarkeit
- Schritt 2: Erstellen erster Unit Tests
- Schritt 3: Unit Tests um Testfälle A bis F erweitern
- Schritt 4: Unit Tests um Testfälle für die Konvertierung 0 bis F erweitern
- Schritt 5: Testfälle für Eingabewerte a bis f
- Schritt 6: Implementierung erweitern um Konvertierung a bis f
- Fazit
-
16.2.2 Unit Tests und Legacy-Code
- Vorarbeiten: Analyse
- Schritt 1: Schreiben von ersten Unit Tests
- Schritt 2: Herausfaktorieren einer durch Unit Tests prüfbaren Methode
- Schritt 3: Anpassungen für bessere Wart- und Lesbarkeit
- Schritt 4: Fehlersuche und -korrektur durch Log-Auswertung
- Schritt 5: Komplettierung der Unit Tests
- Fazit: Positive Effekte beim Einsatz von Unit Tests
-
16.2.1 Unit Tests für Neuentwicklungen
- 16.3 Fortgeschrittene Unit-Test-Techniken
- 16.4 Unit Tests mit Threads und Timing
- 16.5 Nützliche Tools für Unit Tests
- 16.6 Weiterführende Literatur
- 17 Codereviews
-
18 Optimierungen
- 18.1 Grundlagen
- 18.2 Einsatz geeigneter Datenstrukturen
- 18.3 Lazy Initialization
- 18.4 Optimierungen am Beispiel
- 18.5 I/O-bound-Optimierungen
- 18.6 Memory-bound-Optimierungen
- 18.7 CPU-bound-Optimierungen
- 18.8 Weiterführende Literatur
-
15 Programmierstil und Coding Conventions
- Teil V Anhang
- Literaturverzeichnis
- Index
- Fußnoten
Product information
- Title: Der Weg zum Java-Profi, 2nd Edition
- Author(s):
- Release date: July 2012
- Publisher(s): dpunkt
- ISBN: 97833864900051
You might also like
book
Der Weg zum Java-Profi, 5th Edition
Dieses Buch bietet eine umfassende Einführung in die professionelle Java-Entwicklung und vermittelt Ihnen das notwendige Wissen, …
book
Der Weg zum Java-Profi
Diese umfassende Einführung in die professionelle Java-Programmierung vermittelt Ihnen das notwendige Wissen, um stabile und erweiterbare …
book
Der Java-Profi: Persistenzlösungen und REST-Services
• Erweiterung des Java-Profis für Datenbankprogrammierung• Erfolgsautor Michael Inden• Professionelle Entwicklung von Datenbankanwendungen
book
Die Kunst der agilen Entwicklung
Dieses Buch beschreibt umfassend und praxisorientiert die Grundlagen, Methoden und Praktiken agiler Softwareentwicklung. James Shore gibt …