Designing a Hotel Reservation System Using OOD

Designing a Hotel Reservation System using Object-Oriented Design (OOD) involves creating a flexible, scalable, and easy-to-maintain system. We will break it down into several key components, focusing on the core OOD principles: encapsulation, inheritance, polymorphism, and abstraction. Here’s how to design the system:

1. Understanding Requirements

Before diving into the design, we need to outline the basic features of the Hotel Reservation System. These could include:

• Room reservation (for guests)

• Room availability check

• Booking management (cancellation, modification)

• Billing system (charges for stay, additional services)

• Customer management (storing guest details)

• Room management (adding/removing rooms, room types)

• Payment processing

• Report generation (e.g., booking history, revenue)

2. Key Entities and Classes

Here are the key entities for the system, broken down into their corresponding classes:

a. Room Class

A Room is one of the main entities of the system. Each room has attributes like room type, price, and availability status.

python
CopyEdit
class Room:
    def __init__(self, room_number, room_type, price):
        self.room_number = room_number
        self.room_type = room_type
        self.price = price
        self.is_available = True

    def reserve(self):
        self.is_available = False

    def release(self):
        self.is_available = True

    def get_room_details(self):
        return {
            "room_number": self.room_number,
            "room_type": self.room_type,
            "price": self.price,
            "is_available": self.is_available
        }

b. Guest Class

A guest holds personal details for a hotel stay. This class is used to manage reservations and guest data.

python
CopyEdit
class Guest:
    def __init__(self, guest_id, first_name, last_name, contact_info):
        self.guest_id = guest_id
        self.first_name = first_name
        self.last_name = last_name
        self.contact_info = contact_info
        self.reservations = []

    def add_reservation(self, reservation):
        self.reservations.append(reservation)

    def get_guest_details(self):
        return {
            "guest_id": self.guest_id,
            "name": f"{self.first_name} {self.last_name}",
            "contact_info": self.contact_info
        }

c. Reservation Class

The Reservation class connects the guest and the room. It holds information about the booking, such as check-in/check-out dates and payment status.

python
CopyEdit
class Reservation:
    def __init__(self, reservation_id, guest, room, check_in_date, check_out_date):
        self.reservation_id = reservation_id
        self.guest = guest
        self.room = room
        self.check_in_date = check_in_date
        self.check_out_date = check_out_date
        self.status = "Booked"  # Could be "Cancelled", "Completed"
        self.payment_status = "Unpaid"  # Could be "Paid"

    def cancel_reservation(self):
        self.status = "Cancelled"
        self.room.release()

    def check_in(self):
        self.status = "Checked-in"

    def check_out(self):
        self.status = "Completed"
        self.room.release()

    def make_payment(self):
        self.payment_status = "Paid"

d. Hotel Class

The Hotel class manages rooms, reservations, and the overall system’s operations. It has methods for making reservations, listing available rooms, and handling guest bookings.

python
CopyEdit
class Hotel:
    def __init__(self, name, address):
        self.name = name
        self.address = address
        self.rooms = []
        self.reservations = []

    def add_room(self, room):
        self.rooms.append(room)

    def get_available_rooms(self):
        return [room for room in self.rooms if room.is_available]

    def make_reservation(self, guest, room, check_in_date, check_out_date):
        if room.is_available:
            reservation = Reservation(
                reservation_id=len(self.reservations) + 1,
                guest=guest,
                room=room,
                check_in_date=check_in_date,
                check_out_date=check_out_date
            )
            self.reservations.append(reservation)
            room.reserve()
            guest.add_reservation(reservation)
            return reservation
        else:
            return None  # Room is not available

3. System Features Using OOD Principles

a. Encapsulation

Each class hides its internal state and exposes only the necessary methods. For example, the Room class only exposes reserve() and release() methods to modify its availability status. This prevents external code from directly modifying room states.

b. Inheritance

We could extend the Room class to create specialized room types, such as DeluxeRoom and StandardRoom. This allows us to reuse the Room class’s functionality while adding more specific attributes.

python
CopyEdit
class DeluxeRoom(Room):
    def __init__(self, room_number, price, amenities):
        super().__init__(room_number, "Deluxe", price)
        self.amenities = amenities

    def get_room_details(self):
        details = super().get_room_details()
        details["amenities"] = self.amenities
        return details

c. Polymorphism

The Hotel class can interact with different types of rooms (standard or deluxe) without knowing their specific implementation. We can use polymorphism to handle room reservations of varying types.

d. Abstraction

The Hotel class provides an abstraction layer for interacting with rooms and reservations, meaning clients (e.g., external systems, users) do not need to know the details of how the reservation is handled, just that they can book a room, cancel it, or check it out.

4. System Design Considerations

• Scalability: You can easily add more room types, guest management features, or billing options without changing the core structure.

• Flexibility: If the hotel expands to handle multiple branches, the design can be extended by creating a Branch class that contains its own list of rooms and reservations.

• Maintainability: By using OOD principles, the system is organized, and future enhancements can be easily integrated.

5. Use Case Example

Let’s go through a simple example:

1. A guest makes a reservation for a room at the hotel.

2. The system checks room availability.

3. If a room is available, the reservation is created, and the room is marked as reserved.

4. The guest’s payment is processed.

5. After the stay, the guest checks out, and the room is released for further bookings.

6. Final Thoughts

This design can be further enhanced by introducing advanced features such as discounts, loyalty programs, or seasonal pricing. The system’s modular design allows for future enhancements without major changes to the existing structure. The key OOD principles (inheritance, encapsulation, abstraction, and polymorphism) ensure that the system remains extensible and maintainable.