UML Object Diagrams

Complete guide to UML Object Diagrams: learn how to model object instances, links, and runtime snapshots. Understand how object diagrams complement class diagrams by showing concrete examples.

1. What are Object Diagrams?
2. Object Notation
3. Links
4. When to Use Object Diagrams
5. Object Diagrams vs Class Diagrams
6. Practical Examples
7. Best Practices
8. Conclusion

1. What are Object Diagrams?

Object diagrams show instances of classes at a specific point in time. They represent a snapshot of the system's state, displaying actual objects with their attribute values and the links between them.

While class diagrams show the structure and relationships that are possible, object diagrams show concrete examples of how those classes are instantiated and connected at runtime.

Key characteristics of object diagrams:

Runtime View: Show the system at a specific moment in time
Concrete Instances: Display actual objects, not classes
Attribute Values: Show specific values for object attributes
Links: Show actual connections between objects

2. Object Notation

2.1 Basic Object Representation

An object is represented as a rectangle with two compartments:

Name compartment: Contains object name and class (objectName : ClassName)
Attributes compartment: Shows attribute values (optional)

@startuml object "order1 : Order" as order1 { orderId = "ORD-001" total = 150.00 status = "PENDING" } note right of order1 Object name : Class name Attribute values shown end note @enduml

2.2 Object Naming

Objects can be named in three ways:

Named object: order1 : Order (has instance name)
Anonymous object: : Order (no instance name)
Class name only: Order (when showing a typical instance)

2.3 Attribute Values

Attribute values are shown in the format:

attributeName = value

Examples:

customerId = "CUST-123"
balance = 500.00
isActive = true
items = [item1, item2, item3]

2.4 Showing Attribute Values

You can show:

All attributes: Complete snapshot of object state
Selected attributes: Only relevant attributes for the diagram's purpose
No attributes: Focus on relationships rather than values

3. Links

3.1 What are Links?

Links represent connections between objects at runtime. They are instances of associations from class diagrams. A link connects two objects and shows that they can communicate or are related.

3.2 Link Notation

Links are shown as solid lines connecting objects:

@startuml object "order1 : Order" as order1 object "customer1 : Customer" as customer1 order1 -- customer1 @enduml

3.3 Link Labels

Links can have labels (role names) to clarify the relationship:

@startuml object "order1 : Order" as order1 object "customer1 : Customer" as customer1 order1 -- customer1 : placedBy @enduml

3.4 Multiplicity in Object Diagrams

While class diagrams show potential multiplicities (1, *, 1..*), object diagrams show actual numbers of objects. If a class diagram shows "one to many," the object diagram shows exactly how many objects exist.

3.5 Qualified Links

Qualified links show how objects are accessed through a qualifier:

@startuml object "order1 : Order" as order1 object "item1 : Item" as item1 order1 -- item1 : [itemId] @enduml

4. When to Use Object Diagrams

4.1 Clarifying Complex Class Diagrams

Object diagrams help clarify complex class relationships by showing concrete examples. When a class diagram has many relationships, an object diagram can illustrate how those relationships work in practice.

4.2 Testing and Debugging

Object diagrams are useful for:

Understanding system state at a specific point
Debugging by visualizing object relationships
Testing scenarios with specific object configurations
Verifying that class relationships work as intended

4.3 Documentation

Object diagrams serve as examples that complement class diagrams:

Showing typical system configurations
Illustrating use cases with concrete examples
Documenting system state at key moments
Providing examples for new team members

4.4 Communication

Object diagrams help communicate with:

Developers: Showing concrete examples of how objects interact
Testers: Illustrating test scenarios and system states
Stakeholders: Making abstract concepts more concrete

5. Object Diagrams vs Class Diagrams

Aspect	Class Diagram	Object Diagram
Shows	Classes and their structure	Object instances and their state
Time	Static (design time)	Dynamic (runtime snapshot)
Relationships	Associations (potential)	Links (actual connections)
Attributes	Attribute names and types	Attribute values
Multiplicity	Shows ranges (1, , 1..)	Shows exact numbers
Purpose	Design and structure	Examples and debugging

5.1 Complementary Use

Class and object diagrams work best together:

Class diagrams define the structure and possibilities
Object diagrams show concrete examples of that structure
Together, they provide both the blueprint and examples

6. Practical Examples

6.1 E-Commerce Order System

Consider a class diagram with Order, Customer, and OrderItem classes. An object diagram might show:

@startuml object "order1 : Order" as order1 { orderId = "ORD-001" total = 150.00 status = "PENDING" } object "customer1 : Customer" as customer1 { customerId = "C001" name = "John Doe" email = "john@..." } order1 -- customer1 : placedBy object "order1 : Order" as order1b object "item1 : Item" as item1 { id = "I1" qty = 2 price = 50 } object "item2 : Item" as item2 { id = "I2" qty = 1 price = 50 } order1b -- item1 : contains order1b -- item2 : contains @enduml

6.2 Library Management System

Object diagram showing a book checkout scenario:

@startuml object "member1 : Member" as member1 { memberId = "M001" name = "Alice" } object "loan1 : Loan" as loan1 { loanId = "L001" borrowDate = "..." dueDate = "..." } object "book1 : Book" as book1 { isbn = "123-456" title = "UML Guide" available = false } member1 -- loan1 : borrows loan1 -- book1 : for @enduml

6.3 System State Snapshots

Object diagrams can show system state at different moments:

Initial State: System after startup
After User Action: System after a specific operation
Error State: System when an error occurs
Final State: System after completing a process

7. Best Practices

7.1 Focus on Clarity

Show only relevant objects and links
Include attribute values that are important for understanding
Use clear, descriptive object names
Avoid cluttering the diagram

7.2 Show Meaningful Snapshots

Choose moments that illustrate important concepts
Show typical scenarios, not edge cases
Include enough context to understand the situation
Document what the snapshot represents

7.3 Consistency with Class Diagrams

Ensure objects conform to their classes
Verify links match associations in class diagrams
Check that attribute values match attribute types
Maintain consistency across related diagrams

7.4 Use Sparingly

Don't create object diagrams for every scenario
Use them when they add value (clarification, examples, debugging)
Focus on complex or important scenarios
Keep them simple and focused