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
Die Kunst der agilen Entwicklung
Dieses Buch beschreibt umfassend und praxisorientiert die Grundlagen, Methoden und Praktiken agiler Softwareentwicklung. James Shore gibt …
book
Der Java-Profi: Persistenzlösungen und REST-Services
• Erweiterung des Java-Profis für Datenbankprogrammierung• Erfolgsautor Michael Inden• Professionelle Entwicklung von Datenbankanwendungen