**Course Title:** Software Design Principles: Foundations and Best Practices **Section Title:** Design Patterns: Introduction and Creational Patterns **Topic:** Implement a creational pattern in a small project.(Lab topic) **Overview** In this lab topic, we will apply the creational patterns learned in the previous topics to a small project. We will design and implement a simple application that demonstrates the Factory Method pattern. This will help you understand how to apply design patterns in real-world scenarios and make informed decisions about when to use each pattern. **Project Description** You are tasked with designing a system that allows users to create and manage different types of vehicles (e.g., cars, trucks, motorcycles). Each vehicle type has its unique characteristics and features. You will use the Factory Method pattern to create a system that can create and manage different types of vehicles. **Step 1: Define the Requirements** Before we start designing the system, let's define the requirements: * The system should be able to create different types of vehicles (e.g., cars, trucks, motorcycles). * Each vehicle type should have its unique characteristics and features. * The system should be able to manage all types of vehicles. * The system should be extensible, allowing new vehicle types to be added in the future. **Step 2: Design the System** Based on the requirements, we can design the system using the Factory Method pattern. We will create an abstract class `Vehicle` that defines the common characteristics and features of all vehicles. We will then create concrete classes `Car`, `Truck`, and `Motorcycle` that inherit from the `Vehicle` class and implement the specific features of each vehicle type. We will also create a `VehicleFactory` class that will be responsible for creating instances of the different vehicle types. The `VehicleFactory` class will use the Factory Method pattern to create instances of the different vehicle types based on the input provided by the user. **Step 3: Implement the System** Here is an example implementation of the system in Python: ```python # Abstract class Vehicle class Vehicle: def __init__(self, make, model): self.make = make self.model = model def display_info(self): print(f"Make: {self.make}, Model: {self.model}") # Concrete class Car class Car(Vehicle): def __init__(self, make, model, num_doors): super().__init__(make, model) self.num_doors = num_doors def display_info(self): super().display_info() print(f"Number of doors: {self.num_doors}") # Concrete class Truck class Truck(Vehicle): def __init__(self, make, model, payload_capacity): super().__init__(make, model) self.payload_capacity = payload_capacity def display_info(self): super().display_info() print(f"Payload capacity: {self.payload_capacity} lbs") # Concrete class Motorcycle class Motorcycle(Vehicle): def __init__(self, make, model, engine_size): super().__init__(make, model) self.engine_size = engine_size def display_info(self): super().display_info() print(f"Engine size: {self.engine_size} cc") # VehicleFactory class class VehicleFactory: def create_vehicle(self, vehicle_type, make, model, **kwargs): if vehicle_type == "car": return Car(make, model, kwargs["num_doors"]) elif vehicle_type == "truck": return Truck(make, model, kwargs["payload_capacity"]) elif vehicle_type == "motorcycle": return Motorcycle(make, model, kwargs["engine_size"]) else: raise ValueError("Invalid vehicle type") # Example usage factory = VehicleFactory() car = factory.create_vehicle("car", "Toyota", "Camry", num_doors=4) car.display_info() truck = factory.create_vehicle("truck", "Ford", "F-150", payload_capacity=2000) truck.display_info() motorcycle = factory.create_vehicle("motorcycle", "Honda", "CBR500R", engine_size=500) motorcycle.display_info() ``` **Step 4: Test and Refactor** Test the system by creating instances of different vehicle types and verifying that they are created correctly. Refactor the code as needed to improve performance, readability, and maintainability. **Conclusion** In this lab topic, we applied the Factory Method pattern to design and implement a system that creates and manages different types of vehicles. We demonstrated how to use the pattern to create a flexible and extensible system that can be easily extended to support new vehicle types. **What to Do Next** * Review the code and refactor it as needed to improve performance, readability, and maintainability. * Test the system thoroughly to ensure that it works correctly. * Consider adding new features to the system, such as the ability to save and load vehicle data. **Resources** * [Design Patterns: Elements of Reusable Object-Oriented Software](https://en.wikipedia.org/wiki/Design_Patterns_(book)) * [Factory Method Pattern](https://en.wikipedia.org/wiki/Factory_method_pattern) * [Python documentation](https://docs.python.org/3/) **Leave a Comment or Ask for Help** If you have any questions or need help with the lab topic, please leave a comment below. We will respond to your questions and provide guidance as needed. Next Topic: 'Adapter Pattern' From: Structural Patterns.