Effektive Java-3. Auflage, Chinesisch, Englisch, zweisprachig
Dies ist eine Referenz zum Lernen von Chinesisch und Englisch für jedes Kapitel von Effective Java (3. Auflage). Vorschläge und Änderungen sind durch Ausgabe oder PR willkommen.
Inhalt
- Kapitel 2. Objekte erstellen und zerstören
- Kapitel 2 Einführung
- Punkt 1: Erwägen Sie statische Factory-Methoden anstelle von Konstruktoren (Erwägen Sie statische Factory-Methoden anstelle von Konstruktoren)
- Punkt 2: Ziehen Sie einen Builder in Betracht, wenn Sie mit vielen Konstruktorparametern konfrontiert werden
- Punkt 3: Erzwingen Sie die Singleton-Eigenschaft mit einem privaten Konstruktor oder einem Aufzählungstyp (verwenden Sie einen privaten Konstruktor oder einen Aufzählungstyp, um eine Singleton-Eigenschaft zu implementieren).
- Punkt 4: Nichtinstanziabilität mit einem privaten Konstruktor erzwingen (verwenden Sie einen privaten Konstruktor, um Nichtinstanziabilität zu implementieren)
- Punkt 5: Bevorzugen Sie die Abhängigkeitsinjektion gegenüber festverdrahteten Ressourcen (Abhängigkeitsinjektion ist besser als festverdrahtete Ressourcen)
- Punkt 6: Vermeiden Sie die Erstellung unnötiger Objekte
- Punkt 7: Veraltete Objektreferenzen beseitigen (veraltete Objektreferenzen ausschließen)
- Punkt 8: Vermeiden Sie Finalizer und Reiniger (vermeiden Sie die Verwendung von Finalizern und Reinigern)
- Punkt 9: Versuchen Sie es lieber mit Ressourcen, bevor Sie es endlich versuchen (die Verwendung von „Try-with-Resources“ ist besser als „Try-finally“)
- Kapitel 3. Allen Objekten gemeinsame Methoden (gemeinsame Methoden von Objekten)
- Kapitel 3 Einführung
- Punkt 10: Befolgen Sie beim Überschreiben von Equals den allgemeinen Vertrag (die Konvention, die beim Überschreiben der Equals-Methode befolgt werden sollte)
- Punkt 11: Überschreiben Sie immer hashCode, wenn Sie equal überschreiben (wenn Sie die Methode equal überschreiben, überschreiben Sie immer die Methode hashCode)
- Punkt 12: toString immer überschreiben (toString-Methode immer überschreiben)
- Punkt 13: Klonen mit Bedacht überschreiben (Klonmethode mit Bedacht überschreiben)
- Punkt 14: Erwägen Sie die Implementierung von Comparable (Erwägen Sie die Implementierung der Comparable-Schnittstelle)
- Kapitel 4. Klassen und Schnittstellen
- Kapitel 4 Einführung
- Punkt 15: Minimieren Sie die Zugänglichkeit von Klassen und Mitgliedern (minimieren Sie die Zugänglichkeit von Klassen und Mitgliedern)
- Punkt 16: Verwenden Sie in öffentlichen Klassen Zugriffsmethoden und keine öffentlichen Felder (verwenden Sie in öffentlichen Klassen Zugriffsmethoden und keine öffentlichen Felder).
- Punkt 17: Veränderlichkeit minimieren (Variabilität reduzieren)
- Punkt 18: Bevorzugen Sie die Zusammensetzung gegenüber der Vererbung
- Punkt 19: Die Vererbung planen und dokumentieren oder verbieten (die Vererbung muss gut geplant und dokumentiert sein, andernfalls ist ihre Verwendung verboten)
- Punkt 20: Schnittstellen gegenüber abstrakten Klassen bevorzugen (Schnittstellen sind besser als abstrakte Klassen)
- Punkt 21: Design-Schnittstellen für die Nachwelt
- Punkt 22: Schnittstellen nur zum Definieren von Typen verwenden (Schnittstellen werden nur zum Definieren von Typen verwendet)
- Punkt 23: Klassenhierarchien gegenüber getaggten Klassen bevorzugen (Klassenhierarchien sind besser als getaggte Klassen)
- Punkt 24: Bevorzugen Sie statische Mitgliedsklassen gegenüber nicht statischen (statische Mitgliedsklassen sind besser als nicht statische Mitgliedsklassen)
- Punkt 25: Quelldateien auf eine einzelne Top-Level-Klasse beschränken (Quelldateien sind auf eine einzelne Top-Level-Klasse beschränkt)
- Kapitel 5. Generika
- Kapitel 5 Einführung
- Punkt 26: Keine Rohtypen verwenden (Keine Rohtypen verwenden)
- Punkt 27: Ungeprüfte Warnungen beseitigen (ungeprüfte Warnungen beseitigen)
- Punkt 28: Listen gegenüber Arrays bevorzugen (Liste ist besser als Array)
- Punkt 29: Generische Typen bevorzugen (generische Typen bevorzugen)
- Punkt 30: Generische Methoden bevorzugen (generische Methoden bevorzugen)
- Punkt 31: Begrenzte Platzhalter verwenden, um die API-Flexibilität zu erhöhen (begrenzte Platzhalter verwenden, um die API-Flexibilität zu erhöhen)
- Punkt 32: Kombinieren Sie Generika und Varargs mit Bedacht
- Punkt 33: Typsichere heterogene Container berücksichtigen (Typsichere heterogene Container berücksichtigen)
- Kapitel 6. Aufzählungen und Anmerkungen (Aufzählungen und Anmerkungen)
- Kapitel 6 Einführung
- Punkt 34: Aufzählungen statt Int-Konstanten verwenden (Aufzählungstypen statt Int-Konstanten verwenden)
- Punkt 35: Verwenden Sie Instanzfelder anstelle von Ordinalzahlen
- Punkt 36: EnumSet anstelle von Bitfeldern verwenden (EnumSet anstelle von Bitfeldern verwenden)
- Punkt 37: Verwenden Sie EnumMap anstelle der Ordinalindizierung (Verwenden Sie EnumMap, um die Ordinalindizierung zu ersetzen)
- Punkt 38: Erweiterbare Aufzählungen mit Schnittstellen emulieren (Schnittstellen verwenden, um erweiterbare Aufzählungen zu simulieren)
- Punkt 39: Bevorzugen Sie Anmerkungen gegenüber Benennungsmustern (Anmerkungen sind besser als Benennungsmuster)
- Punkt 40: Verwenden Sie konsequent die Override-Annotation (bestehen Sie auf der Verwendung der @Override-Annotation)
- Punkt 41: Verwenden Sie Markierungsschnittstellen, um Typen zu definieren
- Kapitel 7. Lambdas und Streams (λ-Ausdrücke und Streams)
- Kapitel 7 Einführung
- Punkt 42: Bevorzugen Sie Lambdas gegenüber anonymen Klassen (λ-Ausdrücke sind besser als anonyme Klassen)
- Punkt 43: Methodenverweise gegenüber Lambdas bevorzugen (Methodenverweise sind besser als Lambda-Ausdrücke)
- Punkt 44: Befürworten Sie die Verwendung standardmäßiger Funktionsschnittstellen
- Punkt 45: Streams mit Bedacht nutzen
- Punkt 46: Nebenwirkungsfreie Funktionen in Streams bevorzugen (nebenwirkungsfreie Funktionen in Streams verwenden)
- Punkt 47: Sammlung gegenüber Stream als Rückgabetyp bevorzugen (Sammlung anstelle von Stream als Rückgabetyp bevorzugen)
- Punkt 48: Seien Sie vorsichtig, wenn Sie Streams parallel gestalten
- Kapitel 8. Methoden
- Kapitel 8 Einführung
- Punkt 49: Parameter auf Gültigkeit prüfen
- Punkt 50: Erstellen Sie bei Bedarf Verteidigungskopien
- Punkt 51: Methodensignaturen sorgfältig entwerfen (Methodensignaturen sorgfältig entwerfen)
- Punkt 52: Überlastung mit Bedacht einsetzen
- Punkt 53: Verwenden Sie Varargs mit Bedacht
- Punkt 54: Leere Sammlungen oder Arrays zurückgeben, keine Nullen (leere Sammlungen oder Arrays zurückgeben, keine Nullen)
- Punkt 55: Geben Sie Optionen mit Bedacht zurück
- Punkt 56: Dokumentkommentare für alle offengelegten API-Elemente schreiben
- Kapitel 9. Allgemeine Programmierung
- Kapitel 9 Einführung
- Punkt 57: Minimieren Sie den Umfang lokaler Variablen (minimieren Sie den Umfang lokaler Variablen)
- Punkt 58: For-each-Schleifen den traditionellen for-Schleifen vorziehen (for-each-Schleife ist besser als die traditionelle for-Schleife)
- Punkt 59: Die Bibliotheken kennen und nutzen
- Punkt 60: Vermeiden Sie Float- und Double-Typen, wenn genaue Antworten erforderlich sind (Float- und Double-Typen sollten vermieden werden, wenn genaue Antworten erforderlich sind).
- Punkt 61: Primitive Typen gegenüber Box-Primitiven bevorzugen (Basisdatentypen sind besser als Wrapper-Klassen)
- Punkt 62: Vermeiden Sie Zeichenfolgen, wenn andere Typen geeigneter sind (vermeiden Sie die Verwendung von Zeichenfolgen, wenn andere Typen geeigneter sind)
- Punkt 63: Achten Sie auf die Leistung der Zeichenfolgenverkettung (Vorsicht vor Leistungsproblemen, die durch die Zeichenfolgenverkettung verursacht werden)
- Punkt 64: Verweisen Sie auf Objekte anhand ihrer Schnittstellen
- Punkt 65: Schnittstellen der Reflexion vorziehen (Schnittstelle ist besser als Reflexion)
- Punkt 66: Verwenden Sie native Methoden mit Bedacht
- Punkt 67: Mit Bedacht optimieren
- Punkt 68: Halten Sie sich an allgemein anerkannte Namenskonventionen
- Kapitel 10. Ausnahmen
- Kapitel 10 Einführung
- Punkt 69: Ausnahmen nur für außergewöhnliche Bedingungen verwenden
- Punkt 70: Geprüfte Ausnahmen für behebbare Bedingungen und Laufzeitausnahmen für Programmierfehler verwenden (geprüfte Ausnahmen für behebbare Bedingungen und Laufzeitausnahmen für Programmierfehler verwenden)
- Punkt 71: Vermeiden Sie die unnötige Verwendung geprüfter Ausnahmen (Vermeiden Sie die unnötige Verwendung geprüfter Ausnahmen)
- Punkt 72: Befürworten Sie die Verwendung von Standardausnahmen (fördern Sie die Wiederverwendung von Standardausnahmen)
- Punkt 73: Ausnahmen auslösen, die der Abstraktion entsprechen (Ausnahmen auslösen, die durch Abstraktion erklärt werden können)
- Punkt 74: Dokumentieren Sie alle von jeder Methode ausgelösten Ausnahmen (zeichnen Sie alle von jeder Methode ausgelösten Ausnahmen auf)
- Punkt 75: Informationen zur Fehlererfassung in Detailmeldungen einbeziehen (Ausnahmedetailmeldungen sollten Informationen zu Erfassungsfehlern enthalten)
- Punkt 76: Streben Sie nach Fehleratomizität (versuchen Sie Ihr Bestes, um die Fehleratomizität sicherzustellen)
- Punkt 77: Ausnahmen nicht ignorieren
- Kapitel 11. Parallelität
- Kapitel 11 Einführung
- Punkt 78: Synchronisieren Sie den Zugriff auf gemeinsam genutzte veränderbare Daten
- Punkt 79: Vermeiden Sie übermäßige Synchronisierung
- Punkt 80: Executoren, Aufgaben und Streams gegenüber Threads bevorzugen (Executoren, Aufgaben und Streams sind besser als die direkte Verwendung von Threads)
- Punkt 81: Parallelitätsdienstprogramme dem Warten und Benachrichtigen vorziehen (Parallelitätsdienstprogramme sind besser als Warten und Benachrichtigen)
- Punkt 82: Thread-Sicherheit dokumentieren (Dokument sollte Thread-Sicherheitsattribute enthalten)
- Punkt 83: Verwenden Sie die verzögerte Initialisierung mit Bedacht
- Punkt 84: Verlassen Sie sich nicht auf den Thread-Scheduler (Verlassen Sie sich nicht auf den Thread-Scheduler)
- Kapitel 12. Serialisierung
- Kapitel 12 Einführung
- Punkt 85: Alternativen zur Java-Serialisierung bevorzugen (Alternativen zur Java-Serialisierung bevorzugen)
- Punkt 86: Implementieren Sie Serializable mit großer Vorsicht
- Punkt 87: Erwägen Sie die Verwendung eines benutzerdefinierten serialisierten Formulars (Erwägen Sie die Verwendung eines benutzerdefinierten serialisierten Formulars)
- Punkt 88: readObject-Methoden defensiv schreiben (readObject-Methoden defensiv schreiben)
- Punkt 89: Für die Instanzsteuerung bevorzugen Sie Aufzählungstypen gegenüber readResolve (Für die Instanzsteuerung sind Aufzählungstypen besser als readResolve)
- Punkt 90: Erwägen Sie Serialisierungs-Proxys anstelle von serialisierten Instanzen (Erwägen Sie Serialisierungs-Proxys anstelle von serialisierten Instanzen)
