Effective Java, 3rd Edition

Table of contents

1. Cover
2. Titel
3. Impressum
4. Inhaltsverzeichnis
5. Vorbemerkung
6. Vorwort
7. Danksagung
8. 1 Einleitung
9. 2 Objekte erzeugen und auflösen
   1. 2.1 Thema 1: Statische Factory-Methoden als Alternative zu Konstruktoren
   2. 2.2 Thema 2: Erwägen Sie bei zu vielen Konstruktorparametern den Einsatz eines Builders
   3. 2.3 Thema 3: Erzwingen Sie die Singleton-Eigenschaft mit einem private-Konstruktor oder einem Aufzählungstyp
   4. 2.4 Thema 4: Erzwingen Sie die Nicht-Instanziierbarkeit mit einem private-Konstruktor
   5. 2.5 Thema 5: Arbeiten Sie mit Dependency Injection statt Ressourcen direkt einzubinden
   6. 2.6 Thema 6: Vermeiden Sie die Erzeugung unnötiger Objekte
   7. 2.7 Thema 7: Löschen Sie veraltete Objektreferenzen
   8. 2.8 Thema 8: Vermeiden Sie Finalizer und Cleaner
   9. 2.9 Thema 9: Verwenden Sie try-with-resources anstelle von try-finally
10. 3 Methoden, die allen Objekten gemeinsam sind
    1. 3.1 Thema 10: Halten Sie beim Überschreiben von equals den allgemeinen Vertrag ein
    2. 3.2 Thema 11: Überschreiben Sie, wenn Sie equals überschreiben, immer auch hashCode
    3. 3.3 Thema 12: Überschreiben Sie immer toString
    4. 3.4 Thema 13: Vorsicht beim Überschreiben von clone
    5. 3.5 Thema 14: Denken Sie darüber nach, Comparable zu implementieren
11. 4 Klassen und Schnittstellen
    1. 4.1 Thema 15: Minimieren Sie den Zugriff auf Klassen und Member
    2. 4.2 Thema 16: Verwenden Sie in öffentlichen Klassen Accessor-Methoden und keine öffentlichen Felder
    3. 4.3 Thema 17: Bevorzugen Sie unveränderliche Klassen
    4. 4.4 Thema 18: Ziehen Sie Komposition der Vererbung vor
    5. 4.5 Thema 19: Entwerfen und dokumentieren Sie für Vererbung oder verbieten Sie sie
    6. 4.6 Thema 20: Geben Sie Schnittstellen den Vorzug vor abstrakten Klassen
    7. 4.7 Thema 21: Entwerfen Sie Ihre Schnittstellen für die Nachwelt
    8. 4.8 Thema 22: Verwenden Sie Schnittstellen nur zum Definieren von Typen
    9. 4.9 Thema 23: Arbeiten Sie mit Klassenhierarchien statt mit Tag-Klassen
    10. 4.10 Thema 24: Ziehen Sie statische Member-Klassen den nicht-statischen vor
    11. 4.11 Thema 25: Beschränken Sie Quelltextdateien auf eine einzige Toplevel-Klasse
12. 5 Java Generics
    1. 5.1 Thema 26: Hände weg von Rohtypen
    2. 5.2 Thema 27: Eliminieren Sie unchecked-Warnungen
    3. 5.3 Thema 28: Verwenden Sie Listen statt Arrays
    4. 5.4 Thema 29: Bevorzugen Sie generische Typen
    5. 5.5 Thema 30: Bevorzugen Sie generische Methoden
    6. 5.6 Thema 31: Eingeschränkte Wildcard-Typen machen Ihre APIs flexibler
    7. 5.7 Thema 32: Vorsicht beim Kombinieren von Java Generics mit varargs-Methoden
    8. 5.8 Thema 33: Nutzen Sie typsichere heterogene Container
13. 6 Aufzählungen und Annotationen
    1. 6.1 Thema 34: Verwenden Sie Aufzählungen statt int-Konstanten
    2. 6.2 Thema 35: Verwenden Sie Instanzfelder statt Ordinalzahlen
    3. 6.3 Thema 36: Verwenden Sie EnumSet statt Bitfelder
    4. 6.4 Thema 37: Verwenden Sie EnumMap statt Ordinalzahlindizierung
    5. 6.5 Thema 38: Emulieren Sie erweiterbare Enums mit Schnittstellen
    6. 6.6 Thema 39: Ziehen Sie die Annotationen den Namensmustern vor
    7. 6.7 Thema 40: Verwenden Sie konsequent die Annotation Override
    8. 6.8 Thema 41: Definieren Sie Typen mit Markierungsschnittstellen
