Developing applications with Java and UML (Paul R. Reed)（Z-Library）

# Developing Applications with Java and UML — Reading Guide ## 【One-Line Pitch】 A practical, process-driven guide for Java developers and project teams who want to master UML as a design tool and apply the Rational Unified Process to build robust, maintainable enterprise applications. If you're moving from "just writing code" to "engineering software with intent," this book shows you the full journey from requirements to deployment. ## 【Book Arc】 - **Opening (~0%–10%)**: Introduces the book's core promise — using UML as the standard notation for object-oriented design in Java. Sets up the Rational Unified Process (RUP) as the guiding methodology, explains its phases (Inception, Elaboration, Construction, Transition), and positions the book around a large-scale sample project (Remulak Productions, a musical instrument retailer) that runs throughout. - **Early (~10%–23%)**: Covers UML diagram fundamentals and the critical distinction between implementation inheritance (extends) and interface inheritance. Discusses which diagrams matter most in practice (class, sequence, use-case, component, deployment), introduces the "fragile base class" problem, and explains how sequence diagrams serve as the primary tool for walking through use-case pathways before coding. - **Early-to-Middle (~23%–39%)**: Dives deep into requirements gathering — identifying actors, use-cases, and the three levels of pathways (primary, alternate, exception). Presents a detailed use-case template with sections for trigger events, steps, variations, business rules, and constraints. Introduces project estimation techniques (function point analysis) and the concept of delivering in increments. - **Middle (~39%–48%)**: Focuses on class identification and design. Explains the role of the class diagram as the pivotal UML artifact, offers practical techniques like noun extraction from use-cases, and covers association types — aggregation vs. composition (solid vs. hollow diamond), link associations, and operation signatures. Emphasizes that class diagrams evolve iteratively as understanding deepens. - **Late (~48%–end)**: Applies everything to the Remulak Productions project — mapping UML designs to Java code, implementing server-side functionality with JSP, servlets, and EJB 2.0 (Session Beans, Entity Beans with both Bean-Managed and Container-Managed Persistence), and deploying on application servers. The book closes by tying the entire process together: from project plan → requirements → design → code → deployment. ## 【Key Takeaways】 - **The Rational Unified Process is the backbone of the book** (Opening): RUP's four phases (Inception, Elaboration, Construction, Transition) provide a disciplined framework, with milestones like "Lifecycle Objective" marking progress. The book deliberately filters RUP to focus on high-value artifacts rather than process overhead. - **UML is a communication tool, not a paperwork exercise** (Early): The author stresses "light" documentation — knowing which diagrams to produce and when. At minimum: class, sequence, and use-case diagrams; component and deployment diagrams are strongly recommended to avoid the common pitfall of poor physical architecture. - **Interface inheritance beats implementation inheritance in Java** (Early): The "fragile base class problem" — where superclass code becomes unstable as business evolves — is a real risk. Java's first-class interface support makes interface-based programming a safer default, though implementation inheritance (extends) has its place for genuinely shared, stable behavior. - **Sequence diagrams are the new code walkthrough** (Early): Instead of reading code to verify logic, teams walk through sequence diagrams to validate use-case pathways. This shifts quality assurance earlier in the process and makes method-level coding a more mechanical step. - **Use-cases need a project-wide template** (Early-to-Middle): UML defines diagram notation but not what goes inside a use-case. A standardized template — covering trigger events, steps, variations, business rules, constraints — is essential for consistency. The book's template is battle-tested and practical. - **Class identification is a learnable skill** (Middle): Two approaches: facilitated brainstorming sessions or systematic noun extraction from use-cases. The class diagram starts sparse and evolves with each iteration — it's the pivot from which component and deployment diagrams derive. - **Aggregation vs. composition has real code implications** (Middle): In Java the effect is often the same, but the distinction matters conceptually — composition means the whole owns the parts' lifecycle; aggregation means parts can outlive the whole. Link associations handle cases where attributes belong to the relationship itself. - **Estimation and incremental delivery are part of design** (Middle): The book ties estimating (via function point analysis) to increment planning — Remulak's project is split into three increments (670, 950, 950 person-hours) to manage risk and deliver value progressively. ## 【Reading Tips】 1. **Skim the RUP theory in the opening chapters** if you're already familiar with iterative development — the key insight is which artifacts matter, not the full process details. Focus on the "wheat from the chaff" philosophy. 2. **Deep-read the use-case template chapter** (~29%–39%): This is the most immediately actionable content. The four-section template (high-level info, steps, variations, business rules) is something you can adopt on your next project as-is. 3. **Pay close attention to the class design chapters** (~39%–48%): The guidelines for identifying classes, distinguishing aggregation/composition, and designing operation signatures are the heart of the book's practical value. These are the skills that separate adequate from excellent UML designers. 4. **Treat the Remulak Productions case study as a reference, not a novel**: The sample project ties everything together, but you can skip detailed code listings if you're primarily interested in the design methodology. Use it to see how diagrams trace to code. 5. **Note the book's era (2001)**: EJB 2.0, JSP, and servlets are dated technologies. Read for the process and design principles, not the specific frameworks. The UML and RUP concepts remain relevant; the implementation details are historical context. ## 【Coverage Limits】 This guide covers the book's core methodology — RUP, UML diagram usage, use-case analysis, class design, and the mapping from design to Java implementation. The excerpts do not cover the later chapters' detailed EJB 2.0 implementation specifics, deployment strategies, or the full Remulak code listings in depth. ##