Introduction to Software Design with Java, 3rd Edition (Martin P. Robillard)（Z-Library）

【One-Line Pitch】 A narrative-driven introduction to object-oriented software design in Java that teaches you to reason about design trade-offs, not just syntax. Best for programmers who can already write small programs and now want to build larger, well-structured systems. 【Book Arc】 - **Opening (~0%–15%)**: Frames software design as a distinct activity from coding, using a deliberately obfuscated program to show why self-evident structure matters; also lays out the book's apparatus (chapter overviews, design contexts, insights, code explorations). - **Early (~15%–35%)**: Moves from design fundamentals into interfaces and encapsulation—separating specification from implementation, function objects, iterators, the ITERATOR and STRATEGY patterns, dependency injection, and the Interface Segregation Principle. - **Middle (~35%–55%)**: Covers object state (nullability, final fields, identity/equality, FLYWEIGHT, SINGLETON), unit testing with JUnit (stubs, coverage, testing exceptions), and composition (COMPOSITE, DECORATOR, PROTOTYPE, COMMAND, the Law of Demeter). - **Late (~55%–75%)**: Tackles inheritance in depth—typing, field/method inheritance, overloading, abstract classes, TEMPLATE METHOD, and the inheritance-versus-composition decision—then inversion of control via MVC, OBSERVER, GUI event handling, and VISITOR. - **Ending (~75%–100%)**: Shifts to functional-style design (first-class functions and related techniques), followed by appendices on Java essentials, coding conventions, and the two sample applications (a card game and the JetUML diagramming tool). 【Key Takeaways】 - **Design is a process of exploring alternatives, not applying rules** (Opening): the book's continuous narrative shows competing solutions in context, so you learn judgment rather than memorized patterns. - **Interfaces separate what from how** (Early): specifying behavior with interface types, function objects, and dependency injection makes code substitutable and testable—foundational for everything later. - **State deserves explicit design attention** (Middle): nullability, finality, and object identity/equality decisions ripple through correctness; FLYWEIGHT and SINGLETON show when sharing or uniqueness is warranted. - **Unit testing is part of design, not an afterthought** (Middle): JUnit fundamentals, test organization, stubs, and coverage are presented as forces that shape encapsulation and structure. - **Composition is the default; inheritance is the exception** (Late): the book weighs inheritance against composition explicitly and warns about its pitfalls, with abstract classes and TEMPLATE METHOD as disciplined uses. - **Inversion of control decouples components** (Late): MVC, OBSERVER, and event handling show how frameworks call your code, a mental shift for building interactive systems. - **Functional-style design complements OO** (Ending): first-class functions offer another axis for structuring behavior, not a replacement for objects. - **Practice is mandatory** (throughout): companion exercises, two full sample applications, and "Code Exploration" insets tie each concept to real code you should read and run. 【Reading Tips】 - Read the chapter-opening overview and the closing **Insights** section first for each chapter; the Insights are an actionable summary you can revisit as a checklist. - Deep-read the design contexts and trade-off discussions; skim Java-specific mechanics you already know, since the book treats Java as a vehicle for general design ideas. - Treat "Code Exploration" insets and the sample applications (card game, JetUML) as required work—download the code and experiment rather than reading passively. - Hard spots: inheritance-versus-composition reasoning, inversion of control, and functional design; slow down there and do the exercises. - Use the companion website's interactive code samples and practice exercises to reinforce each chapter before moving on. 【Coverage Limits】 This guide is based on the book's front matter, preface, and table of contents; the excerpts do not cover the detailed content of individual chapters, so specific examples and code discussions are summarized at the structural level only.