Applying UML and Patterns An Introduction to Object-Oriented Analysis and Design

ISBN-10: 0137488807

ISBN-13: 9780137488803

Edition: 1998

Authors: Craig Larman
List price: $69.33
30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy

Description: Appropriate for courses in Object-Oriented Programming. The first book to apply the Unified Modeling Language (UML) to communicating object-oriented analysis and design results. You'll learn the fundamental concepts of object-oriented analysis and design, and then walk step-by-step through the entire process of analysis and design using a single case study that takes full advantage of UML and design patterns.

what's this?
Rush Rewards U
Members Receive:
You have reached 400 XP and carrot coins. That is the daily max!

Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
Periodic Table Online content $4.95 $1.99
Add to cart
Study Briefs
SQL Online content $4.95 $1.99
Add to cart
Study Briefs
MS Excel® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS Word® 2010 Online content $4.95 $1.99

Customers also bought


Book details

List price: $69.33
Copyright year: 1998
Publisher: Prentice Hall PTR
Publication date: 10/30/1997
Binding: Paperback
Pages: 528
Size: 8.27" wide x 10.24" long x 0.98" tall
Weight: 2.574
Language: English

Object-Oriented Analysis and Design
Applying UML, Patterns, and Object-Oriented Analysis and Design
Assigning Responsibilities
What is Analysis and Design?
What is Object-Oriented Analysis and Design?
An Analogy--Organizing the MicroChaos Business
An Example of Object-Oriented Analysis and Design
Object Versus Function-Oriented Analysis and Design
Warning: "Analysis" and "Design" Can Lead to Terminology Wars
The Unified Modeling Language
Introduction to a Development Process
The UML and Development Processes
Macro-level Steps
Interative Development
The Plan and Elaborate Phase
Build Phase--Development Cycles
Choosing When to Create Artifacts
Defining Models and Artifacts
Modeling Systems
Sample Models
Relationship Between Artifacts
Plan and Elaborate Phase
Case Study: Point-of-Sale
The Point-of-Sale System
Architectural Layers and Case Study Emphasis
Our Strategy: Iterative Learning and Development
Understanding Requirements
Overview Statement
System Functions
System Attributes
Other Requirements Phase Artifacts
Use Cases: Describing Processes
Activities and Dependencies
Use Cases
A Common Mistake with Use Cases
Identifying Use Cases
Use Case and Domain Processes
Use Cases, System Functions, and Traceability
Use Case Diagrams
Use Case Formats
Systems and their Boundaries
Primary, Secondary, and Optional Use Cases
Essential versus Real Use Cases
Notational Points
Use Cases Within a Development Process
Process Steps for the Point-of-Sale System
Sample Models
Ranking and Scheduling Use Cases
Scheduling Use Cases to Development Cycles
Ranking the Point-of-Sale Application Use Cases
The "Start Up" Use Case
Scheduling the Point-of-Sale Application Use Cases
Use Case Versions of "Buy Items"
Starting a Development Cycle
Starting a Development Cycle
Analyze Phase (1)
Building a Conceptual Model
Activities and Dependencies
Conceptual Models
Strategies to Identify Concepts
Candidate Concepts for the Point-of-Sale Domain
Conceptual Modeling Guidelines
Resolving Similar Concepts--POST versus Register
Modeling the Unreal World
Specification or Description Concepts
Defining Terms in the UML
Sample Models
Conceptual Model--Adding Associations
The UML Association Notation
Finding Associations--Common Associations List
How Detailed Should Associations Be?
Association Guidelines
Naming Associations
Multiple Associations Between Two Types
Associations and Implementation
Point-of-Sale Domain Associations
Point-of-Sale Conceptual Model
Conceptual Model--Adding Attributes
UML Attribute Notation
Valid Attribute Types
Non-primitive Attribute Types
Modeling Attribute Quantities and Units
Attributes for the Point-of-Sale System
Attributes in the Point-of-Sale Model
Multiplicity From SalesLineItem to Item
Point-of-Sale Conceptual Model
Recording Terms in the Glossary
Activities and Dependencies
Sample Point-of-Sale System Glossary
System Behavior--System Sequence Diagrams
Activities and Dependencies
System Behavior
System Sequence Diagrams
Example of a System Sequence Diagram
System Events and System Operations
How to Make a System Sequence Diagram
System Sequence Diagrams and other Artifacts
System Events and the System Boundary
Naming System Events and Operations
Showing Use Case Text
Sample Models
System Behavior--Contracts
Activities and Dependencies
System Behavior
Example contract--enterItem
Contract Sections
How to Make A Contract
The Spirit of Post-conditions: the Stage and Curtain
Discussion--enterItem Post-conditions
How Complete Should Post-conditions Be?
Describing Design Details and Algorithms--Notes
Advice on Writing Contracts
Contracts for the Buy Items Use Case
Contracts for the StartUp Use Case
Changes to the Conceptual Model
Sample Models
Design Phase (1)
From Analysis to Design
Analysis Phase Conclusion
Design Phase Initiation
Describing Real Use Cases
Activities and Dependencies
Real Use Cases
Example--Buy Items-Version 1
Sample Models
Collaboration Diagrams
Activities and Dependencies
Interaction Diagrams
Example Collaboration Diagram: makePayment
Interaction Diagrams are a Valuable Artifact
This is a Notation-Only Chapter
Read the Following Chapters for Design Guidelines
How to Make Collaboration Diagrams
Basic Collaboration Diagram Notation
Sample Models
Grasp: Patterns for Assigning Responsibilities
Activities and Dependencies
Well-Designed Interaction Diagrams are Valuable
Responsibilities and Methods
Responsibilities and Interaction Diagrams
GRASP: Patterns of General Principles in Assigning Responsibilities
The UML Class Diagram Notation
Low Coupling
High Cohesion
Responsibilities, Role Playing and CRC Cards
Designing a Solution With Objects and Patterns
Interaction Diagrams and Other Artifacts
Point-of-Sale Conceptual Model
Collaboration Diagrams for the POST Application
Collaboration Diagram: enterItem
Collaboration Diagram: endSale
Collaboration Diagram: makePayment
Collaboration Diagram: startUp
Connecting the Presentation Layer to the Domain Layer
Determining Visibility
Visibility Between Objects
Illustrating Visibility in the UML
Design Class Diagrams
Activities and Dependencies
When to Create Design Class Diagrams
Example Design Class Diagram
Design Class Diagrams
How to Make a Design Class Diagram
Conceptual Model versus Design Class Diagrams
Creating the Point-of-Sale Design Class Diagrams
Notation for Member Details
Sample Models
Issues in System Design
Classic Three-Tier Architecture
Multi-Tiered Object-Oriented Architectures
Showing Architecture with UML Packages
Identifying Packages
Layers and Partitions
Visibility Between Package Classes
Service Packages Interface--The Facade Pattern
No Direct Visibility to Windows--The Model-View Separation Pattern
Indirect Communication in a System
Application Coordinators
Storage and Persistence
Sample Models
Construct Phase (1)
Mapping Designs to Code
Programming and the Development Process
Mapping Designs to Code
Creating Class Definitions from Design Class Diagrams
Creating Methods from Collaboration Diagrams
Updating Class Definitions
Container/Collection Classes in Code
Exceptions and Error Handling
Defining the Sale--makeLineItem Method
Order of Implementation
Summary of Mapping Designs to Code
Program Solution in Java
Introduction to the Program Solution
Analyze Phase (2)
Choosing Development Cycle 2 Requirements
Development Cycle Two Requirements
Assumptions and Simplifications
Relating Multiple Use Cases
When to Create Separate Use Cases
Use Case Diagrams with uses Relationships
Use Case Documents with uses Relationships
Extending the Conceptual Model
New Concepts in the Point-of-Sale System
Defining Super and Subtypes
When to Define a Subtype
When to Define a Supertype
Point-of-Sale Type Hierarchies
Abstract Types
Modeling Changing States
Class Hierarchies and Inheritance
Packages: Organizing Elements
UML Package Notation
How to Partition the Conceptual Model
Point-of-Sale Conceptual Model Packages
Polishing the Conceptual Model
Associative Types
Aggregation and Composition
Association Role Names
Roles As Concepts versus Roles in Associations
Derived Elements
Qualified Associations
Recursive or Reflexive Associations
Conceptual Model--Summary
Domain Concepts Package
Core/Misc Package
Authorization Transactions
System Behavior
System Sequence Diagrams
New System Events
Modeling Behavior in State Diagrams
Events, States, and Transitions
State Diagrams
Use Case State Diagrams
System State Diagrams
Use Case State Diagrams for the Point-of-Sale Application
Types That Need State Diagrams
Other State Diagrams for the Point-of-Sale Application
Illustrating External and Interval Events
Additional State Diagram Notation
Design Phase (2)
Grasp: More Patterns for Assigning Responsibilities
GRASP: General Responsibility Assignment Software Patterns
Pure Fabrication
Don't Talk to Strangers
Designing with More Patterns
State (GoF)
Polymorphism (GRASP)
Singleton (GoF)
Remote Proxy and Proxy (GoF)
Facade and Device Proxy (GoF)
Command (GoF)
Special Topics
Other UML Notation
General Notation
Implementation Diagrams
Asynchronous Messages in Collaboration Diagrams
Package Interfaces
Development Process Issues
Why Bother?
Guiding Principles of a Successful Process
Iterative and Incremental Development
Use Case Driven Development
Early Emphasis on Architecture
Phases of Development
Length of Development Cycles
Development Cycle Issues
Scheduling Development of Architectural Layers
Frameworks, Patterns, and Persistence
The Problem: Persistent Objects
The Solution: A Persistence Framework
What is a Framework?
Requirements for the Persistence Framework
PersistentObject Superclass?
Key Ideas
Mapping--Pattern Representing Objects as Tables
Object Identify--Object Identifier Pattern
Brokers--Database Broker Pattern
Framework Design--Template Method Pattern
Materialization--Template Method Pattern
Cached Objects--Cache Management Pattern
Smart References--Virtual Proxy, Bridge Patterns
Virtual Proxies and Database Brokers
How to Represent Relationships in Tables
The Complex Object Instantiation Pattern
Transaction Operations
Searching the Objects in the Persistent Store
Alternate Designs
Unresolved Issues
Recommended Readings
Sample Development Activities and Models
Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.