UML class diagrams basics in LLD - System Design Guide

Problem Statement

When designing software, teams often struggle to communicate the structure of classes and their relationships clearly. Without a common visual language, misunderstandings arise, leading to inconsistent implementations and harder maintenance.

Solution

UML class diagrams provide a simple, standardized way to visualize classes, their attributes, methods, and relationships. This visual map helps everyone understand the system's structure before coding, reducing errors and improving collaboration.

Architecture

┌─────────────┐      ┌─────────────┐
│   Person    │      │   Address   │
├─────────────┤      ├─────────────┤
│ - name      │      │ - street    │
│ - age       │      │ - city      │
├─────────────┤      ├─────────────┤
│ + getName() │      │ + getCity() │
│ + getAge()  │      └─────────────┘
└─────┬───────┘           ▲
      │ 1                 │ 1
      │                   │
      │                   │
      └───────────────────┘
         has an address

This diagram shows two classes, Person and Address, with their attributes and methods. It also shows a one-to-one association where a Person has an Address.

Trade-offs

✓ Pros

→

Provides a clear, visual representation of class structure and relationships.

→

Standardized notation understood by many developers and architects.

→

Helps identify design issues early before coding.

→

Improves team communication and documentation.

✗ Cons

→

Can become complex and hard to read for very large systems.

→

Requires learning UML notation which may be new to some team members.

→

Static diagrams do not show runtime behavior or dynamic interactions.

Use UML class diagrams when designing object-oriented systems with multiple classes and relationships, especially in teams needing clear communication and documentation.

Avoid using UML class diagrams for very small projects with few classes or when rapid prototyping is prioritized over upfront design.

Real World Examples

Amazon

Amazon uses UML class diagrams to design their order processing system, clarifying relationships between orders, customers, and products before implementation.

LinkedIn

LinkedIn applies UML class diagrams to model user profiles and connections, ensuring consistent data structures across services.

Uber

Uber uses UML class diagrams to visualize driver, rider, and trip classes, helping coordinate development across teams.

Code Example

The before code mixes address details inside Person, making it hard to manage. The after code separates Address as its own class, showing a clear one-to-one relationship. This matches the UML class diagram structure and improves clarity and reusability.

LLD

### Before: No clear class structure or relationships
class Person:
    def __init__(self, name, age, street, city):
        self.name = name
        self.age = age
        self.street = street
        self.city = city

### After: Clear classes with attributes and relationships
class Address:
    def __init__(self, street: str, city: str):
        self.street = street
        self.city = city

    def get_city(self) -> str:
        return self.city

class Person:
    def __init__(self, name: str, age: int, address: Address):
        self.name = name
        self.age = age
        self.address = address

    def get_name(self) -> str:
        return self.name

    def get_age(self) -> int:
        return self.age

    def get_address_city(self) -> str:
        return self.address.get_city()

Alternatives

Entity-Relationship Diagrams (ERD)

ERDs focus on database entities and their relationships rather than object-oriented classes and methods.

Use when: Choose ERDs when designing database schemas rather than application class structures.

Object Role Modeling (ORM)

ORM models data semantics and constraints more expressively but is less widely adopted than UML.

Use when: Use ORM when detailed semantic modeling of data is required beyond class structure.

Summary

UML class diagrams visually represent classes and their relationships to improve design clarity.

They help teams communicate and document object-oriented structures before coding.

While powerful, they focus on static structure and can become complex if overused.

Practice

1. What does a UML class diagram primarily represent in system design?

easy

A. The structure of classes and their relationships

B. The sequence of operations in a process

C. The deployment of hardware components

D. The flow of data between systems

Solution

1. Step 1: Understand UML class diagram purpose

   A UML class diagram shows how classes are organized and connected in a system.

2. Step 2: Compare options to definition

   Only The structure of classes and their relationships describes structure of classes and relationships, which matches UML class diagrams.

3. Final Answer:

   The structure of classes and their relationships -> Option A

4. Quick Check:

   UML class diagram = class structure [OK]

Hint: Class diagrams show classes and links, not processes or hardware [OK]

Common Mistakes:

• Confusing class diagrams with sequence diagrams
• Thinking class diagrams show hardware layout
• Mixing data flow diagrams with class diagrams

2. Which of the following is the correct way to show a class attribute in a UML class diagram?

easy

A. * attributeName -> Type

B. - attributeName = Type

C. # attributeName - Type

D. + attributeName : Type

Solution

1. Step 1: Recall UML attribute notation

   Attributes use visibility (+ public, - private, # protected), name, colon, and type.

2. Step 2: Match options to notation

   + attributeName : Type matches correct format: '+ attributeName : Type'. Others use wrong symbols or separators.

3. Final Answer:

   + attributeName : Type -> Option D

4. Quick Check:

   Attribute syntax = + name : Type [OK]

Hint: Attributes use visibility + name : Type format [OK]

Common Mistakes:

• Using '=' instead of ':' to separate name and type
• Confusing visibility symbols
• Using arrows or dashes incorrectly

3. Given this UML class snippet:
+ name : String
- age : int
Which statement is true about the attributes?

medium

A. 'name' is private and 'age' is public

B. 'name' is public and 'age' is private

C. Both 'name' and 'age' are public

D. Both 'name' and 'age' are private

Solution

1. Step 1: Interpret visibility symbols

   '+' means public, '-' means private in UML.

2. Step 2: Apply to attributes

   'name' has '+', so public; 'age' has '-', so private.

3. Final Answer:

   'name' is public and 'age' is private -> Option B

4. Quick Check:

   + = public, - = private [OK]

Hint: Plus means public, minus means private [OK]

Common Mistakes:

• Mixing up '+' and '-' meanings
• Assuming all attributes are public by default
• Ignoring visibility symbols

4. Identify the error in this UML class attribute declaration:
- salary = float

medium

A. Visibility symbol '-' is incorrect

B. Type 'float' should be capitalized

C. The '=' sign should be ':' to separate name and type

D. Attribute name 'salary' is invalid

Solution

1. Step 1: Check UML attribute syntax

   Attributes use visibility, name, colon ':', then type. '=' is not used.

2. Step 2: Identify incorrect symbol

   The '=' sign is wrong; it should be ':' to separate attribute name and type.

3. Final Answer:

   The '=' sign should be ':' to separate name and type -> Option C

4. Quick Check:

   Use ':' not '=' in attributes [OK]

Hint: Use ':' not '=' between name and type [OK]

Common Mistakes:

• Using '=' instead of ':'
• Thinking visibility symbols are wrong
• Assuming type names must be capitalized

5. You want to model a simple library system with classes Book and Author. Each book has one author, and an author can write many books. Which UML relationship best represents this?

hard

A. Aggregation from Author to Book (one-to-many)

B. Composition from Book to Author (one-to-one)

C. Inheritance from Book to Author

D. Association from Book to Author (many-to-many)

Solution

1. Step 1: Understand relationship types

   Aggregation means a whole-part with shared lifecycle; composition means strong ownership; inheritance means 'is-a' relation; association is a general link.

2. Step 2: Apply to library example

   Author writes many books (one-to-many). Books can exist without author object lifecycle tightly bound, so aggregation fits best.

3. Final Answer:

   Aggregation from Author to Book (one-to-many) -> Option A

4. Quick Check:

   One author, many books = aggregation [OK]

Hint: One-to-many ownership without strong lifecycle = aggregation [OK]

Common Mistakes:

• Confusing composition with aggregation
• Using inheritance for unrelated classes
• Choosing many-to-many when one-to-many fits