Room type hierarchy in LLD - System Design Exercise

Design: Room Type Hierarchy System

Design focuses on the class and object hierarchy for room types and their attributes. It excludes UI design, database persistence, and network communication.

Functional Requirements

FR1: Define different room types with common and specific attributes

FR2: Support inheritance of properties from parent room types to child room types

FR3: Allow adding new room types without changing existing code

FR4: Enable querying room types and their attributes

FR5: Support multiple levels of hierarchy (e.g., Room -> Bedroom -> Master Bedroom)

Non-Functional Requirements

NFR1: System should handle up to 1000 room types

NFR2: Query response time for room type details should be under 100ms

NFR3: System should be extensible and maintainable

NFR4: Memory usage should be optimized for embedded or low-resource environments

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Base RoomType class or interface

Derived classes for specific room types

Attribute storage and inheritance mechanism

Factory or builder pattern for creating room types

Query interface for retrieving room type details

Design Patterns

Inheritance and polymorphism

Composite pattern for hierarchical structures

Factory pattern for object creation

Decorator pattern for adding attributes dynamically

Reference Architecture

RoomType (Base Class)
  |
  +-- Bedroom (Derived Class)
       |
       +-- MasterBedroom (Derived Class)
       +-- GuestBedroom (Derived Class)
  +-- Kitchen (Derived Class)
  +-- Bathroom (Derived Class)

Components

RoomType Base Class

Object-Oriented Programming (any language)

Defines common attributes and methods for all room types

Derived RoomType Classes

OOP inheritance

Specialize room types with specific attributes and behaviors

Attribute Storage

Class fields or dictionaries

Store attributes with inheritance support

RoomType Factory

Factory design pattern

Create room type instances dynamically

Query Interface

Methods or APIs

Retrieve room type details and attributes

Request Flow

1. Client requests details for a specific room type

2. Query interface calls the RoomType factory to get the instance

3. RoomType instance returns attributes, including inherited ones

4. Client receives complete room type information

Database Schema

Not applicable - design focuses on in-memory class hierarchy and inheritance

Scaling Discussion

Bottlenecks

Large number of room types causing memory overhead

Deep inheritance chains increasing lookup time for attributes

Difficulty in adding new room types without modifying base classes

Solutions

Use attribute dictionaries with caching to reduce repeated lookups

Limit inheritance depth and use composition for shared attributes

Implement a plugin or registration system for adding new room types dynamically

Interview Tips

Time: 10 minutes for requirements and clarifications, 20 minutes for design and explanation, 15 minutes for scaling and Q&A

Explain the importance of inheritance for code reuse and clarity

Discuss trade-offs between inheritance and composition

Show how design supports extensibility and maintainability

Mention performance considerations for attribute lookup

Highlight how the factory pattern helps in dynamic creation

Practice

1. What is the main purpose of using a Room type hierarchy in system design?

easy

A. To randomly assign room types without any structure

B. To organize rooms by shared and unique features for easier maintenance

C. To store all room data in a single flat list without categories

D. To duplicate room properties in every class separately

Solution

1. Step 1: Understand the concept of hierarchy

   A hierarchy groups items by common traits, making management simpler.

2. Step 2: Apply to room types

   Using a base class for shared features and subclasses for specifics avoids duplication and eases updates.

3. Final Answer:

   To organize rooms by shared and unique features for easier maintenance -> Option B

4. Quick Check:

   Hierarchy = Organize by features [OK]

Hint: Think: shared features go in base, unique in subclasses [OK]

Common Mistakes:

• Confusing hierarchy with flat lists
• Duplicating properties in every room class
• Ignoring shared features in base class

2. Which of the following is the correct way to define a base class Room with a subclass ConferenceRoom in a typical object-oriented design?

easy

A. class Room {}; class ConferenceRoom extends Room {}

B. class Room; class ConferenceRoom inherits Room

C. class Room() {}; class ConferenceRoom() inherits Room()

