Added Null Object Pattern & updated README.MD file.

Author: Mayur Kadam

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/Bicycle.ts

@@ -0,0 +1,17 @@
+import { Vehicle } from "./Vehicle";
+
+class Bicycle extends Vehicle {
+    isEngine(): boolean {
+        return false;
+    }
+
+    isElectric(): boolean {
+        return true;
+    }
+
+    getEngineCount(): number {
+        return 0;
+    }
+}
+
+export { Bicycle };

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/Bike.ts

@@ -0,0 +1,17 @@
+import { Vehicle } from "./Vehicle";
+
+class Bike extends Vehicle {
+    isEngine(): boolean {
+        return true;
+    }
+
+    isElectric(): boolean {
+        return true;
+    }
+
+    getEngineCount(): number {
+        return 1;
+    }
+}
+
+export { Bike };

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/Car.ts

@@ -0,0 +1,17 @@
+import { Vehicle } from "./Vehicle";
+
+class Car extends Vehicle {
+    isEngine(): boolean {
+        return true;
+    }
+
+    isElectric(): boolean {
+        return false;
+    }
+
+    getEngineCount(): number {
+        return 1;
+    }
+}
+
+export { Car };

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/NullVehicle.ts

@@ -0,0 +1,25 @@
+import { Vehicle } from "./Vehicle";
+
+class NullVehicle extends Vehicle {
+    private static instance: NullVehicle | null = null; // Explicitly declare static property
+
+    isEngine(): boolean {
+        return false;
+    }
+    isElectric(): boolean {
+        return false;
+    }
+    getEngineCount(): number {
+        return 0;
+    }
+
+    // OPTIONAL BELOW METHOD : Since NullVehicle does not store any state, we can make it a singleton to avoid creating multiple redundant instances.
+    static getInstance(): NullVehicle {
+        if (!NullVehicle.instance) {
+            NullVehicle.instance = new NullVehicle();
+        }
+        return NullVehicle.instance;
+    }
+}
+
+export { NullVehicle };

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/README.md

@@ -0,0 +1,83 @@
+# Null Object Pattern - Vehicle System
+
+## Overview
+This project demonstrates the **Null Object Pattern** using a Vehicle system in TypeScript. The pattern is used to avoid `null` checks by providing a default behavior for cases where an object is expected but not available. Instead of returning `null`, a **NullVehicle** class is used to handle such cases gracefully.
+
+## Design Pattern Explanation
+The **Null Object Pattern** is a behavioral design pattern that provides an object as a surrogate for the absence of a real object. It helps eliminate `null` checks and improves code maintainability.
+
+## Project Structure
+```
+├── Bicycle.ts
+├── Bike.ts
+├── Car.ts
+├── NullVehicle.ts
+├── Vehicle.ts
+├── VehicleFactory.ts
+└── index.ts
+```
+
+### **1. Vehicle Base Class**
+`Vehicle.ts` defines an abstract class that serves as the base for all vehicle types. It includes methods that each concrete vehicle type must implement.
+```typescript
+abstract class Vehicle {
+    abstract isEngine(): boolean;
+    abstract isElectric(): boolean;
+    abstract getEngineCount(): number;
+}
+```
+
+### **2. Concrete Vehicle Implementations**
+- `Car.ts`, `Bike.ts`, and `Bicycle.ts` implement the `Vehicle` class and provide real behavior.
+- Each concrete class returns values specific to its type.
+
+### **3. Null Object Implementation**
+- `NullVehicle.ts` is a subclass of `Vehicle` that provides default values instead of returning `null`.
+```typescript
+class NullVehicle extends Vehicle {
+    isEngine(): boolean { return false; }
+    isElectric(): boolean { return false; }
+    getEngineCount(): number { return 0; }
+}
+```
+
+### **4. Factory for Creating Vehicles**
+- `VehicleFactory.ts` returns an instance of a requested vehicle type.
+- If an invalid vehicle type is requested, it returns an instance of `NullVehicle`.
+```typescript
+class VehicleFactory {
+    static getVehicleObject(vehicleType: string): Vehicle {
+        switch (vehicleType) {
+            case "Car": return new Car();
+            case "Bike": return new Bike();
+            case "Bicycle": return new Bicycle();
+            default: return new NullVehicle();
+        }
+    }
+}
+```
+
+### **5. Usage Example**
+- `index.ts` demonstrates how the factory is used to create vehicles.
+```typescript
+const car = VehicleFactory.getVehicleObject("Car");
+console.log(car.isEngine()); // true
+
+const unknownVehicle = VehicleFactory.getVehicleObject("Truck");
+console.log(unknownVehicle.isEngine()); // false (handled by NullVehicle)
+```
+
+## Benefits of Using the Null Object Pattern
+✅ **Removes null checks**: No need for repeated `if (vehicle !== null)` checks.  
+✅ **Improves code maintainability**: Cleaner and more readable code.  
+✅ **Prevents null pointer errors**: Avoids runtime crashes due to unexpected `null` values. Here in TypeScript it will be undefined value.  
+✅ **Encapsulates default behavior**: Defines expected behavior for missing objects in one place.
+
+## When to Use
+- When handling missing or optional objects in a system.
+- When you want to avoid excessive null checks.
+- When returning `null` would require additional logic in multiple places.
+
+## Conclusion
+This project demonstrates how the **Null Object Pattern** improves code readability and reliability by replacing `null` with a default, non-functional object (`NullVehicle`). This ensures the system remains stable even when an expected object is missing.
+

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/Vehicle.ts