14. 7 Lambdas und Streams
    1. 7.1 Thema 42: Lambdas sind oft besser als anonyme Klassen
    2. 7.2 Thema 43: Denken Sie an Methodenreferenzen als Alternative zu Lambdas
    3. 7.3 Thema 44: Verwenden Sie nach Möglichkeit die funktionalen Schnittstellen aus dem Standard
    4. 7.4 Thema 45: Setzen Sie Streams mit Bedacht ein
    5. 7.5 Thema 46: Bevorzugen Sie in Streams Funktionen ohne Nebeneffekte
    6. 7.6 Thema 47: Verwenden Sie als Rückgabewert eher Collection als Stream
    7. 7.7 Thema 48: Seien Sie vorsichtig, wenn Sie Streams parallelisieren
15. 8 Methoden
    1. 8.1 Thema 49: Prüfen Sie Parameter auf Gültigkeit
    2. 8.2 Thema 50: Erstellen Sie bei Bedarf defensive Kopien
    3. 8.3 Thema 51: Entwerfen Sie Methodensignaturen sorgfältig
    4. 8.4 Thema 52: Verwenden Sie Überladung mit Bedacht
    5. 8.5 Thema 53: Verwenden Sie varargs mit Bedacht
    6. 8.6 Thema 54: Geben Sie nicht null, sondern leere Sammlungen oder Arrays zurück
    7. 8.7 Thema 55: Verwenden Sie den Rückgabetyp Optional mit Bedacht
    8. 8.8 Thema 56: Schreiben Sie Doc-Kommentare für alle offengelegten API-Elemente
16. 9 Allgemeine Programmierung
    1. 9.1 Thema 57: Minimieren Sie den Gültigkeitsbereich lokaler Variablen
    2. 9.2 Thema 58: Ziehen Sie for-each-Schleifen den traditionellen for-Schleifen vor
    3. 9.3 Thema 59: Machen Sie sich mit den Bibliotheken vertraut und nutzen Sie sie
    4. 9.4 Thema 60: Vermeiden Sie float und double, wenn genaue Antworten benötigt werden
    5. 9.5 Thema 61: Ziehen Sie die elementaren Datentypen den Wrapper-Typen vor
    6. 9.6 Thema 62: Vermeiden Sie Strings, wenn andere Typen besser geeignet sind
    7. 9.7 Thema 63: Denken Sie an die Leistungseinbußen bei der String-Verkettung
    8. 9.8 Thema 64: Referenzieren Sie Objekte über ihre Schnittstellen
    9. 9.9 Thema 65: Ziehen Sie Schnittstellen der Java Reflection vor
    10. 9.10 Thema 66: Vorsicht bei der Arbeit mit nativen Methoden
    11. 9.11 Thema 67: Optimieren Sie mit Bedacht
    12. 9.12 Thema 68: Halten Sie sich an die allgemein anerkannten Namenskonventionen
17. 10 Ausnahmen
    1. 10.1 Thema 69: Verwenden Sie Ausnahmen nur für Ausnahmebedingungen
    2. 10.2 Thema 70: Verwenden Sie geprüfte Ausnahmen für behebbare Situationen und Laufzeitausnahmen für Programmierfehler
    3. 10.3 Thema 71: Vermeiden Sie den unnötigen Einsatz von geprüften Ausnahmen
    4. 10.4 Thema 72: Ziehen Sie Standardausnahmen vor
    5. 10.5 Thema 73: Werfen Sie Ausnahmen passend zur Abstraktion
    6. 10.6 Thema 74: Dokumentieren Sie alle Ausnahmen, die jede Methode auslöst
    7. 10.7 Thema 75: Geben Sie in Detailnachrichten Fehlerinformationen an
    8. 10.8 Thema 76: Streben Sie nach Fehleratomizität
    9. 10.9 Thema 77: Ignorieren Sie Ausnahmen nicht
18. 11 Nebenläufigkeit
    1. 11.1 Thema 78: Synchronisieren Sie den Zugriff auf gemeinsam genutzte, veränderliche Daten
    2. 11.2 Thema 79: Vermeiden Sie übermäßige Synchronisation
    3. 11.3 Thema 80: Ziehen Sie Exekutoren, Aufgaben und Streams den Threads vor
    4. 11.4 Thema 81: Ziehen Sie die Nebenläufigkeitsdienste den Methoden wait und notify vor
    5. 11.5 Thema 82: Dokumentieren Sie die Thread-Sicherheit
    6. 11.6 Thema 83: Verwenden Sie die späte Initialisierung mit Bedacht
    7. 11.7 Thema 84: Verlassen Sie sich nicht auf den Thread-Planer
19. 12 Serialisierung
    1. 12.1 Thema 85: Verwenden Sie statt der Java-Serialisierung besser deren Alternativen
    2. 12.2 Thema 86: Implementieren Sie Serializable mit großer Vorsicht
    3. 12.3 Thema 87: Verwenden Sie möglichst eine eigene serialisierte Form
    4. 12.4 Thema 88: Implementieren Sie readObject defensiv
    5. 12.5 Thema 89: Ziehen Sie zur Instanzenkontrolle die Aufzählungstypen der Methode readResolve vor
    6. 12.6 Thema 90: Verwenden Sie möglichst Serialisierungs-Proxys anstelle von serialisierten Instanzen
20. Index
21. Literatur