📌 Critical Arrow Distinctions - Master These!
FILLED ARROWHEAD (Solid Triangle ▶)
- ✓ Synchronous messages (waits for response)
- ✓ Control flow (activity diagrams)
- ✓ State transitions
OPEN ARROWHEAD (V-Shape >)
- ✓ Asynchronous messages (no wait)
- ✓ Return messages (dashed line)
- ✓ Include/Extend (dashed line)
HOLLOW TRIANGLE (Inheritance △)
- ✓ Generalization/Inheritance ONLY
- ✓ Always points to parent/superclass
- ✓ Used in Use Case & Class diagrams
NO ARROWHEAD (Association —)
- ✓ Association (actor to use case)
- ✓ Bidirectional relationship
- ✓ No specific direction implied
1️⃣ Use Case Diagrams
Oval / Ellipse
Represents a use case - a specific function or action that the system provides to actors.
📝 Example: "Login", "Process Payment", "Generate Report"
Stick Figure
Represents an actor - an external entity (person, system, or organization) that interacts with the system.
📝 Example: "Customer", "Administrator", "Payment Gateway"
Rectangle / Box
Represents the system boundary - defines the scope of the system and what's inside vs outside.
📝 Contains all use cases of the system
Solid Line (Association)
Shows communication/participation between actor and use case.
⚠️ SOLID LINE - No arrowhead
📝 Meaning: Actor can initiate or participate in this use case
«include» Relationship
Base use case always includes the included use case. Mandatory inclusion.
⚠️ DASHED LINE + OPEN ARROWHEAD
📝 Example: "Login" includes "Validate Credentials"
«extend» Relationship
Optional extension - extending use case may add behavior to base use case under certain conditions.
⚠️ DASHED LINE + OPEN ARROWHEAD (points TO base)
📝 Example: "Process Order" extends to "Apply Discount Code"
Generalization (Inheritance)
Inheritance relationship between actors or use cases. Child inherits properties of parent.
⚠️ SOLID LINE + HOLLOW TRIANGLE (points to parent)
📝 Example: "Admin" and "Guest" are specialized types of "User"
Aggregation (Hollow Diamond)
Weak "has-a" relationship - whole contains parts, but parts can exist independently when whole is destroyed.
⚠️ SOLID LINE + HOLLOW DIAMOND (points to whole)
📝 Example: University has Students (students can exist without university)
Composition (Filled Diamond)
Strong "has-a" relationship - whole contains parts, parts CANNOT exist independently when whole is destroyed.
⚠️ SOLID LINE + FILLED DIAMOND (points to whole)
📝 Example: House has Rooms (rooms cannot exist without the house)
2️⃣ Activity Diagrams
Filled Circle (●)
Represents the initial state / start node - where the activity begins.
📝 Only ONE per activity diagram
Bull's Eye (◎)
Represents the final state / end node - where the activity terminates.
📝 Can have multiple end nodes
Rounded Rectangle
Represents an activity / action state - a task or operation being performed.
📝 Example: "Process Payment", "Validate Input", "Send Email"
Filled Diamond (◆) - Decision
Decision node / branch - conditional flow with multiple outgoing paths based on conditions.
⚠️ FILLED DIAMOND (solid color inside)
📝 Guards shown in brackets: [condition], [else]
Empty Diamond (◇) - Merge
Merge node - where multiple paths converge back into a single flow.
⚠️ EMPTY DIAMOND (hollow, no fill)
📝 Used after decision/branch to rejoin paths
Thick Bar - Fork
Fork node - splits flow into multiple parallel/concurrent activities that execute simultaneously.
⚠️ ONE input, MULTIPLE outputs
📝 All parallel activities start at the same time
Thick Bar - Join
Join node / synchronization - waits for ALL parallel activities to complete before continuing.
⚠️ MULTIPLE inputs, ONE output
📝 Must wait for all tasks to finish (synchronization point)
Arrow (Control Flow)
Control flow / transition - shows the sequence and direction of activities.
⚠️ SOLID LINE + FILLED ARROWHEAD
📝 Indicates order of execution
Swimlane / Partition
Vertical or horizontal partition - organizes activities by who performs them (roles/departments).
📝 Shows responsibility: Customer lane, System lane, Admin lane
3️⃣ Sequence Diagrams
Rectangle with Name
Represents an object/participant in the interaction. Name format: :ClassName or objectName:ClassName
📝 Example: :PaymentProcessor, user:User
Stick Figure (Actor)
Represents an external actor - typically a human user interacting with the system.
📝 Example: Customer, Administrator
Vertical Dashed Line
Lifeline - represents the object's existence over time in the sequence.
⚠️ VERTICAL DASHED LINE
📝 Extends from object box downward through the interaction
Activation Box
Thin vertical rectangle on lifeline - shows when the object is actively executing or processing.
📝 Duration of method execution or active state
Solid Arrow (Synchronous)
Synchronous message - sender waits for receiver to complete before continuing.
⚠️ SOLID LINE + FILLED ARROWHEAD
📝 Blocking call - waits for response
Open Arrow (Asynchronous)
Asynchronous message - sender continues immediately without waiting for receiver.
⚠️ SOLID LINE + OPEN ARROWHEAD
📝 Non-blocking call - fire and forget
Dashed Arrow (Return)
Return message - response or result sent back to caller.
⚠️ DASHED LINE + OPEN ARROWHEAD
📝 Optional - often implied in synchronous calls
Interaction Frame (alt)
Alternative flows - like if-else statement. Only one branch executes.
📝 Common operators: alt (alternative), opt (optional), loop (repetition), ref (reference)
Reference Frame (ref)
Reference to another diagram - indicates interaction continues in a separate sequence diagram.
📝 Used to simplify complex interactions by breaking them into smaller diagrams
Loop Frame (loop)
Repetition - interaction repeats based on condition or count.
📝 Example: [for each item], [while condition], [1..10]
4️⃣ State Machine Diagrams
Filled Circle (●)
Represents the initial state - where the object begins its lifecycle.
📝 Only ONE per state machine
Bull's Eye (◎)
Represents the final state - where the object's lifecycle ends.
📝 Can have multiple final states
Rounded Rectangle (State)
Represents a state - a condition or situation in the object's lifecycle.
📝 Example: "Idle", "Processing", "Completed", "Error"
Arrow (Transition)
Transition - change from one state to another triggered by an event.
⚠️ SOLID LINE + FILLED ARROWHEAD
📝 Labeled with: event [guard] / action
Transition Label Format
event [guard] / action - Complete transition specification.
📝 event = trigger, [guard] = condition, action = what happens
Composite State
State with internal activities - shows actions performed during the state.
📝 entry/ = on entering, do/ = while in state, exit/ = on leaving
Entry Action (entry /)
Action performed when entering the state - executed once upon entry.
📝 Example: Initialize variables, start timers, log entry
Do Activity (do /)
Ongoing activity while in the state - continues until state exit.
📝 Example: Continuous monitoring, animation, polling
Exit Action (exit /)
Action performed when leaving the state - executed once upon exit.
📝 Example: Clean up resources, save state, log exit
💡 Quick Memorization Tips
- Circles: Start (●) and End (◎) points in activity and state diagrams
- Rectangles: Things that do work or hold state (activities, states, objects)
- Filled Diamond (◆): Decision points (branching) in activity diagrams
- Empty Diamond (◇): Merge points OR Aggregation (weak "has-a")
- Thick Bars: Parallel processing (fork to split, join to synchronize)
- Filled Arrow (▶): Strong relationship (synchronous call, transition, control flow)
- Open Arrow (>): Weak/dependency relationship (async, include, extend, return)
- Hollow Triangle (△): Always means inheritance/generalization (points to parent)
- Stick Figures: Always external actors (people or systems)
- Remember: Filled = Strong/Decision, Empty = Weak/Merge, Dashed = Dependency
🎯 Complete Arrow Reference - All Types
| Visual | Arrow Type | Line Style | Head Type | Used In | Meaning |
|---|---|---|---|---|---|
| Control Flow | Solid | Filled Triangle ▶ | Activity, State | Sequence/transition | |
| Synchronous Call | Solid | Filled Triangle ▶ | Sequence | Waits for response | |
| Asynchronous Call | Solid | Open (V-shape) | Sequence | No wait, continues | |
| Return Message | Dashed | Open (V-shape) | Sequence | Response/result | |
| «include» | Dashed | Open (V-shape) | Use Case | Always includes | |
| «extend» | Dashed | Open (V-shape) | Use Case | Optional extension | |
| Generalization | Solid | Hollow Triangle △ | Use Case, State | Inheritance | |
| Association | Solid | None | Use Case | Communication | |
| Lifeline | Dashed (vertical) | None | Sequence | Object existence | |
| Aggregation | Solid | Hollow Diamond ◇ | Class | Weak "has-a" | |
| Composition | Solid | Filled Diamond ◆ | Class | Strong "has-a" |