Effective Java 中文版（第2版） (Joshua Bloch) (Z-Library)

【One-Line Pitch】 A rule-by-rule field manual for writing Java that other people can actually maintain: 78 short, opinionated items on objects, generics, enums, methods, and concurrency. Best for working Java developers who already know the syntax and now want to stop shipping subtly broken code. 【Book Arc】 - **Opening (~0%–10%)**: Frames the whole method — each item is a self-contained rule backed by example code — and immediately dives into object creation: static factories vs. constructors, the telescoping-constructor problem, Builder, and Singleton (including the single-element enum). - **Early (~10%–33%)**: The universal-method core. Deep treatment of `equals`/`hashCode` contracts (symmetry, transitivity, consistency), `toString`, and the many traps of `clone` and `finalize`, with the recurring lesson that violating these contracts breaks `HashMap`, `HashSet`, and friends. - **Middle (~33%–57%)**: Class and interface design — minimizing accessibility, avoiding exposed mutable fields, favoring composition over inheritance, designing and documenting for inheritance (or forbidding it), plus `Comparable`, constant interfaces, and skeletal implementations. - **Late (~57%–80%)**: The Java 5 feature block — generics, enums, annotations, autoboxing, varargs, and for-each — taught as patterns and idioms rather than syntax, with emphasis on erasure, bounded wildcards, and avoiding accidental boxing costs. - **Ending (~80%–100%)**: Method design (parameters, return values, signatures, documentation), then general programming details — local variables, control structures, library use, reflection and native methods, naming conventions, and optimization. The excerpts do not cover the serialization and concurrency items in detail. 【Key Takeaways】 - **Prefer static factories over public constructors when naming or caching matters** (Opening): they allow meaningful names, instance reuse, and return-type flexibility, and they underpin service-provider frameworks like JDBC. - **Builder beats telescoping constructors and JavaBeans for many optional parameters** (Opening): it keeps construction atomic and the object consistent, unlike step-by-step setters that leave objects temporarily invalid. - **The single-element enum is the best Singleton** (Opening): concise, serialization-safe, and immune to reflection attacks — a rare case where a newer idiom cleanly replaces older ones. - **`equals` and `hashCode` are a package deal with real contracts** (Early): breaking symmetry, transitivity, or consistency silently corrupts hash-based collections; a constant `hashCode` is legal but degrades hash tables to linked lists. - **`clone` and `finalize` are best avoided** (Early): `Cloneable` is flawed, deep copies risk stack overflow if done recursively, and copy constructors/conversion constructors are usually the better tool. - **Design for inheritance deliberately, or prohibit it** (Middle): constructors must never call overridable methods, protected members are permanent API commitments, and you should write subclasses before releasing an extensible class. - **Minimize accessibility and never expose mutable fields** (Middle): package-private is the default target; public immutable fields are a lesser evil, but `Point`/`Dimension`-style exposure is a cautionary tale. - **Generics, enums, and annotations are patterns, not just syntax** (Late): the payoff comes from idioms — bounded wildcards, skeletal implementations, enum-based constants — that keep code simple while gaining type safety. 【Reading Tips】 - Treat it as a reference, not a novel: read the item titles first, then deep-read the items touching code you currently own (object creation, `equals`/`hashCode`, generics). - Skim the Java 5 feature chapters if you already use generics and enums daily, but slow down on erasure, wildcards, and autoboxing pitfalls — those are where experienced developers still slip. - For each rule, ask "what breaks if I ignore this?" The book's power is in the failure modes, not the prescriptions. - Keep the item numbers as a shared vocabulary with your team; citing "Item 9" in code review is faster than re-arguing the design. - The serialization and concurrency material is only lightly represented in these excerpts — consult the full book for those chapters. 【Coverage Limits】 This guide is built from stratified excerpts covering object creation, universal methods, class/interface design, generics/enums/annotations, and method design; serialization, concurrency, and the appendix's version comparison are not covered in detail here.