Home Page Icon
Home Page
Table of Contents for
Use Case Statechart Diagrams for the POS Application
Close
Use Case Statechart Diagrams for the POS Application
by Craig Larman
Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, Second Edition
Copyright
Sample UML Notation
Praise for Applying UML and Patterns
Foreword
Preface
Introduction
Object-Oriented Analysis and Design
Applying UML and Patterns in OOA/D
Assigning Responsibilities
What Is Analysis and Design?
What Is Object-Oriented Analysis and Design?
An Example
The UML
Further Readings
Iterative Development and the Unified Process
Introduction
The Most Important UP Idea: Iterative Development
Additional UP Best Practices and Concepts
The UP Phases and Schedule-Oriented Terms
The UP Disciplines (was Workflows)
Process Customization and the Development Case
The Agile UP
The Sequential “Waterfall” Lifecycle
You Know You Didn't Understand the UP When...
Further Readings
Case Study: The NextGen POS System
Introduction
The NextGen POS System
Architectural Layers and Case Study Emphasis
The Book's Strategy: Iterative Learning and Development
Inception
Inception
Introduction
Inception: An Analogy
Inception May Be Very Brief
What Artifacts May Start in Inception?
You Know You Didn't Understand Inception When...
Understanding Requirements
Introduction
Types of Requirements
Further Readings
Use-Case Model: Writing Requirements in Context
Introduction
Goals and Stories
Background
Use Cases and Adding Value
Use Cases and Functional Requirements
Use Case Types and Formats
Fully Dressed Example: Process Sale
Explaining the Sections
Goals and Scope of a Use Case
Finding Primary Actors, Goals, and Use Cases
Congratulations: Use Cases Have Been Written, and Are Imperfect
Write Use Cases in an Essential UI-Free Style
Actors
Use Case Diagrams
Requirements in Context and Low-Level Feature Lists
Use Cases Are Not Object-Oriented
Use Cases Within the UP
Case Study: Use Cases in the NextGen Inception Phase
Further Readings
UP Artifacts and Process Context
Identifying Other Requirements
Introduction
NextGen POS Examples
NextGen Example: (Partial) Supplementary Specification
Commentary: Supplementary Specification
NextGen Example: (Partial) Vision
Commentary: Vision
NextGen Example: A (Partial) Glossary
Commentary: Glossary (Data Dictionary)
Reliable Specifications: An Oxymoron?
Online Artifacts at the Project Website
Not Much UML During Inception?
Other Requirement Artifacts Within the UP
Further Readings
UP Artifacts and Process Context
From Inception to Elaboration
Introduction
Checkpoint: What Happened in Inception?
On to Elaboration
Planning the Next Iteration
Iteration 1 Requirements and Emphasis: Fundamental OOA/D Skills
What Artifacts May Start in Elaboration?
You Know You Didn't Understand Elaboration When...
Elaboration Iteration 1
Use-Case Model: Drawing System Sequence Diagrams
Moving on to Iteration 1
Introduction
System Behavior
System Sequence Diagrams
Example of an SSD
Inter-System SSDs
SSDs and Use Cases
System Events and the System Boundary
Naming System Events and Operations
Showing Use Case Text
SSDs and the Glossary
SSDs Within the UP
Further Readings
UP Artifacts
Domain Model: Visualizing Concepts
Introduction
Domain Models
Conceptual Class Identification
Candidate Conceptual Classes for the Sales Domain
Domain Modeling Guidelines
Resolving Similar Conceptual Classes—Register vs. “POST”
Modeling the Unreal World
Specification or Description Conceptual Classes
UML Notation, Models, and Methods: Multiple Perspectives
Lowering the Representational Gap
Example: The NextGen POS Domain Model
Domain Models Within the UP
Further Readings
UP Artifacts
Domain Model: Adding Associations
Introduction
Associations
The UML Association Notation
Finding Associations—Common Associations List
Association Guidelines
Roles
How Detailed Should Associations Be?
Naming Associations
Multiple Associations Between Two Types
Associations and Implementation
NextGen POS Domain Model Associations
NextGen POS Domain Model
Domain Model: Adding Attributes
Introduction
Attributes
UML Attribute Notation
Valid Attribute Types
Non-primitive Data Type Classes
Design Creep: No Attributes as Foreign Keys
Modeling Attribute Quantities and Units
Attributes in the NextGen Domain Model
Multiplicity From SalesLineItem to Item
Domain Model Conclusion
Use-Case Model: Adding Detail with Operation Contracts
Introduction
Contracts
Example Contract: enterItem
Contract Sections
Postconditions
Discussion—enterItem Postconditions
Writing Contracts Leads to Domain Model Updates
When Are Contracts Useful? Contracts vs. Use Cases?
Guidelines: Contracts
NextGen POS Example: Contracts
Changes to the Domain Model
Contracts, Operations, and the UML
Operation Contracts Within the UP
Further Readings
From Requirements to Design in this Iteration
Introduction
Iteratively Do the Right Thing, Do the Thing Right
Didn't That Take Weeks To Do? No, Not Exactly.
On to Object Design
Interaction Diagram Notation
Introduction
Sequence and Collaboration Diagrams
Example Collaboration Diagram: makePayment
Example Sequence Diagram: makePayment
Interaction Diagrams Are Valuable
Common Interaction Diagram Notation
Basic Collaboration Diagram Notation
Basic Sequence Diagram Notation
GRASP: Designing Objects with Responsibilities
Introduction
Responsibilities and Methods
Responsibilities and Interaction Diagrams
Patterns
GRASP: Patterns of General Principles in Assigning Responsibilities
The UML Class Diagram Notation
Information Expert (or Expert)
Creator
Low Coupling
High Cohesion
Controller
Object Design and CRC Cards
Further Readings
Design Model: Use-Case Realizations with GRASP Patterns
Introduction
Use-Case Realizations
Artifact Comments
Use-Case Realizations for the NextGen Iteration
Object Design: makeNewSale
Object Design: enterItem
Object Design: endSale
Object Design: makePayment
Object Design: startUp
Connecting the UI Layer to the Domain Layer
Use-Case Realizations Within the UP
Summary
Design Model: Determining Visibility
Introduction
Visibility Between Objects
Visibility
Illustrating Visibility in the UML
Design Model: Creating Design Class Diagrams
Introduction
When to Create DCDs
Example DCD
DCD and UP Terminology
Domain Model vs. Design Model Classes
Creating a NextGen POS DCD
Notation for Member Details
DCDs, Drawing, and CASE Tools
DCDs Within the UP
UP Artifacts
Implementation Model: Mapping Designs to Code
Introduction
Programming and the Development Process
Mapping Designs to Code
Creating Class Definitions from DCDs
Creating Methods from Interaction Diagrams
Container/Collection Classes in Code
Exceptions and Error Handling
Defining the Sale--makeLineItem Method
Order of Implementation
Test-First Programming
Summary of Mapping Designs to Code
Introduction to the Program Solution
Elaboration Iteration 2
Iteration 2 and its Requirements
Iteration 2 Emphasis: Object Design and Patterns
From Iteration 1 to 2
Iteration 2 Requirements
Refinement of Analysis-oriented Artifacts in this Iteration
GRASP: More Patterns for Assigning Responsibilities
Introduction
Polymorphism
Pure Fabrication
Indirection
Protected Variations
Designing Use-Case Realizations with GoF Design Patterns
Introduction
Adapter (GoF)
“Analysis” Discoveries During Design: Domain Model
Factory (GoF)
Singleton (GoF)
Conclusion of the External Services with Varying Interfaces Problem
Strategy (GoF)
Composite (GoF) and Other Design Principles
Facade (GoF)
Observer/Publish-Subscribe/Delegation Event Model (GoF)
Conclusion
Further Readings
Elaboration Iteration 3
Iteration 3 and Its Requirements
Iteration 3 Requirements
Iteration 3 Emphasis
Relating Use Cases
Introduction
The include Relationship
Terminology: Concrete, Abstract, Base, and Addition Use Cases
The extend Relationship
The generalize Relationship
Use Case Diagrams
Modeling Generalization
Introduction
New Concepts for the Domain Model
Generalization
Defining Conceptual Superclasses and Subclasses
When to Define a Conceptual Subclass
When to Define a Conceptual Superclass
NextGen POS Conceptual Class Hierarchies
Abstract Conceptual Classes
Modeling Changing States
Class Hierarchies and Inheritance in Software
Refining the Domain Model
Introduction
Association Classes
Aggregation and Composition
Time Intervals and Product Prices—Fixing an Iteration 1 “Error”
Association Role Names
Roles as Concepts vs. Roles in Associations
Derived Elements
Qualified Associations
Reflexive Associations
Ordered Elements
Using Packages to Organize the Domain Model
Adding New SSDs and Contracts
New System Sequence Diagrams
New System Operations
New System Operation Contracts
Modeling Behavior in Statechart Diagrams
Introduction
Events, States, and Transitions
Statechart Diagrams
Statechart Diagrams in the UP?
Use Case Statechart Diagrams
Use Case Statechart Diagrams for the POS Application
Classes that Benefit from Statechart Diagrams
Illustrating External and Interval Events
Additional Statechart Diagram Notation
Further Readings
Designing the Logical Architecture with Patterns
Introduction
Software Architecture
Architectural Pattern: Layers
The Model-View Separation Principle
Further Readings
Organizing the Design and Implementation Model Packages
Introduction
Package Organization Guidelines
More UML Package Notation
Further Readings
Introduction to Architectural Analysis and the SAD
Introduction
Architectural Analysis
Types and Views of Architecture
The Science: Identification and Analysis of Architectural Factors
Example: Partial NextGen POS Architectural Factor Table
The Art: Resolution of Architectural Factors
Summary of Themes in Architectural Analysis
Architectural Analysis within the UP
Further Readings
Designing More Use-Case Realizations with Objects and Patterns
Introduction
Failover to Local Services; Performance with Local Caching
Handling Failure
Failover to Local Services with a Proxy (GoF)
Designing for Non-Functional or Quality Requirements
Accessing External Physical Devices with Adapters; Buy vs. Build
Abstract Factory (GoF) for Families of Related Objects
Handling Payments with Polymorphism and Do It Myself
Conclusion
Designing a Persistence Framework with Patterns
Introduction
The Problem: Persistent Objects
The Solution: A Persistence Service from a Persistence Framework
Frameworks
Requirements for the Persistence Service and Framework
Key Ideas
Pattern: Representing Objects as Tables
UML Data Modeling Profile
Pattern: Object Identifier
Accessing a Persistence Service with a Facade
Mapping Objects: Database Mapper or Database Broker Pattern
Framework Design with the Template Method Pattern
Materialization with the Template Method Pattern
Configuring Mappers with a MapperFactory
Pattern: Cache Management
Consolidating and Hiding SQL Statements in One Class
Transactional States and the State Pattern
Designing a Transaction with the Command Pattern
Lazy Materialization with a Virtual Proxy
How to Represent Relationships in Tables
PersistentObject Superclass and Separation of Concerns
Unresolved Issues
Special Topics
On Drawing and Tools
Introduction
On Speculative Design and Visual Thinking
Suggestions for UML Drawing Within the Development Process
Tools and Sample Features
Example Two
Introduction to Iterative Planning and Project Issues
Introduction
Ranking Requirements
Ranking Project Risks
Adaptive vs. Predictive Planning
Phase and Iteration Plans
Iteration Plan: What to Do in the Next Iteration?
Requirements Tracking Across Iterations
The (In)Validity of Early Estimates
Organizing Project Artifacts
Some Team Iteration Scheduling Issues
You Know You Didn't Understand Planning in the UP When...
Further Readings
Comments on Iterative Development and the UP
Additional UP Best Practices and Concepts
The Construction and Transition Phases
Other Interesting Practices
Motivations for Timeboxing an Iteration
The Sequential “Waterfall” Lifecycle
Usability Engineering and User Interface Design
The UP Analysis Model
The RUP Product
The Challenge and Myths of Reuse
More UML Notation
General Notation
Implementation Diagrams
Template (Parameterized, Generic) Class
Activity Diagrams
Bibliography
Glossary
Sample UML Notation
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Use Case Statechart Diagrams
Next
Next Chapter
Classes that Benefit from Statechart Diagrams
29.5. Use Case Statechart Diagrams for the POS Application
Process Sale
Figure 29.3. A sample statechart.
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset