Java Fundamentals

Recap: UML Class Diagrams

In Lecture 1, we learned about structural diagrams:

• Class diagrams show the static structure of a system
• They define classes, attributes, methods, and relationships
• Relationships: association, aggregation, composition, inheritance

UML Diagram Categories

Today we focus on the three most common behavioral diagrams (in bold)

Part 1: Use Case Diagrams

A use case diagram shows what a system does from a user's perspective.

• Purpose: Capture functional requirements
• Focus: What the system should do, not how
• Audience: Stakeholders, business analysts, developers

Use Case Diagram Components

Use Case Diagram Example: Online Shopping

flowchart LR
    subgraph System["Online Shop System"]
        UC1(["Browse Products"])
        UC2(["Add to Cart"])
        UC3(["Checkout"])
        UC4(["Make Payment"])
        UC3 -.->|include| UC4
    end

    Customer[/Customer\]
    Customer --- UC1
    Customer --- UC2
    Customer --- UC3
    Customer --- UC4
        

Use Case Relationships

Types of Actors

• Primary Actors: Initiate interactions (e.g., Customer, Admin)
  • Usually shown on the left side of the diagram
• Secondary Actors: React to system requests (e.g., Payment Gateway, Email Service)
  • Usually shown on the right side
• Actor Generalization: One actor inherits capabilities of another
  • Example: "Admin" extends "User" (can do everything a User can, plus more)

Exercise 1: Library Management Use Cases

Create a use case diagram for a Library Management System with these requirements:

• Actors: Member, Librarian, System (for automated tasks)
• Member can: Search books, Borrow book, Return book, View borrowing history
• Librarian can: All member actions + Add book, Remove book, Manage members
• System: Send overdue notifications

Part 2: Activity Diagrams

An activity diagram shows the flow of activities in a process.

• Purpose: Model workflows and business processes
• Focus: Sequential and parallel activities
• Similar to: Flowcharts, but with support for parallelism

Activity Diagram Components

Activity Diagram Example: Order Processing

flowchart TD
    Start((●)) --> ReceiveOrder["Receive Order"]
    ReceiveOrder --> CheckStock{In Stock?}
    CheckStock -->|No| CancelOrder["Cancel Order"]
    CancelOrder --> End1((⊙))
    CheckStock -->|Yes| Fork[/ /]
    Fork --> PackItems["Pack Items"]
    Fork --> ProcessPayment["Process Payment"]
    PackItems --> Join[\ \]
    ProcessPayment --> Join
    Join --> ShipOrder["Ship Order"]
    ShipOrder --> End2((⊙))
        

Activity Diagrams with Swimlanes

Swimlanes partition activities by responsibility (actor, department, system).

flowchart TD
    subgraph Customer
        A((●)) --> B["Place Order"]
        G["Receive Order"] --> H((⊙))
    end
    subgraph System
        C["Verify Stock"]
        F["Send Notification"]
    end
    subgraph Warehouse
        D["Pack Order"]
        E["Ship Order"]
    end

    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
        

Decision and Guard Conditions

Use guard conditions in brackets to control flow:

flowchart TD
    CheckLogin["Check Login"] --> Decision{Valid?}
    Decision -->|"[invalid]"| ShowError["Show Error"]
    Decision -->|"[valid]"| ShowDashboard["Show Dashboard"]
    ShowError --> Merge{" "}
    ShowDashboard --> Merge
    Merge --> LogEvent["Log Event"]
        

Exercise 2: ATM Withdrawal Activity Diagram

Create an activity diagram for an ATM cash withdrawal process:

1. User inserts card
2. System validates card
3. If invalid → show error → eject card → end
4. If valid → ask for PIN
5. If PIN wrong (max 3 attempts) → block card → end
6. If PIN correct → show menu → select withdrawal
7. Enter amount
8. Check balance: if insufficient → show error → back to menu
9. If sufficient → dispense cash AND print receipt (parallel)
10. Eject card → end

Part 3: Sequence Diagrams

A sequence diagram shows how objects interact over time.

• Purpose: Model the sequence of messages between objects
• Focus: Time-ordered interactions
• Use case: Detailing how a specific scenario is executed

Sequence Diagram Components

Sequence Diagram Example: User Login

sequenceDiagram
    actor User
    participant LoginForm
    participant AuthService
    participant Database

    User->>LoginForm: enter credentials
    LoginForm->>AuthService: validate()
    AuthService->>Database: findUser()
    Database-->>AuthService: user data
    AuthService->>AuthService: checkPassword
    AuthService-->>LoginForm: auth result
    LoginForm-->>User: show result
        

Combined Fragments

Fragments add control flow logic to sequence diagrams:

Example: Alt Fragment (If-Else)

sequenceDiagram
    participant Client
    participant Server
    participant Database

    Client->>Server: request()
    Server->>Database: query()

    alt data found
        Database-->>Server: data
        Server-->>Client: success
    else data not found
        Database-->>Server: null
        Server-->>Client: error 404
    end
        

Example: Loop Fragment

sequenceDiagram
    participant ShoppingCart
    participant ProductService
    participant Inventory

    loop for each item in cart
        ShoppingCart->>ProductService: getPrice(item)
        ProductService->>Inventory: checkStock()
        Inventory-->>ProductService: quantity
        ProductService-->>ShoppingCart: price + stock
    end

    ShoppingCart->>ShoppingCart: calculateTotal
        

Object Creation and Destruction

sequenceDiagram
    participant OrderService
    participant Order
    participant EmailService

    OrderService->>Order: create new Order()
    activate Order
    OrderService->>Order: addItem(product)
    OrderService->>Order: confirm()
    Order->>EmailService: sendConfirmation()
    EmailService-->>Order: done
    OrderService->>Order: destroy
    deactivate Order
    destroy Order
        

create: Creates new object | destroy: Object destruction

Sequence Diagram Best Practices

• Name messages clearly: Use verb phrases (e.g., validateUser(), calculateTotal())
• Show return values: Especially for important data
• Keep it focused: One scenario per diagram
• Left to right: Place primary actor on the left
• Minimize crossings: Order lifelines to reduce arrow crossings
• Use fragments: For loops and conditions, not separate diagrams

Exercise 3: Online Purchase Sequence Diagram

Create a sequence diagram for an online purchase with these objects:

• Customer, WebUI, CartService, PaymentGateway, InventoryService, EmailService

Scenario:

1. Customer clicks "Checkout" on WebUI
2. WebUI gets cart total from CartService
3. CartService checks each item's availability with InventoryService (loop)
4. WebUI sends payment to PaymentGateway
5. Use alt fragment: if payment succeeds → reserve items, send confirmation email; if fails → show error

When to Use Which Diagram?

UML Diagramming Tools

• Free:
  • draw.io - Web-based, exports to various formats
  • PlantUML - Text-based, integrates with IDEs
  • Mermaid - Text-based, great for documentation
• Commercial:
  • Enterprise Architect
  • Visual Paradigm
  • Lucidchart

Exercise 4: Complete System Analysis

Design a Hotel Reservation System using all three diagram types:

1. Use Case Diagram:
   • Actors: Guest, Receptionist, System
   • Use cases: Search rooms, Make reservation, Cancel reservation, Check-in, Check-out, Process payment, Send confirmation
2. Activity Diagram:
   • Model the complete reservation process from search to confirmation
   • Include decisions (room available?), parallel activities (payment + email)
3. Sequence Diagram:
   • Detail the "Make reservation" use case
   • Show interactions between Guest, WebUI, RoomService, PaymentService, EmailService

Summary