Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, Second Edition.chm

【实例简介】Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, Second Edition

【实例截图】

书籍

【核心代码】

Publisher	: Prentice Hall PTR
Pub Date	: July 16, 2001
ISBN	: 0-13-092569-1
Pages	: 650


   		Copyright
   		Sample UML Notation
   		Praise for Applying UML and Patterns
   		Foreword
   		Preface
   	 		Objectives
   	 		Intended Audience
   	 		Prerequisites
   	 		Java Examples
   	 		Book Organization
   	 		Web-Related Resources
   	 		Enhancements to the First Edition
   	 		Acknowledgments
   	 		About the Author
   	 		Contact
   	 		Typographical Conventions
   	 		Production Notes

   		Part 1.  Introduction
   	 		  Chapter 1.  Object-Oriented Analysis and Design
   	 		Section 1.1.  Applying UML and Patterns in OOA/D
   	 		Section 1.2.  Assigning Responsibilities
   	 		Section 1.3.  What Is Analysis and Design?
   	 		Section 1.4.  What Is Object-Oriented Analysis and Design?
   	 		Section 1.5.  An Example
   	 		Section 1.6.  The UML
   	 		Section 1.7.  Further Readings

   	 		  Chapter 2.  Iterative Development and the Unified Process
   	 		Introduction
   	 		Section 2.1.  The Most Important UP Idea: Iterative Development
   	 		Section 2.2.  Additional UP Best Practices and Concepts
   	 		Section 2.3.  The UP Phases and Schedule-Oriented Terms
   	 		Section 2.4.  The UP Disciplines (was Workflows)
   	 		Section 2.5.  Process Customization and the Development Case
   	 		Section 2.6.  The Agile UP
   	 		Section 2.7.  The Sequential "Waterfall" Lifecycle
   	 		Section 2.8.  You Know You Didn't Understand the UP When...
   	 		Section 2.9.  Further Readings

   	 		  Chapter 3.  Case Study: The NextGen POS System
   	 		Introduction
   	 		Section 3.1.  The NextGen POS System
   	 		Section 3.2.  Architectural Layers and Case Study Emphasis
   	 		Section 3.3.  The Book's Strategy: Iterative Learning and Development


   		Part 2.  Inception
   	 		  Chapter 4.  Inception
   	 		Introduction
   	 		Section 4.1.  Inception: An Analogy
   	 		Section 4.2.  Inception May Be Very Brief
   	 		Section 4.3.  What Artifacts May Start in Inception?
   	 		Section 4.4.  You Know You Didn't Understand Inception When...

   	 		  Chapter 5.  Understanding Requirements
   	 		Introduction
   	 		Section 5.1.  Types of Requirements
   	 		Section 5.2.  Further Readings

   	 		  Chapter 6.  Use-Case Model: Writing Requirements in Context
   	 		Introduction
   	 		Section 6.1.  Goals and Stories
   	 		Section 6.2.  Background
   	 		Section 6.3.  Use Cases and Adding Value
   	 		Section 6.4.  Use Cases and Functional Requirements
   	 		Section 6.5.  Use Case Types and Formats
   	 		Section 6.6.  Fully Dressed Example: Process Sale
   	 		Section 6.7.  Explaining the Sections
   	 		Section 6.8.  Goals and Scope of a Use Case
   	 		Section 6.9.  Finding Primary Actors, Goals, and Use Cases
   	 		Section 6.10.  Congratulations: Use Cases Have Been Written, and Are Imperfect
   	 		Section 6.11.  Write Use Cases in an Essential UI-Free Style
   	 		Section 6.12.  Actors
   	 		Section 6.13.  Use Case Diagrams
   	 		Section 6.14.  Requirements in Context and Low-Level Feature Lists
   	 		Section 6.15.  Use Cases Are Not Object-Oriented
   	 		Section 6.16.  Use Cases Within the UP
   	 		Section 6.17.  Case Study: Use Cases in the NextGen Inception Phase
   	 		Section 6.18.  Further Readings
   	 		Section 6.19.  UP Artifacts and Process Context

   	 		  Chapter 7.  Identifying Other Requirements
   	 		Introduction
   	 		Section 7.1.  NextGen POS Examples
   	 		Section 7.2.  NextGen Example: (Partial) Supplementary Specification
   	 		Section 7.3.  Commentary: Supplementary Specification
   	 		Section 7.4.  NextGen Example: (Partial) Vision
   	 		Section 7.5.  Commentary: Vision
   	 		Section 7.6.  NextGen Example: A (Partial) Glossary
   	 		Section 7.7.  Commentary: Glossary (Data Dictionary)
   	 		Section 7.8.  Reliable Specifications: An Oxymoron?
   	 		Section 7.9.  Online Artifacts at the Project Website
   	 		Section 7.10.  Not Much UML During Inception?
   	 		Section 7.11.  Other Requirement Artifacts Within the UP
   	 		Section 7.12.  Further Readings
   	 		Section 7.13.  UP Artifacts and Process Context

   	 		  Chapter 8.  From Inception to Elaboration
   	 		Introduction
   	 		Section 8.1.  Checkpoint: What Happened in Inception?
   	 		Section 8.2.  On to Elaboration
   	 		Section 8.3.  Planning the Next Iteration
   	 		Section 8.4.  Iteration 1 Requirements and Emphasis: Fundamental OOA/D Skills
   	 		Section 8.5.  What Artifacts May Start in Elaboration?
   	 		Section 8.6.  You Know You Didn't Understand Elaboration When...


   		Part 3.  Elaboration Iteration 1
   	 		  Chapter 9.  Use-Case Model: Drawing System Sequence Diagrams
   	 		Moving on to Iteration 1
   	 		Introduction
   	 		Section 9.1.  System Behavior
   	 		Section 9.2.  System Sequence Diagrams
   	 		Section 9.3.  Example of an SSD
   	 		Section 9.4.  Inter-System SSDs
   	 		Section 9.5.  SSDs and Use Cases
   	 		Section 9.6.  System Events and the System Boundary
   	 		Section 9.7.  Naming System Events and Operations
   	 		Section 9.8.  Showing Use Case Text
   	 		Section 9.9.  SSDs and the Glossary
   	 		Section 9.10.  SSDs Within the UP
   	 		Section 9.11.  Further Readings
   	 		Section 9.12.  UP Artifacts

   	 		  Chapter 10.  Domain Model: Visualizing Concepts
   	 		Introduction
   	 		Section 10.1.  Domain Models
   	 		Section 10.2.  Conceptual Class Identification
   	 		Section 10.3.  Candidate Conceptual Classes for the Sales Domain
   	 		Section 10.4.  Domain Modeling Guidelines
   	 		Section 10.5.  Resolving Similar Conceptual Classes—Register vs. "POST"
   	 		Section 10.6.  Modeling the Unreal World
   	 		Section 10.7.  Specification or Description Conceptual Classes
   	 		Section 10.8.  UML Notation, Models, and Methods: Multiple Perspectives
   	 		Section 10.9.  Lowering the Representational Gap
   	 		Section 10.10.  Example: The NextGen POS Domain Model
   	 		Section 10.11.  Domain Models Within the UP
   	 		Section 10.12.  Further Readings
   	 		Section 10.13.  UP Artifacts

   	 		  Chapter 11.  Domain Model: Adding Associations
   	 		Introduction
   	 		Section 11.1.  Associations
   	 		Section 11.2.  The UML Association Notation
   	 		Section 11.3.  Finding Associations—Common Associations List
   	 		Section 11.4.  Association Guidelines
   	 		Section 11.5.  Roles
   	 		Section 11.6.  How Detailed Should Associations Be?
   	 		Section 11.7.  Naming Associations
   	 		Section 11.8.  Multiple Associations Between Two Types
   	 		Section 11.9.  Associations and Implementation
   	 		Section 11.10.  NextGen POS Domain Model Associations
   	 		Section 11.11.  NextGen POS Domain Model

   	 		  Chapter 12.  Domain Model: Adding Attributes
   	 		Introduction
   	 		Section 12.1.  Attributes
   	 		Section 12.2.  UML Attribute Notation
   	 		Section 12.3.  Valid Attribute Types
   	 		Section 12.4.  Non-primitive Data Type Classes
   	 		Section 12.5.  Design Creep: No Attributes as Foreign Keys
   	 		Section 12.6.  Modeling Attribute Quantities and Units
   	 		Section 12.7.  Attributes in the NextGen Domain Model
   	 		Section 12.8.  Multiplicity From SalesLineItem to Item
   	 		Section 12.9.  Domain Model Conclusion

   	 		  Chapter 13.  Use-Case Model: Adding Detail with Operation Contracts
   	 		Introduction
   	 		Section 13.1.  Contracts
   	 		Section 13.2.  Example Contract: enterItem
   	 		Section 13.3.  Contract Sections
   	 		Section 13.4.  Postconditions
   	 		Section 13.5.  Discussion—enterItem Postconditions
   	 		Section 13.6.  Writing Contracts Leads to Domain Model Updates
   	 		Section 13.7.  When Are Contracts Useful? Contracts vs. Use Cases?
   	 		Section 13.8.  Guidelines: Contracts
   	 		Section 13.9.  NextGen POS Example: Contracts
   	 		Section 13.10.  Changes to the Domain Model
   	 		Section 13.11.  Contracts, Operations, and the UML
   	 		Section 13.12.  Operation Contracts Within the UP
   	 		Section 13.13.  Further Readings

   	 		  Chapter 14.  From Requirements to Design in this Iteration
   	 		Introduction
   	 		Section 14.1.  Iteratively Do the Right Thing, Do the Thing Right
   	 		Section 14.2.  Didn't That Take Weeks To Do? No, Not Exactly.
   	 		Section 14.3.  On to Object Design

   	 		  Chapter 15.  Interaction Diagram Notation
   	 		Introduction
   	 		Section 15.1.  Sequence and Collaboration Diagrams
   	 		Section 15.2.  Example Collaboration Diagram: makePayment
   	 		Section 15.3.  Example Sequence Diagram: makePayment
   	 		Section 15.4.  Interaction Diagrams Are Valuable
   	 		Section 15.5.  Common Interaction Diagram Notation
   	 		Section 15.6.  Basic Collaboration Diagram Notation
   	 		Section 15.7.  Basic Sequence Diagram Notation

   	 		  Chapter 16.  GRASP: Designing Objects with Responsibilities
   	 		Introduction
   	 		Section 16.1.  Responsibilities and Methods
   	 		Section 16.2.  Responsibilities and Interaction Diagrams
   	 		Section 16.3.  Patterns
   	 		Section 16.4.  GRASP: Patterns of General Principles in Assigning Responsibilities
   	 		Section 16.5.  The UML Class Diagram Notation
   	 		Section 16.6.  Information Expert (or Expert)
   	 		Section 16.7.  Creator
   	 		Section 16.8.  Low Coupling
   	 		Section 16.9.  High Cohesion
   	 		Section 16.10.  Controller
   	 		Section 16.11.  Object Design and CRC Cards
   	 		Section 16.12.  Further Readings

   	 		  Chapter 17.  Design Model: Use-Case Realizations with GRASP Patterns
   	 		Introduction
   	 		Section 17.1.  Use-Case Realizations
   	 		Section 17.2.  Artifact Comments
   	 		Section 17.3.  Use-Case Realizations for the NextGen Iteration
   	 		Section 17.4.  Object Design: makeNewSale
   	 		Section 17.5.  Object Design: enterItem
   	 		Section 17.6.  Object Design: endSale
   	 		Section 17.7.  Object Design: makePayment
   	 		Section 17.8.  Object Design: startUp
   	 		Section 17.9.  Connecting the UI Layer to the Domain Layer
   	 		Section 17.10.  Use-Case Realizations Within the UP
   	 		Section 17.11.  Summary

   	 		  Chapter 18.  Design Model: Determining Visibility
   	 		Introduction
   	 		Section 18.1.  Visibility Between Objects
   	 		Section 18.2.  Visibility
   	 		Section 18.3.  Illustrating Visibility in the UML

   	 		  Chapter 19.  Design Model: Creating Design Class Diagrams
   	 		Introduction
   	 		Section 19.1.  When to Create DCDs
   	 		Section 19.2.  Example DCD
   	 		Section 19.3.  DCD and UP Terminology
   	 		Section 19.4.  Domain Model vs. Design Model Classes
   	 		Section 19.5.  Creating a NextGen POS DCD
   	 		Section 19.6.  Notation for Member Details
   	 		Section 19.7.  DCDs, Drawing, and CASE Tools
   	 		Section 19.8.  DCDs Within the UP
   	 		Section 19.9.  UP Artifacts

   	 		  Chapter 20.  Implementation Model: Mapping Designs to Code
   	 		Introduction
   	 		Section 20.1.  Programming and the Development Process
   	 		Section 20.2.  Mapping Designs to Code
   	 		Section 20.3.  Creating Class Definitions from DCDs
   	 		Section 20.4.  Creating Methods from Interaction Diagrams
   	 		Section 20.5.  Container/Collection Classes in Code
   	 		Section 20.6.  Exceptions and Error Handling
   	 		Section 20.7.  Defining the Sale--makeLineItem Method
   	 		Section 20.8.  Order of Implementation
   	 		Section 20.9.  Test-First Programming
   	 		Section 20.10.  Summary of Mapping Designs to Code
   	 		Section 20.11.  Introduction to the Program Solution


   		Part 4.  Elaboration Iteration 2
   	 		  Chapter 21.  Iteration 2 and its Requirements
   	 		Section 21.1.  Iteration 2 Emphasis: Object Design and Patterns
   	 		Section 21.2.  From Iteration 1 to 2
   	 		Section 21.3.  Iteration 2 Requirements
   	 		Section 21.4.  Refinement of Analysis-oriented Artifacts in this Iteration

   	 		  Chapter 22.  GRASP: More Patterns for Assigning Responsibilities
   	 		Introduction
   	 		Section 22.1.  Polymorphism
   	 		Section 22.2.  Pure Fabrication
   	 		Section 22.3.  Indirection
   	 		Section 22.4.  Protected Variations

   	 		  Chapter 23.  Designing Use-Case Realizations with GoF Design Patterns
   	 		Introduction
   	 		Section 23.1.  Adapter (GoF)
   	 		Section 23.2.  "Analysis" Discoveries During Design: Domain Model
   	 		Section 23.3.  Factory (GoF)
   	 		Section 23.4.  Singleton (GoF)
   	 		Section 23.5.  Conclusion of the External Services with Varying Interfaces Problem
   	 		Section 23.6.  Strategy (GoF)
   	 		Section 23.7.  Composite (GoF) and Other Design Principles
   	 		Section 23.8.  Facade (GoF)
   	 		Section 23.9.  Observer/Publish-Subscribe/Delegation Event Model (GoF)
   	 		Section 23.10.  Conclusion
   	 		Section 23.11.  Further Readings


   		Part 5.  Elaboration Iteration 3
   	 		  Chapter 24.  Iteration 3 and Its Requirements
   	 		Section 24.1.  Iteration 3 Requirements
   	 		Section 24.2.  Iteration 3 Emphasis

   	 		  Chapter 25.  Relating Use Cases
   	 		Introduction
   	 		Section 25.1.  The include Relationship
   	 		Section 25.2.  Terminology: Concrete, Abstract, Base, and Addition Use Cases
   	 		Section 25.3.  The extend Relationship
   	 		Section 25.4.  The generalize Relationship
   	 		Section 25.5.  Use Case Diagrams

   	 		  Chapter 26.  Modeling Generalization
   	 		Introduction
   	 		Section 26.1.  New Concepts for the Domain Model
   	 		Section 26.2.  Generalization
   	 		Section 26.3.  Defining Conceptual Superclasses and Subclasses
   	 		Section 26.4.  When to Define a Conceptual Subclass
   	 		Section 26.5.  When to Define a Conceptual Superclass
   	 		Section 26.6.  NextGen POS Conceptual Class Hierarchies
   	 		Section 26.7.  Abstract Conceptual Classes
   	 		Section 26.8.  Modeling Changing States
   	 		Section 26.9.  Class Hierarchies and Inheritance in Software

   	 		  Chapter 27.  Refining the Domain Model
   	 		Introduction
   	 		Section 27.1.  Association Classes
   	 		Section 27.2.  Aggregation and Composition
   	 		Section 27.3.  Time Intervals and Product Prices—Fixing an Iteration 1 "Error"
   	 		Section 27.4.  Association Role Names
   	 		Section 27.5.  Roles as Concepts vs. Roles in Associations
   	 		Section 27.6.  Derived Elements
   	 		Section 27.7.  Qualified Associations
   	 		Section 27.8.  Reflexive Associations
   	 		Section 27.9.  Ordered Elements
   	 		Section 27.10.  Using Packages to Organize the Domain Model

   	 		  Chapter 28.  Adding New SSDs and Contracts
   	 		Section 28.1.  New System Sequence Diagrams
   	 		Section 28.2.  New System Operations
   	 		Section 28.3.  New System Operation Contracts

   	 		  Chapter 29.  Modeling Behavior in Statechart Diagrams
   	 		Introduction
   	 		Section 29.1.  Events, States, and Transitions
   	 		Section 29.2.  Statechart Diagrams
   	 		Section 29.3.  Statechart Diagrams in the UP?
   	 		Section 29.4.  Use Case Statechart Diagrams
   	 		Section 29.5.  Use Case Statechart Diagrams for the POS Application
   	 		Section 29.6.  Classes that Benefit from Statechart Diagrams
   	 		Section 29.7.  Illustrating External and Interval Events
   	 		Section 29.8.  Additional Statechart Diagram Notation
   	 		Section 29.9.  Further Readings

   	 		  Chapter 30.  Designing the Logical Architecture with Patterns
   	 		Introduction
   	 		Section 30.1.  Software Architecture
   	 		Section 30.2.  Architectural Pattern: Layers
   	 		Section 30.3.  The Model-View Separation Principle
   	 		Section 30.4.  Further Readings

   	 		  Chapter 31.  Organizing the Design and Implementation Model Packages
   	 		Introduction
   	 		Section 31.1.  Package Organization Guidelines
   	 		Section 31.2.  More UML Package Notation
   	 		Section 31.3.  Further Readings

   	 		  Chapter 32.  Introduction to Architectural Analysis and the SAD
   	 		Introduction
   	 		Section 32.1.  Architectural Analysis
   	 		Section 32.2.  Types and Views of Architecture
   	 		Section 32.3.  The Science: Identification and Analysis of Architectural Factors
   	 		Section 32.4.  Example: Partial NextGen POS Architectural Factor Table
   	 		Section 32.5.  The Art: Resolution of Architectural Factors
   	 		Section 32.6.  Summary of Themes in Architectural Analysis
   	 		Section 32.7.  Architectural Analysis within the UP
   	 		Section 32.8.  Further Readings

   	 		  Chapter 33.  Designing More Use-Case Realizations with Objects and Patterns
   	 		Introduction
   	 		Section 33.1.  Failover to Local Services; Performance with Local Caching
   	 		Section 33.2.  Handling Failure
   	 		Section 33.3.  Failover to Local Services with a Proxy (GoF)
   	 		Section 33.4.  Designing for Non-Functional or Quality Requirements
   	 		Section 33.5.  Accessing External Physical Devices with Adapters; Buy vs. Build
   	 		Section 33.6.  Abstract Factory (GoF) for Families of Related Objects
   	 		Section 33.7.  Handling Payments with Polymorphism and Do It Myself
   	 		Section 33.8.  Conclusion

   	 		  Chapter 34.  Designing a Persistence Framework with Patterns
   	 		Introduction
   	 		Section 34.1.  The Problem: Persistent Objects
   	 		Section 34.2.  The Solution: A Persistence Service from a Persistence Framework
   	 		Section 34.3.  Frameworks
   	 		Section 34.4.  Requirements for the Persistence Service and Framework
   	 		Section 34.5.  Key Ideas
   	 		Section 34.6.  Pattern: Representing Objects as Tables
   	 		Section 34.7.  UML Data Modeling Profile
   	 		Section 34.8.  Pattern: Object Identifier
   	 		Section 34.9.  Accessing a Persistence Service with a Facade
   	 		Section 34.10.  Mapping Objects: Database Mapper or Database Broker Pattern
   	 		Section 34.11.  Framework Design with the Template Method Pattern
   	 		Section 34.12.  Materialization with the Template Method Pattern
   	 		Section 34.13.  Configuring Mappers with a MapperFactory
   	 		Section 34.14.  Pattern: Cache Management
   	 		Section 34.15.  Consolidating and Hiding SQL Statements in One Class
   	 		Section 34.16.  Transactional States and the State Pattern
   	 		Section 34.17.  Designing a Transaction with the Command Pattern
   	 		Section 34.18.  Lazy Materialization with a Virtual Proxy
   	 		Section 34.19.  How to Represent Relationships in Tables
   	 		Section 34.20.  PersistentObject Superclass and Separation of Concerns
   	 		Section 34.21.  Unresolved Issues


   		Part 6.  Special Topics
   	 		  Chapter 35.  On Drawing and Tools
   	 		Introduction
   	 		Section 35.1.  On Speculative Design and Visual Thinking
   	 		Section 35.2.  Suggestions for UML Drawing Within the Development Process
   	 		Section 35.3.  Tools and Sample Features
   	 		Section 35.4.  Example Two

   	 		  Chapter 36.  Introduction to Iterative Planning and Project Issues
   	 		Introduction
   	 		Section 36.1.  Ranking Requirements
   	 		Section 36.2.  Ranking Project Risks
   	 		Section 36.3.  Adaptive vs. Predictive Planning
   	 		Section 36.4.  Phase and Iteration Plans
   	 		Section 36.5.  Iteration Plan: What to Do in the Next Iteration?
   	 		Section 36.6.  Requirements Tracking Across Iterations
   	 		Section 36.7.  The (In)Validity of Early Estimates
   	 		Section 36.8.  Organizing Project Artifacts
   	 		Section 36.9.  Some Team Iteration Scheduling Issues
   	 		Section 36.10.  You Know You Didn't Understand Planning in the UP When...
   	 		Section 36.11.  Further Readings

   	 		  Chapter 37.  Comments on Iterative Development and the UP
   	 		Section 37.1.  Additional UP Best Practices and Concepts
   	 		Section 37.2.  The Construction and Transition Phases
   	 		Section 37.3.  Other Interesting Practices
   	 		Section 37.4.  Motivations for Timeboxing an Iteration
   	 		Section 37.5.  The Sequential "Waterfall" Lifecycle
   	 		Section 37.6.  Usability Engineering and User Interface Design
   	 		Section 37.7.  The UP Analysis Model
   	 		Section 37.8.  The RUP Product
   	 		Section 37.9.  The Challenge and Myths of Reuse

   	 		  Chapter 38.  More UML Notation
   	 		Section 38.1.  General Notation
   	 		Section 38.2.  Implementation Diagrams
   	 		Section 38.3.  Template (Parameterized, Generic) Class
   	 		Section 38.4.  Activity Diagrams


   		  Bibliography
   		  Glossary
   		  Sample UML Notation
   		Index