@@ -0,0 +1,7 @@
+abstract class Vehicle {
+    abstract isEngine(): boolean;
+    abstract isElectric(): boolean;
+    abstract getEngineCount(): number;
+}
+
+export { Vehicle };

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/VehicleFactory.ts

@@ -0,0 +1,23 @@
+import { Bicycle } from "./Bicycle";
+import { Bike } from "./Bike";
+import { Car } from "./Car";
+import { Vehicle } from "./Vehicle";
+import { NullVehicle } from "./NullVehicle";
+
+class VehicleFactory {
+    static getVehicleObject(vehicleType: string): Vehicle {
+        switch (vehicleType) {
+            case "Car":
+                return new Car();
+            case "Bike":
+                return new Bike();
+            case "Bicycle":
+                return new Bicycle();
+            default:
+                console.warn(`Warning: ${vehicleType} is not a valid vehicle type. Returning NullVehicle.`);
+                return NullVehicle.getInstance();
+        }
+    }
+}
+
+export { VehicleFactory };

05 - Low Level Design/03 - TypeScript Design Pattern/Behavioral Design Patterns/Null Object Pattern/Vehicle System/index.ts

@@ -0,0 +1,15 @@
+import { VehicleFactory } from "./VehicleFactory";
+
+const myVehicle = VehicleFactory.getVehicleObject("Bicycle");
+
+console.log(myVehicle.isEngine());       // false
+console.log(myVehicle.isElectric());     // true
+console.log(myVehicle.getEngineCount()); // 0
+console.log()
+
+
+const myNewVehicle = VehicleFactory.getVehicleObject("Lambo-Car");
+
+console.log(myNewVehicle.isEngine());       // false - default value return
+console.log(myNewVehicle.isElectric());     // false - default value return
+console.log(myNewVehicle.getEngineCount()); // 0     - default value return

readme.md

@@ -217,6 +217,7 @@ Understand system design principles and implement design patterns.
   <summary>Behavioral Design Patterns</summary>
 
   - [Chain of Responsibility (Logging System)](./05%20-%20Low%20Level%20Design/03%20-%20TypeScript%20Design%20Pattern/Behavioral%20Design%20Patterns/Chain%20of%20Responsibility/%20Logging%20System/README.md)
+  - [Null Object Pattern (Vehicle System)](./05%20-%20Low%20Level%20Design/03%20-%20TypeScript%20Design%20Pattern/Behavioral%20Design%20Patterns/Null%20Object%20Pattern/Vehicle%20System/README.md)
 </details>
 
 <details>