List of Figures

---

Chapter 1: What’s UML About, Alfie?

Figure 1-1: A class diagram of UML diagrams.

Chapter 2: Following Best Practices

Figure 2-1: Picture representation of an air-filter unit.

Figure 2-2: Electric circuit representation of an air-filter unit.

Figure 2-3: This stove-top air-filter unit has a light so you find the oregano.

Figure 2-4: Air-filter unit with ultraviolet light. (Do dust motes glow in the dark?)

Chapter 3: Objects and Classes

Figure 3-1: UML's class box.

Figure 3-2: A class box with a name.

Figure 3-3: Sample UML objects.

Figure 3-4: An object pointing to (instantiating)its class.

Figure 3-5: A class's compartments.

Figure 3-6: A class with many features.

Chapter 4: Relating Objects That Work Together

Figure 4-1: Two linked objects.

Figure 4-2: Two associated classes.

Figure 4-3: Use of arrowheads for reading association names.

Figure 4-4: Association with multiplicity

Figure 4-5: Choosing multiplicity

Figure 4-6: Multiplicity depends on the application.

Figure 4-7: Multiplicity example with cells and planes.

Figure 4-8: Class diagram with roles.

Figure 4-9: The Plane class with role-name attributes.

Figure 4-10: Instance diagram

Figure 4-11: A reflexive association.

Figure 4-12: Association with constraint notation.

Figure 4-13: The Rents association class.

Figure 4-14: Qualifying an association.

Figure 4-15: Qualifiers can reduce multiplicity.

Figure 4-16: Using the navigation-arrow symbol.

Figure 4-17: Class Diagram of clients and crash dummies.

Chapter 5: Including the Parts with the Whole

Figure 5-1: Example of composition, a strong form of aggregation.

Figure 5-2: A weak form of aggregation-some parts survive if the whole goes away.

Figure 5-3: Composite parts shown inside a class.

Figure 5-4: Showing composite parts as attributes inside a class.

Chapter 6: Reusing Superclasses: Generalization and Inheritance

Figure 6-1: Simple inheritance hierarchy.

Figure 6-2: An instance showing all inherited attributes.

Figure 6-3: Print-media inheritance hierarchy.

Figure 6-4: Inheritance showing generalization set.

Figure 6-5: Complex hierarchy with generalization sets.

Figure 6-6: Using generalization sets to help with class placemen.

Figure 6-7: Inherited features of an association.

Figure 6-8: Examples of overridden attributes.

Figure 6-9: An abstract class, used to enforce interface inheritance.

Figure 6-10: Inheritance from classes.

Chapter 7: Organizing UML Class Diagrams and Packages

Figure 7-1: Object diagram example.

Figure 7-2: A top-level diagram.

Figure 7-3: A second-level diagram.

Figure 7-4: Separate aggregation diagram.

Figure 7-5: Separate inheritance diagram.

Figure 7-6: A diagram with mixed time periods.

Figure 7-7: Multiple time periods modeled correctly.

Figure 7-8: Internal context diagram.

Figure 7-9: Application class diagram.

Figure 7-10: Package diagram.

Chapter 8: Introducing Use-Case Diagrams

Figure 8-1: Using roles to find actors.

Figure 8-2: Exposing actors on diagrams.

Figure 8-3: Generalizing actors.

Figure 8-4: This use-case diagram illustrates use cases and their associated actors.

Figure 8-5: A use-case diagram with multiplicity.

Figure 8-6: Use-case diagram levels.

Figure 8-7: System context diagram.

Figure 8-8: Gathering use cases into packages.

Chapter 9: Defining the Inside of a Use Case

Figure 9-1: A use-case diagram for the use case Make Room Reservation.

Figure 9-2: Scenarios of a use case.

Chapter 10: Relating Use Cases to Each Other

Figure 10-1: Potential commonality in use cases.

Figure 10-2: An included use case.

Figure 10-3: Generalizing actors.

Figure 10-4: Generalizing use cases by mechanism.

Figure 10-5: Generalizing use cases by agent.

Figure 10-6: Showing a new release.

Figure 10-7: An extension and extension points.

Figure 10-8: Mandatory use case with optional goal.

Chapter 11: Introducing Functional Modeling

Figure 11-1: Use class of a system.

Figure 11-2: System decomposition showing lower-level use-case subjects.

Figure 11-3: Use cases as system operations.

Figure 11-4: Pre- and post- conditions usiing OCL.

Chapter 12: Capturing Scenarios with Sequence Diagrams

Figure 12-1: A basic sequence diagram.

Figure 12-2: A sequence diagram for the Make Room Reservation use case.

Figure 12-3: Guarantee Reservation and creating an object within the Guarantee Reservation system.

Figure 12-4: Destroying an object in the cancel Reservation system.

