Designing a Public Bicycle Rental System Using Object-Oriented Principles

A Public Bicycle Rental System is a service that allows users to rent bicycles on a short-term basis. The system needs to handle various functions such as managing bicycle availability, tracking user rentals, and ensuring proper bike maintenance. Using object-oriented design (OOD) principles ensures that the system is modular, flexible, and scalable.

Key Components of the System

In this design, we will break down the system into classes, which represent the various entities involved. Each class will have specific responsibilities, and we will make use of inheritance, encapsulation, and polymorphism to ensure efficient and maintainable code.

1. Classes and Their Responsibilities

1.1 Bicycle Class

The Bicycle class represents a single bicycle in the system. It is responsible for storing information about the bicycle, including its status (e.g., available, rented, under maintenance).

Attributes:

• bicycleID: Unique identifier for each bicycle.

• status: Current status of the bicycle (Available, Rented, Under Maintenance).

• location: The location or station where the bicycle is currently stored.

Methods:

• updateStatus(status): Changes the status of the bicycle.

• updateLocation(location): Changes the location of the bicycle.

• isAvailable(): Returns true if the bicycle is available for rent.

python
CopyEdit
class Bicycle:
    def __init__(self, bicycleID, status, location):
        self.bicycleID = bicycleID
        self.status = status
        self.location = location

    def updateStatus(self, status):
        self.status = status

    def updateLocation(self, location):
        self.location = location

    def isAvailable(self):
        return self.status == "Available"

1.2 User Class

The User class represents customers who rent bicycles. It stores information about the user and manages their rentals.

Attributes:

• userID: Unique identifier for each user.

• name: Name of the user.

• rentedBikes: A list of bicycles currently rented by the user.

Methods:

• rentBicycle(bicycle): Rents a bicycle to the user.

• returnBicycle(bicycle): Returns the bicycle rented by the user.

• hasRentedBike(): Checks if the user has rented a bike.

python
CopyEdit
class User:
    def __init__(self, userID, name):
        self.userID = userID
        self.name = name
        self.rentedBikes = []

    def rentBicycle(self, bicycle):
        if bicycle.isAvailable():
            bicycle.updateStatus("Rented")
            self.rentedBikes.append(bicycle)
            print(f"{self.name} rented bicycle {bicycle.bicycleID}")
        else:
            print(f"Bicycle {bicycle.bicycleID} is not available for rent.")

    def returnBicycle(self, bicycle):
        if bicycle in self.rentedBikes:
            bicycle.updateStatus("Available")
            self.rentedBikes.remove(bicycle)
            print(f"{self.name} returned bicycle {bicycle.bicycleID}")
        else:
            print(f"{self.name} hasn't rented bicycle {bicycle.bicycleID}.")

    def hasRentedBike(self):
        return len(self.rentedBikes) > 0

1.3 BicycleStation Class

The BicycleStation class manages a collection of bicycles at a specific location. It keeps track of the bicycles available for rent and those that are in need of maintenance.

Attributes:

• stationID: Unique identifier for each station.

• location: The physical address or coordinates of the station.

• bicycles: A collection (list) of bicycles at this station.

Methods:

• addBicycle(bicycle): Adds a bicycle to the station.

• removeBicycle(bicycle): Removes a bicycle from the station.

• getAvailableBicycles(): Returns a list of available bicycles at the station.

python
CopyEdit
class BicycleStation:
    def __init__(self, stationID, location):
        self.stationID = stationID
        self.location = location
        self.bicycles = []

    def addBicycle(self, bicycle):
        self.bicycles.append(bicycle)

    def removeBicycle(self, bicycle):
        self.bicycles.remove(bicycle)

    def getAvailableBicycles(self):
        return [bike for bike in self.bicycles if bike.isAvailable()]

1.4 RentalSystem Class

The RentalSystem class serves as the central hub for managing rentals. It coordinates between users, bicycles, and stations.

Attributes:

• users: A collection of users registered with the system.

• stations: A collection of bicycle stations available in the system.

Methods:

• registerUser(user): Registers a new user.

• findBicycle(stationID): Finds an available bicycle in a given station.

• returnBicycle(user, bicycle): Manages the return process of a bicycle.

• displayAvailableBikes(): Displays all available bicycles across all stations.

python
CopyEdit
class RentalSystem:
    def __init__(self):
        self.users = []
        self.stations = []

    def registerUser(self, user):
        self.users.append(user)

    def findBicycle(self, stationID):
        for station in self.stations:
            if station.stationID == stationID:
                available_bikes = station.getAvailableBicycles()
                if available_bikes:
                    return available_bikes[0]  # Returns the first available bicycle
        return None

    def returnBicycle(self, user, bicycle):
        user.returnBicycle(bicycle)

    def displayAvailableBikes(self):
        available_bikes = []
        for station in self.stations:
            available_bikes.extend(station.getAvailableBicycles())
        return available_bikes

2. Interactions Between Classes

2.1 Renting a Bicycle

When a user wants to rent a bicycle, the system checks for available bicycles at a specific station and allows the user to rent one.

python
CopyEdit
# Create system and stations
rental_system = RentalSystem()
station1 = BicycleStation(1, "Station A")
station2 = BicycleStation(2, "Station B")

# Add bicycles to stations
bicycle1 = Bicycle(101, "Available", "Station A")
bicycle2 = Bicycle(102, "Available", "Station B")
station1.addBicycle(bicycle1)
station2.addBicycle(bicycle2)

# Register a user
user1 = User(1, "John Doe")
rental_system.registerUser(user1)

# Rent a bicycle
available_bike = rental_system.findBicycle(1)
if available_bike:
    user1.rentBicycle(available_bike)
else:
    print("No available bicycles.")

2.2 Returning a Bicycle

When a user returns a bicycle, the bicycle’s status is updated, and the system logs the return.

python
CopyEdit
# User returns a bicycle
user1.returnBicycle(bicycle1)

3. Enhancements and Future Considerations

3.1 Maintenance Management

To track bicycle maintenance, we could add a maintenanceStatus attribute to the Bicycle class and implement a maintenance scheduling system.

3.2 Pricing and Billing

A class could be added to handle pricing calculations based on rental duration and other factors, such as a discount for frequent users.

3.3 Notifications

Notifications could be implemented to alert users about available bicycles or maintenance needs for the bikes they rented.

3.4 GPS Integration

For real-time location tracking, a GPS system could be integrated into each bicycle to track its whereabouts and make the system more dynamic.

3.5 Data Persistence

For a real-world system, adding data persistence (e.g., using a database to store users, bicycles, and stations) would be essential to maintain the integrity of the system.

4. Conclusion

By using object-oriented principles like encapsulation, inheritance, and polymorphism, the public bicycle rental system is designed to be modular, flexible, and easy to maintain. The system can easily be extended to incorporate more advanced features like dynamic pricing, advanced maintenance tracking, and user preferences.