设计模式之禅（第2版） (秦小波)（Z-Library）

# Design Patterns: The Zen of Design Patterns (2nd Edition) ## 【One-Line Pitch】 A famously readable, example-driven tour of 6 design principles and 28 design patterns in Java, written with humor and everyday analogies (games, romance of the Three Kingdoms, school report cards) so that even intimidating theory feels like light fiction. Ideal for working programmers who want to finally "get" design patterns and apply them to real projects without wading through dry academic prose. --- ## 【Book Arc】 - **Opening (~0%–10%)**: The 6 object-oriented design principles — Single Responsibility, Liskov Substitution, Interface Segregation, Law of Demeter, Dependency Inversion, and Open-Closed — are each explained through concrete, sometimes funny examples (a phone interface, a sniper's rifle, a bookstore adding computer books). The goal is to build a principled foundation before any pattern is introduced. - **Early (~10%–33%)**: The classic creational and structural patterns arrive: Factory Method, Abstract Factory, Builder (car assembly sequences), Proxy (game power-leveling), Prototype (cloning objects like the movie *The 6th Day*), Mediator, and Chain of Responsibility (a family where requests are passed from father to husband to son). Each chapter follows the same rhythm: definition, class diagram, code, then "pattern extension" and "best practices." - **Middle (~33%–57%)**: More structural and behavioral patterns: Strategy (the "three clever plans" from Romance of the Three Kingdoms), Adapter, Iterator, Composite (company org trees), Observer, Memento (state backup/restore with BeanUtils reflection), and Visitor (report generation for different employee types). The book begins to emphasize trade-offs — e.g., Composite's conflict with Dependency Inversion, Visitor's violation of the Law of Demeter. - **Late (~57%–75%)**: State patterns (elevator control), and the book's signature "Pattern PK" section — head-to-head comparisons of similar patterns (e.g., Strategy vs. State, Adapter vs. Proxy) to clarify when each is the right choice. This is where the "zen" of pattern selection really comes into focus. - **Ending (~75%–100%)**: "Mixed patterns" — how to combine multiple patterns in one real system (e.g., MVC architecture, interceptor chains) — plus 5 new patterns added in this 2nd edition. The book closes with a detachable color reference chart of all patterns. --- ## 【Key Takeaways】 - **Design principles come first, patterns second** (Opening): The 6 principles (Single Responsibility, Liskov Substitution, Interface Segregation, Law of Demeter, Dependency Inversion, Open-Closed) are the "why" behind every pattern. The book's core claim: if you master these, patterns become obvious solutions rather than memorized recipes. - **"Responsibilities" and "reasons for change" are not measurable** (Opening): The Single Responsibility Principle is the hardest to apply because there's no objective metric for what counts as "one responsibility." The book's honest advice: weigh change risk against design complexity in your actual project context — a simple IPhone interface may be perfectly fine. - **Liskov Substitution is about contracts, not just inheritance** (Opening): A subclass must be substitutable for its parent wherever the parent appears — downcasting to a subclass (like a sniper receiving a specific rifle type) is unsafe and violates the principle. The book links this to Design by Contract: preconditions can be widened, postconditions must not be weakened. - **Open-Closed Principle is "vague by design"** (Opening): It's a slogan, not a spec — the other 5 principles are its concrete manifestations. Abstract layers must stay stable once defined; extension happens through interfaces and abstract classes, never by modifying them. - **Proxy is interception and enhancement** (Early): The game power-leveling example shows the essence: a proxy wraps the real object, adds behavior (logging, fees, access control) without changing the target's code. The "proxy's personality" (e.g., a fee-calculating IProxy interface) belongs in the proxy's own interface, not the subject's. - **Prototype = clone from a template, not build from zero** (Early): The *6th Day* analogy (cloning a person directly at age 30) captures the pattern's value: start from an object with most of the state you need, copy it, then tweak the details. This is far cheaper than reconstructing complex objects from scratch. - **Composite gives simple tree handling but breaks interface purity** (Middle): All nodes (root, branch, leaf) share one Component interface, so callers don't care whether they're dealing with one object or a whole tree. But the book is candid: you'll often end up referencing concrete classes, which conflicts with Dependency Inversion — know the trade-off before using it. - **Visitor is the escape hatch when Iterator isn't enough** (Middle): When you need to traverse *different* object types and perform *different* operations per type, Visitor extends Iterator's capability. But it comes at a cost: it exposes internal details (violating the Law of Demeter) and makes adding new element types painful. --- ## 【Reading Tips】 - **Skim the code, read the stories**: The examples (game proxies, Three Kingdoms strategies, elevator state machines) carry the conceptual payload. Read them for the "why," then skim the Java listings to confirm the structure — you don't need to type every line to absorb the pattern. - **Deep-read the "Pattern Extension" and "Best Practices" sections**: These are the author's claimed "secret skills" — where each chapter goes beyond the textbook definition into real-world variations and pitfalls. This is where the book earns its "zen" title. - **Don't skip the principle chapters (1–6)**: They may feel abstract, but every later pattern references them. If you're short on time, at least read the Open-Closed chapter — it's the master principle that ties everything together. - **Use the "Pattern PK" section as a decision guide**: When you're unsure whether to use Strategy or State, Adapter or Proxy, jump straight to the comparison chapters (30–33). They're designed to be consulted, not just read linearly. - **Treat the mixed-pattern chapters as capstone projects**: The MVC and interceptor examples show how patterns compose in real systems. If you're a beginner, save these for after you've internalized the individual patterns. --- ## 【Coverage Limits】 This guide is synthesized from excerpts covering roughly the first 57% of the book (principles through Visitor). The later sections — Pattern PK comparisons, mixed-pattern chapters, MVC analysis, and the 5 new patterns added in the 2nd edition — are described from the book's table of contents but not from detailed excerpt content. --- ##