A public transport company provides three types of transports to its passengers to travel from city A to city B of different state. The three types of transports are train, bus and taxi. Each transport has different charges and maximum seats limit. The table below shows the detail of each transport.
The company only provides one trip per day for each transport. The company has a ticket counter to sell tickets to its passengers.
Write an application that is able to simulate the ticket counter system. In each transaction, your program should read the transport type (train, bus or taxi) and the number of passengers. Your program then calculates and displays the total charge and record down the transaction. Your system is also able to check the seat availability before allowing any transaction. Other than selling the ticket, your system is also able to show all the transactions in the day.
Design your program in object-oriented design using inheritance and polymorphism.
To design a program using object-oriented design principles for simulating a ticket counter system for a public transport company, we can create a class hierarchy with a base class representing the transport and each specific type of transport as derived classes.
Let's start by creating a base class called "Transport" that will have common attributes and methods for all types of transport. This class will have attributes such as transport type, charge per passenger, and maximum seat limit.
```python
class Transport:
def __init__(self, transport_type, charge_per_passenger, max_seat_limit):
self.transport_type = transport_type
self.charge_per_passenger = charge_per_passenger
self.max_seat_limit = max_seat_limit
self.seat_count = max_seat_limit
def calculate_total_charge(self, num_passengers):
return self.charge_per_passenger * num_passengers
def is_seat_available(self):
return self.seat_count > 0
def book_ticket(self, num_passengers):
if self.is_seat_available():
self.seat_count -= num_passengers
return True
else:
return False
def get_transport_type(self):
return self.transport_type
def get_seat_count(self):
return self.seat_count
```
Now, we can create specific transport classes that inherit from the base class "Transport". In this case, we will create three classes: "Train", "Bus", and "Taxi". Each of these classes will have specific charge rates and maximum seat limits.
```python
class Train(Transport):
def __init__(self):
super().__init__("Train", 10, 100)
class Bus(Transport):
def __init__(self):
super().__init__("Bus", 5, 50)
class Taxi(Transport):
def __init__(self):
super().__init__("Taxi", 20, 10)
```
Now, let's create the main application class that will simulate the ticket counter system. This class will have methods for selling tickets, checking seat availability, and displaying all transactions. It will also have a list to store all the transactions.
```python
class TicketCounter:
def __init__(self):
self.transactions = []
def sell_ticket(self, transport_type, num_passengers):
if transport_type.lower() == "train":
transport = Train()
elif transport_type.lower() == "bus":
transport = Bus()
elif transport_type.lower() == "taxi":
transport = Taxi()
else:
return "Invalid transport type."
if not transport.is_seat_available():
return "No seats available for {}.".format(transport_type)
if not transport.book_ticket(num_passengers):
return "Not enough seats available for {}.".format(transport_type)
total_charge = transport.calculate_total_charge(num_passengers)
self.transactions.append((transport.get_transport_type(), num_passengers, total_charge))
return "Ticket sold for {} passengers on {} transport. Total charge: {}.".format(
num_passengers, transport.get_transport_type(), total_charge)
def check_seat_availability(self, transport_type):
if transport_type.lower() == "train":
transport = Train()
elif transport_type.lower() == "bus":
transport = Bus()
elif transport_type.lower() == "taxi":
transport = Taxi()
else:
return "Invalid transport type."
return "Seats available for {} transport: {}.".format(
transport.get_transport_type(), transport.get_seat_count())
def display_transactions(self):
if len(self.transactions) > 0:
print("All transactions:")
for transaction in self.transactions:
print("Transport: {}, Passengers: {}, Charge: {}".format(*transaction))
else:
print("No transactions.")
```
To use this ticket counter system, you can create an instance of the "TicketCounter" class and call its methods as per your requirement.
```python
ticket_counter = TicketCounter()
print(ticket_counter.sell_ticket("Train", 2))
print(ticket_counter.sell_ticket("Bus", 5))
print(ticket_counter.sell_ticket("Train", 4))
print(ticket_counter.sell_ticket("Taxi", 3))
print(ticket_counter.check_seat_availability("Train"))
print(ticket_counter.check_seat_availability("Bus"))
print(ticket_counter.check_seat_availability("Taxi"))
ticket_counter.display_transactions()
```
This is a basic implementation of the ticket counter system using object-oriented design principles. You can further enhance the system by adding more functionality or implementing input validation as per your requirements.