Hotel, Room, Booking classes in LLD - System Design Guide

Problem Statement

When designing a hotel booking system, mixing responsibilities of hotels, rooms, and bookings in a single class leads to code that is hard to maintain and extend. This causes bugs when adding features like checking room availability or managing multiple bookings per room.

Solution

Separate the system into three classes: Hotel, Room, and Booking. Hotel manages rooms, Room represents individual rooms with their details, and Booking handles reservation data. This clear division allows each class to focus on its own responsibility, making the system easier to understand and modify.

Architecture

┌─────────┐       1..*       ┌────────┐       0..*       ┌─────────┐
│  Hotel  │──────────────────▶│  Room  │──────────────────▶│ Booking │
└─────────┘                   └────────┘                   └─────────┘

This diagram shows that one Hotel has many Rooms, and each Room can have multiple Bookings.

Trade-offs

✓ Pros

→

Clear separation of concerns improves code readability and maintainability.

→

Easier to add new features like room availability checks or booking cancellations.

→

Classes can be tested independently, improving reliability.

✗ Cons

→

Requires more initial design effort to define clear interfaces between classes.

→

May introduce complexity in managing relationships and data consistency.

→

Overhead of creating and managing multiple objects instead of a single class.

Use when building any hotel booking system that needs to handle multiple rooms and bookings with clear responsibilities and future feature expansion.

Avoid if the system is a simple one-off script with only a few bookings and no plans for extension or maintenance.

Real World Examples

Airbnb

Separates listings (similar to hotels), individual rooms, and booking transactions to manage complex availability and pricing rules.

Booking.com

Uses distinct entities for hotels, rooms, and bookings to handle millions of reservations and dynamic room availability.

Code Example

The before code mixes room and booking logic in one class, making it hard to extend. The after code separates concerns: Hotel manages rooms, Room manages bookings and availability, and Booking represents a reservation. This makes the system clearer and easier to maintain.

LLD

### Before: All logic in one class (bad design)
class HotelSystem:
    def __init__(self):
        self.rooms = {}
        self.bookings = []

    def add_room(self, room_number, room_type):
        self.rooms[room_number] = {'type': room_type, 'booked_dates': []}

    def book_room(self, room_number, date):
        if date not in self.rooms[room_number]['booked_dates']:
            self.rooms[room_number]['booked_dates'].append(date)
            self.bookings.append({'room': room_number, 'date': date})
            return True
        return False


### After: Separate classes with clear responsibilities
class Booking:
    def __init__(self, room, date):
        self.room = room
        self.date = date

class Room:
    def __init__(self, number, room_type):
        self.number = number
        self.room_type = room_type
        self.bookings = []

    def is_available(self, date):
        return all(booking.date != date for booking in self.bookings)

    def book(self, date):
        if self.is_available(date):
            booking = Booking(self, date)
            self.bookings.append(booking)
            return booking
        return None

class Hotel:
    def __init__(self):
        self.rooms = {}

    def add_room(self, number, room_type):
        self.rooms[number] = Room(number, room_type)

    def book_room(self, number, date):
        room = self.rooms.get(number)
        if room:
            return room.book(date)
        return None

Alternatives

Monolithic Class

Combines hotel, room, and booking logic into one class without separation.

Use when: Only for very simple prototypes or scripts with minimal functionality and no future scaling.

Database-Driven Design

Focuses on database tables and relations first, then generates classes from schema.

Use when: When the system is heavily data-centric and database design drives the application structure.

Summary

Separate Hotel, Room, and Booking into distinct classes to keep responsibilities clear.

This separation improves maintainability and allows easier feature additions like availability checks.

Avoid mixing multiple concerns in one class to prevent complex, hard-to-maintain code.

Practice

1. Which class is primarily responsible for storing information about individual rooms in a hotel system?

easy

A. Room

B. Hotel

C. Booking

D. Guest

Solution

1. Step 1: Understand the role of each class

   The Hotel class manages the overall hotel, Booking handles reservations, and Room stores details about each room.

2. Step 2: Identify which class holds room details

   Since Room is designed to represent individual rooms, it stores room number, type, and availability.

3. Final Answer:

   Room -> Option A

4. Quick Check:

   Room class = stores room info [OK]

Hint: Room class holds room details, not Hotel or Booking [OK]

Common Mistakes:

• Confusing Hotel with Room class
• Thinking Booking stores room details
• Assuming Guest class stores room info

2. Which of the following is the correct way to represent a Booking class constructor in Python that takes room, guest, and date as parameters?

easy

A. def __init__(self, room, guest, date):

B. def Booking(room, guest, date):

C. def __booking__(self, room, guest, date):

D. def init(self, room, guest, date):

Solution

1. Step 1: Recall Python constructor syntax

   Python constructors use the special method __init__ with self as the first parameter.

2. Step 2: Match the correct method signature

   def __init__(self, room, guest, date): correctly uses def __init__(self, room, guest, date): which is the standard constructor format.

3. Final Answer:

   def __init__(self, room, guest, date): -> Option A

4. Quick Check:

   Constructor = __init__ method [OK]

Hint: Python constructors always use __init__(self, ...) [OK]

Common Mistakes:

• Using method name other than __init__
• Omitting self parameter
• Using class name as method name

3. Given the following code snippet, what will be the output?

class Room:
    def __init__(self, number):
        self.number = number
        self.is_available = True

class Booking:
    def __init__(self, room):
        self.room = room
        self.room.is_available = False

room101 = Room(101)
print(room101.is_available)
booking1 = Booking(room101)
print(room101.is_available)

medium

A. True\nTrue

B. False\nTrue

C. False\nFalse

D. True\nFalse

Solution

1. Step 1: Check initial availability of room101

   When room101 is created, is_available is set to True, so first print outputs True.

2. Step 2: Booking changes room availability

   Booking constructor sets room101.is_available to False, so second print outputs False.

3. Final Answer:

   True\nFalse -> Option D

4. Quick Check:

   Initial True, then set False by Booking [OK]

Hint: Booking sets room availability to False immediately [OK]

Common Mistakes:

• Assuming availability stays True after booking
• Confusing order of prints
• Ignoring side effect on room object

4. Identify the error in the following Booking class code snippet:

class Room:
    def __init__(self, number):
        self.number = number
        self.is_available = True

class Booking:
    def __init__(self, room, guest):
        self.room = room
        self.guest = guest
    def book(self):
        if self.room.is_available:
            self.room.is_available = False
            print("Booking successful")
        else:
            print("Room not available")

room = Room(201)
booking = Booking(room)
booking.book()

medium

A. is_available should be a method, not attribute

B. Missing guest argument when creating Booking instance

C. book method should return a value

D. Room class is not defined

Solution

1. Step 1: Check Booking constructor parameters

   Booking __init__ requires room and guest, but only room is passed when creating booking instance.

2. Step 2: Identify missing argument error

   Omitting guest argument causes a TypeError at runtime.

3. Final Answer:

   Missing guest argument when creating Booking instance -> Option B

4. Quick Check:

   Constructor args mismatch = missing guest [OK]

Hint: Match all constructor parameters when creating objects [OK]

Common Mistakes:

• Ignoring missing guest argument
• Assuming book method must return value
• Thinking is_available must be a method

5. You want to design a system where a Hotel manages multiple Rooms and allows Bookings only if rooms are available. Which design approach best supports scalability and maintainability?

hard

A. Make Booking class manage all Rooms and Guests directly, without Hotel involvement.

B. Store all booking data inside Room class only, without separate Booking class.

C. Have Hotel class contain a list of Room objects, and Booking class references Room and Guest; Hotel checks availability before booking.

D. Use a single class combining Hotel, Room, and Booking functionalities.

Solution

1. Step 1: Analyze class responsibilities

   Hotel should manage Rooms, Booking should link Rooms and Guests, keeping clear separation.

2. Step 2: Evaluate design for scalability

   Have Hotel class contain a list of Room objects, and Booking class references Room and Guest; Hotel checks availability before booking. cleanly separates concerns, allowing Hotel to check availability and Booking to handle reservations, supporting easy maintenance and scaling.

3. Final Answer:

   Hotel manages Rooms; Booking references Room and Guest; Hotel checks availability -> Option C

4. Quick Check:

   Separation of concerns = Have Hotel class contain a list of Room objects, and Booking class references Room and Guest; Hotel checks availability before booking. [OK]

Hint: Separate Hotel, Room, Booking roles for clean design [OK]

Common Mistakes:

• Combining all logic in one class
• Booking managing Rooms directly
• Ignoring availability checks in Hotel