Figure 12-5: Centralized pattern architecture.

Figure 12-6: Some possible message adornments.

Figure 12-7: An interaction called Validate Credit Card.

Figure 12-8: Incorporating a reference.

Figure 12-9: Adding arguments to an interaction.

Figure 12-10: Passing and returning arguments from an interaction.

Figure 12-11: An optional interaction.

Figure 12-12: Looping and alternatives.

Chapter 13: Specifying Workflows with Activity Diagrams

Figure 13-1: The Person class with a high-level operation: planTrip.

Figure 13-2: Activity diagram for planning a trip.

Figure 13-3: A use-case diagram for Make Room Reservation.

Figure 13-4: Interaction Overview diagram for making a room reservation.

Figure 13-5: Activity diagram showing a business process.

Figure 13-6: Showing who's responsible with names placed inside an activity.

Chapter 14: Capturing How Objects Collaborate

Figure 14-1: Initial class diagram for the GenerateBill use case.

Figure 14-2: Promoting an association class to an inline class

Figure 14-3: A class diagram incorporating initial design for GenerateBill.

Figure 14-4: The participants of the GenerateBill collaboration.

Figure 14-5: Initial communication

Figure 14-6: A communication diagram with outline numbering.

Figure 14-7: A communication diagram with looping.

Figure 14-8: A communication diagram showing concurrency.

Figure 14-9: Class model arising from communication diagram and design.

Chapter 15: Capturing the Patterns of Behavior

Figure 15-1: Collaboration showing the Builder design pattern.

Figure 15-2: Alternative form for showing a colaboration occurence.

Figure 15-3: Sequence diagram for the Builder design pattern.

Figure 15-4: The ownership collaboration.

Figure 15-5: The reservation collaboration.

Figure 15-6: A hotel reservation collaboration occurrence.

Chapter 16: Defining the Object’s Lives with States

Figure 16-1: Simple state diagram.

Figure 16-2: Object with three types of states.

Figure 16-3: Sequence diagram for reviewing an account.

Figure 16-4: A state diagram for the Account Reviewer clas.

Chapter 17: Interrupting the States by Hosting Events

Figure 17-1: A state diagram for a credit card.

Figure 17-2: Class diagram showing events as operations of the CreditCard class.

Figure 17-3: The first half of the air-filter-event generalization.

Figure 17-4: The second half of the air-filter-event generalization.

Figure 17-5: Parameterizing some air-filter events.

Figure 17-6: Events inside states.

Figure 17-7: Other special events outside states.

Figure 17-8: Flow of control in a state diagram.

Figure 17-9: An example of UML's transition-oriented notation.

Chapter 18: Avoiding States of Confusion

Figure 18-1: Simple archiving state.

Figure 18-2: States within states.

Figure 18-3: The Generate Statement submachine.

Figure 18-4: Including a submachine.

Figure 18-5: Inheriting events.

Figure 18-6: Using the history pseudo-state.

Figure 18-7: Air-filter machine aggregation.

Figure 18-8: Composite states for the air-filter machine.

Figure 18-9: Concurrent states.

Figure 18-10: Using fork and join pseudostates to manage complex control paths.

Figure 18-11: Class diagram with DBaccess interface.

Figure 18-12: DBaccessor protocol state machine.

Chapter 19: Deploying the System’s Components

Figure 19-1: A subsystem and its components.

Figure 19-2: A package diagram showing internal subsystems.

Figure 19-3: Packages diagram using membership notation.

Figure 19-4: Subsystems with major operations as possible responsibilities.

Figure 19-5: Basic component with interfaces.

Figure 19-6: A component as a black box.

Figure 19-7: A component with explicit interface specifications.

Figure 19-8: Component diagram showing internal classes.

Figure 19-9: A simple deployment diagram for a reservation system.

Figure 19-10: Deployment diagram with nodes and artifacts.

Chapter 20: Breaking the System into Packages/Subsystems

Figure 20-1: Analysis packages for actors, use cases, and datatypes.

Figure 20-2: Analysis-time packages for problem domain.

Figure 20-3: Example of design time subsystems.

Figure 20-4: Diagram showing dependencies among subsystems.

Figure 20-5: Importing subsystems into other subsystems.

Figure 20-6: Merging subsystem from another subsystem

Figure 20-7: Illustration of merged subsystem's internal classes.

Figure 20-8: Three-tier architectural pattern.

Figure 20-9: Collaboration occurrence of a three-tier architectural pattern.

Chapter 21: Ten Common Modeling Mistakes

Figure 21-1: Example of a split-classes mistake.

Figure 21-2: Example of classes made whole.

Figure 21-3: Example of sequence diagram with too much detail.

Figure 21-4: Class diagram with incorrect multiplicities.

---