编写高质量代码 改善Java程序的151个建议 (秦小波著)（Z-Library）

【One-Line Pitch】 A practical, advice-driven handbook for Java developers who want to write cleaner, more robust, and more maintainable code through 151 concrete recommendations covering everything from basic syntax pitfalls to advanced design and concurrency issues. If you are a working Java programmer looking to level up your coding habits, this is your checklist. 【Book Arc】 - **Opening (~0%–10%)**: The book opens with foundational advice on general coding practices, such as avoiding "magic numbers," using constants properly, and writing self-documenting code. This stage establishes the core philosophy: small, deliberate choices in everyday coding prevent big problems later. - **Early (~10%–30%)**: Moves into object-oriented design principles, covering topics like equals/hashCode contracts, immutability, and proper use of inheritance and composition. This section helps readers avoid classic Java traps that lead to subtle bugs. - **Middle (~30%–60%)**: Focuses on the Java language specifics — generics, collections, and exception handling. Advice here targets performance pitfalls, type-safety issues, and the correct way to handle errors without swallowing them. - **Late (~60%–85%)**: Shifts to concurrency and multithreading, offering recommendations on thread safety, synchronization, and the pitfalls of shared state. This is where the book gets advanced, addressing real-world concurrency bugs and how to avoid them. - **Ending (~85%–100%)**: Wraps up with broader topics like JVM tuning, performance optimization, and code quality tools. The final advice ties everything together, emphasizing that high-quality code is a continuous, disciplined practice, not a one-time fix. 【Key Takeaways】 - **Constants beat magic numbers** (Early): Using named constants instead of raw literals makes code self-documenting and easier to maintain. This is the first step toward professional-grade code. - **Respect the equals/hashCode contract** (Early): Breaking this contract leads to unpredictable behavior in collections like HashMap and HashSet. Always override both together, and use immutable fields where possible. - **Prefer composition over inheritance** (Middle): Inheritance couples classes tightly and makes refactoring risky. Composition gives you flexibility and reduces the chance of fragile base-class problems. - **Generics are for compile-time safety, not runtime** (Middle): Type erasure means you cannot rely on runtime type checks for generics. Design your APIs to be type-safe at compile time, and avoid unchecked casts. - **Exceptions should be exceptional** (Middle): Don't use exceptions for normal control flow; they are expensive and obscure the logic. Catch specific exceptions, not `Exception` or `Throwable`, and always preserve the original stack trace. - **Thread safety requires discipline, not luck** (Late): Synchronize on the right lock, avoid double-checked locking without volatile, and prefer `java.util.concurrent` utilities over hand-rolled synchronization. Shared mutable state is the root of most concurrency bugs. - **Performance tuning is a last resort** (Ending): Optimize only after profiling shows a real bottleneck. Premature optimization complicates code and often yields negligible gains; clarity and correctness come first. 【Reading Tips】 - **Skim the "suggestion" headers first**: Each of the 151 items is self-contained. If you are short on time, read the title and the first paragraph of each suggestion, then dive deep only into topics relevant to your current project. - **Deep-read the concurrency section**: The late chapters on threading are the most technically dense and where most real-world bugs hide. Take time to understand the reasoning behind each recommendation, not just the rule itself. - **Treat it as a reference, not a novel**: This book is structured as a list of tips. Keep it on your desk and consult it when you encounter a specific problem (e.g., "why is my HashMap behaving oddly?") rather than reading cover to cover. - **Watch for code examples**: The book is full of short Java snippets. Read them carefully — the "wrong" examples are as instructive as the "right" ones, showing you exactly what to avoid. - **Pair with your own code review**: After each section, review your existing codebase for violations of the advice. This turns passive reading into active learning and immediately improves your projects. 【Coverage Limits】 The excerpts provided contain only the book's title and author, so this guide is based on the book's well-known structure and themes rather than detailed content from the text. Specific examples, code listings, and the exact numbering of the 151 suggestions are not covered here.