Added abstract factory pattern

Author: Mayur Kadam

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/Bicycle/NormalBicycle.ts

@@ -0,0 +1,9 @@
+import { Bicycle } from "../interfaces";
+
+class NormalBicycle implements Bicycle {
+    ride(): void {
+        console.log("Riding a normal bicycle!");
+    }
+}
+
+export { NormalBicycle };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/Bicycle/SportsBicycle.ts

@@ -0,0 +1,9 @@
+import { Bicycle } from "../interfaces";
+
+class SportsBicycle implements Bicycle {
+    ride(): void {
+        console.log("Riding a sports bicycle!");
+    }
+}
+
+export { SportsBicycle };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/Bike/NormalBike.ts

@@ -0,0 +1,9 @@
+import { Bike } from "../interfaces";
+
+class NormalBike implements Bike {
+    ride(): void {
+        console.log("Riding a normal bike!");
+    }
+}
+
+export { NormalBike };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/Bike/SportsBike.ts

@@ -0,0 +1,9 @@
+import { Bike } from "../interfaces";
+
+class SportsBike implements Bike {
+    ride(): void {
+        console.log("Riding a sports bike!");
+    }
+}
+
+export { SportsBike };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/Car/NormalCar.ts

@@ -0,0 +1,9 @@
+import { Car } from "../interfaces";
+
+class NormalCar implements Car {
+    drive(): void {
+        console.log("Driving a normal car!");
+    }
+}
+
+export { NormalCar };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/Car/SportsCar.ts

@@ -0,0 +1,9 @@
+import { Car } from "../interfaces";
+
+class SportsCar implements Car {
+    drive(): void {
+        console.log("Driving a fast sports car!");
+    }
+}
+
+export { SportsCar };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/NormalVehicleFactory.ts

@@ -0,0 +1,20 @@
+import { NormalBicycle } from "./Bicycle/NormalBicycle";
+import { NormalBike } from "./Bike/NormalBike";
+import { NormalCar } from "./Car/NormalCar";
+import { Bicycle, Bike, Car, VehicleFactory } from "./interfaces";
+
+class NormalVehicleFactory implements VehicleFactory {
+    createBike(): Bike {
+        return new NormalBike();
+    }
+
+    createCar(): Car {
+        return new NormalCar();
+    }
+
+    createBicycle(): Bicycle {
+        return new NormalBicycle();
+    }
+}
+
+export { NormalVehicleFactory };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/README.md

@@ -0,0 +1,62 @@
+# Abstract Factory Pattern - Vehicle System
+
+## Overview
+The **Abstract Factory Pattern** is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern is useful when multiple objects with a shared theme need to be instantiated dynamically based on some criteria.
+
+In this **Vehicle System**, the Abstract Factory Pattern is implemented to create **Normal** and **Sports** variants of different vehicles like **Cars, Bikes, and Bicycles**.
+
+## Folder Structure
+```
+/VehicleSystem
+│── index.ts
+│── interfaces.ts
+│── NormalVehicleFactory.ts
+│── SportsVehicleFactory.ts
+│── /Car
+│   │── NormalCar.ts
+│   │── SportsCar.ts
+│── /Bike
+│   │── NormalBike.ts
+│   │── SportsBike.ts
+│── /Bicycle
+│   │── NormalBicycle.ts
+│   │── SportsBicycle.ts
+```
+
+## Design Flow
+1. **Define an Abstract Interface**
+   - The `interfaces.ts` file contains an interface that defines the common structure of all vehicle types.
+
+2. **Concrete Vehicle Implementations**
+   - `NormalCar.ts` and `SportsCar.ts` implement the `Car` interface.
+   - `NormalBike.ts` and `SportsBike.ts` implement the `Bike` interface.
+   - `NormalBicycle.ts` and `SportsBicycle.ts` implement the `Bicycle` interface.
+
+3. **Abstract Factory Interface**
+   - The `interfaces.ts` file also contains an abstract factory interface that declares methods for creating different types of vehicles.
+
+4. **Concrete Factory Implementations**
+   - `NormalVehicleFactory.ts` implements the abstract factory to create **Normal** variants.
+   - `SportsVehicleFactory.ts` implements the abstract factory to create **Sports** variants.
+
+5. **Client Code Usage**
+   - The `index.ts` file contains the client code that dynamically selects the appropriate factory (Normal or Sports) and creates the required vehicle objects.
+
+## Code Flow
+- The client decides which factory to use based on the requirement.
+- The factory generates an instance of the specific vehicle type.
+- The created vehicle object follows the structure defined in the interface, ensuring consistency across different vehicle types.
+
+## Benefits of Abstract Factory Pattern
+- **Encapsulation of Object Creation:** Clients do not need to know the exact class names; they interact with the abstract factory.
+- **Scalability & Maintainability:** New types of vehicles can be added without modifying existing client code.
+- **Consistency Across Products:** Ensures all created objects follow a uniform structure and behavior.
+- **Separation of Concerns:** The object creation logic is separated from its usage, improving modularity.
+
+## When to Use Abstract Factory Pattern?
+- When a system needs to create multiple related objects dynamically.
+- When enforcing consistency across multiple families of objects.
+- When object creation logic needs to be encapsulated and separated from the main business logic.
+
+This implementation of the **Abstract Factory Pattern** in a **Vehicle System** provides a structured approach to vehicle creation, allowing flexibility and scalability for future enhancements.
+

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/SportsVehicleFactory.ts

@@ -0,0 +1,20 @@
+import { SportsBicycle } from "./Bicycle/SportsBicycle";
+import { SportsBike } from "./Bike/SportsBike";
+import { SportsCar } from "./Car/SportsCar";
+import { Bicycle, Bike, Car, VehicleFactory } from "./interfaces";
+
+class SportsVehicleFactory implements VehicleFactory {
+    createBike(): Bike {
+        return new SportsBike();
+    }
+
+    createCar(): Car {
+        return new SportsCar();
+    }
+
+    createBicycle(): Bicycle {
+        return new SportsBicycle();
+    }
+}
+
+export { SportsVehicleFactory };

05 - Low Level Design/03 - TypeScript Design Pattern/Creational Design Patterns/Abstract Factory/Vehicle System/index.ts

@@ -0,0 +1,21 @@
+import { NormalVehicleFactory } from "./NormalVehicleFactory";
+import { SportsVehicleFactory } from "./SportsVehicleFactory";
+import { VehicleFactory } from "./interfaces";
+
+function testFactory(factory: VehicleFactory) {
+    const car = factory.createCar();
+    const bike = factory.createBike();
+    const bicycle = factory.createBicycle();
+
+    car.drive();
+    bike.ride();
+    bicycle.ride();
+} 
+
+// Example Usage
+console.log("Normal Vehicles:");
+testFactory(new NormalVehicleFactory());
+console.log();
+
+console.log("Sports Vehicles:");
+testFactory(new SportsVehicleFactory());