Effective Java[TM], second edition (Bloch, Joshua)（Z-Library）

【One-Line Pitch】 A timeless, item-by-item playbook for writing robust, efficient, and maintainable Java code, this book is essential reading for intermediate to advanced Java developers who want to move beyond "working" code to "excellent" code. 【Book Arc】 - **Opening (~0%–10%)**: The book opens with front matter and an introduction that sets the stage, explaining the book's purpose: to provide best practices for using the Java language and its libraries effectively. It establishes the book's structure of 78 standalone "items" and introduces the engineering version numbers used throughout. - **Early (~10%–23%)**: This section dives into the first major theme: creating and destroying objects. It covers the trade-offs between static factory methods and constructors, the Builder pattern for classes with many parameters, and the pitfalls of creating unnecessary objects. - **Early (~23%–32%)**: Continuing the theme of object lifecycle, this part addresses the controversial topic of finalizers, explaining why they should generally be avoided and what the few legitimate use cases are. It then transitions into the critical contract for overriding `equals`, setting up the deep dive into methods common to all objects. - **Middle (~32%–48%)**: This is the heart of the "Methods Common to All Objects" chapter. It provides a detailed, recipe-like guide to correctly implementing `equals`, `hashCode`, and `clone`, complete with the formal contracts, common pitfalls (like symmetry violations), and step-by-step algorithms. - **Late (~48%–End)**: The book continues with more items covering generics, enums, annotations, and other advanced topics, culminating in best practices for concurrency and serialization. The excerpts provided focus heavily on the foundational object methods, but the book's scope extends to these more advanced areas. 【Key Takeaways】 - **Prefer static factory methods over constructors** (Early): They have names, can return subtypes, and can control instance creation (e.g., singletons). This is a fundamental design choice that improves API clarity and flexibility. - **Use the Builder pattern for classes with many parameters** (Early): Especially when most parameters are optional, a builder is more readable and safer than telescoping constructors. It's worth the extra verbosity for classes with four or more parameters. - **Avoid finalizers** (Early): Finalizers are unpredictable, dangerous, and generally unnecessary. Use explicit termination methods (like `close()`) in a `try-finally` block instead, and reserve finalizers only as a "safety net" or for objects with native peers. - **Obey the `equals` contract** (Middle): Violating symmetry, transitivity, or consistency can cause erratic behavior in collections. The `java.sql.Timestamp` class is a cautionary tale of how breaking this contract leads to hard-to-debug bugs. - **Implement `hashCode` whenever you override `equals`** (Middle): The contract requires equal objects to have equal hash codes. The book provides a concrete, step-by-step recipe for computing a good hash code, emphasizing the use of the number 31 in the calculation. - **Be cautious with `Cloneable`** (Middle): The `Cloneable` interface is atypical and its protocol is complex and unenforceable. A well-behaved `clone` method is hard to write correctly, and the book suggests considering alternatives like copy constructors or factories. - **Avoid creating unnecessary objects** (Early): Reusing objects is often cheaper than creating new ones. Be wary of autoboxing, which can create hidden performance costs by blurring the line between primitives and boxed types. 【Reading Tips】 - **Skim the front matter and introduction** (~0%–10%): This is mostly legal and administrative. The key takeaway is the book's structure and the version numbering scheme, which you can quickly scan and move past. - **Deep-read the "Methods Common to All Objects" chapter** (~32%–48%): This is the most critical and dense material. Pay close attention to the step-by-step recipes for `equals` and `hashCode`; these are directly applicable to your daily coding. - **Treat each "item" as a standalone lesson**: The book is designed for reference. You can jump to any item that addresses a problem you're facing without needing to read linearly. - **Focus on the "why" behind each recommendation**: The book excels at explaining the reasoning and potential pitfalls. Understanding the rationale is more valuable than memorizing the rule, as it helps you make sound judgments in new situations. - **Use the code examples as a starting point**: The examples are simplified for readability. Visit the book's website for expanded, compilable versions to see the patterns in full context. 【Coverage Limits】 This guide is based on excerpts that primarily cover the book's opening and the early chapters on object creation and the `equals`/`hashCode`/`clone` contracts. The later sections on generics, enums, concurrency, and serialization are not covered in detail here.