D. class Room {}; class ConferenceRoom inherits Room {}

Solution

1. Step 1: Identify correct syntax for inheritance

   In many modern languages, extends is used to inherit from a base class.

2. Step 2: Check each option

   class Room {}; class ConferenceRoom extends Room {} uses correct syntax: class ConferenceRoom extends Room {}. Others use incorrect or incomplete syntax.

3. Final Answer:

   class Room {}; class ConferenceRoom extends Room {} -> Option A

4. Quick Check:

   Inheritance syntax = extends [OK]

Hint: Remember: subclass extends base class in OOP [OK]

Common Mistakes:

• Using 'inherits' instead of 'extends'
• Missing curly braces for class body
• Incorrect parentheses in class declaration

3. Given this Python-like pseudocode for room types:

class Room:
    def __init__(self, name):
        self.name = name

class Bedroom(Room):
    def __init__(self, name, bed_size):
        super().__init__(name)
        self.bed_size = bed_size

room = Bedroom('Master', 'King')
print(room.name, room.bed_size)

What will be the output?

medium

A. Error: missing argument

B. Bedroom King

C. Master None

D. Master King

Solution

1. Step 1: Trace object creation

   Creating Bedroom('Master', 'King') calls Bedroom's constructor, which calls Room's constructor with 'Master'.

2. Step 2: Check printed attributes

   room.name is 'Master' from Room; room.bed_size is 'King' from Bedroom.

3. Final Answer:

   Master King -> Option D

4. Quick Check:

   Subclass calls base, attributes set correctly [OK]

Hint: Remember: super() sets base class attributes [OK]

Common Mistakes:

• Assuming subclass overwrites base attributes
• Forgetting to call super().__init__
• Confusing attribute names

4. Consider this code snippet for a room hierarchy:

class Room:
    def __init__(self, name):
        self.name = name

class MeetingRoom(Room):
    def __init__(self, name, capacity):
        self.capacity = capacity

room = MeetingRoom('Boardroom', 20)
print(room.name, room.capacity)

What is the issue here?

medium

A. capacity attribute is not set correctly

B. Syntax error in class definition

C. Missing call to base class constructor causes room.name to be undefined

D. No issue; code runs fine

Solution

1. Step 1: Check constructor chaining

   MeetingRoom's constructor sets capacity but does not call super().__init__(name), so name is not set.

2. Step 2: Understand effect on attributes

   Without base constructor call, room.name is missing, causing error or undefined behavior.

3. Final Answer:

   Missing call to base class constructor causes room.name to be undefined -> Option C

4. Quick Check:

   Always call base __init__ in subclass [OK]

Hint: Call super().__init__ to set base attributes [OK]

Common Mistakes:

• Assuming base constructor runs automatically
• Ignoring missing attributes in subclass
• Confusing syntax errors with logic errors

5. You need to design a room type hierarchy for a hotel system that includes Room, Bedroom, ConferenceRoom, and Suite. Suites can have multiple bedrooms and a living area. Which design approach best models this?

hard

A. Make Suite inherit from Room and include a list of Bedroom objects plus living area

B. Make Suite inherit from Bedroom and add living area attributes

C. Make Suite a separate class unrelated to Room hierarchy

D. Make Bedroom inherit from Suite to reuse features

Solution

1. Step 1: Analyze relationships

   Suite is a special Room that contains multiple Bedrooms and a living area, so it should inherit from Room.

2. Step 2: Model composition

   Suite should have a list of Bedroom objects (composition) to represent multiple bedrooms, plus its own living area attributes.

3. Final Answer:

   Make Suite inherit from Room and include a list of Bedroom objects plus living area -> Option A

4. Quick Check:

   Use inheritance + composition for complex types [OK]

Hint: Use composition for multiple rooms inside Suite [OK]

Common Mistakes:

• Using inheritance to model 'has-many' relationships
• Ignoring composition for complex room types
• Making unrelated classes inherit incorrectly