update the solid principle example

src/solid/dip/main.ts

@@ -0,0 +1,79 @@
+/**
+ * Dependency Inversion Principle:
+ * 1. High-level modules should not depend on low-level modules. 
+ *    Both should depend on interfaces or abstract classes (abstractions).
+ * 2. Interfaces or abstract classes (abstractions) should not depend on concrete implementations (details).
+ *    Concrete implementations should depend on interfaces or abstract classes.
+ */
+
+// Bad: (Violating DIP - Tightly Coupled)
+class CarBad {
+    private petrolEngine: PetrolEngine; // Directly depends on PetrolEngine
+
+    constructor() {
+        this.petrolEngine = new PetrolEngine();
+    }
+
+    start(): void {
+        this.petrolEngine.start();
+    }
+}
+
+class PetrolEngine {
+    start(): void {
+        console.log("Petrol Engine Started")
+    }
+}
+
+const myCarBad = new CarBad()
+myCarBad.start()
+
+/**
+ * Problems:
+ * 1. If we want to create a DieselCar, we have to create a new class (DieselCar) and duplicate a lot of code.
+ * 2. The CarBad class is tightly coupled to PetrolEngine, making it difficult to test and maintain.
+ */
+
+// Good: (Adhering to DIP - Loosely Coupled)
+interface Engine {
+    start(): void;
+}
+
+class PetrolEngineGood implements Engine {
+    start(): void {
+        console.log("Petrol Engine Started");
+    }
+}
+
+class DieselEngineGood implements Engine {
+    start(): void {
+        console.log("Diesel Engine Started");
+    }
+}
+
+class ElectricEngineGood implements Engine {
+    start(): void {
+        console.log("Electric Engine Started")
+    }
+}
+
+class CarGood {
+    private engine: Engine; // Depends on the abstraction (Engine interface)
+
+    constructor(engine: Engine) {
+        this.engine = engine;
+    }
+
+    start(): void {
+        this.engine.start();
+    }
+}
+
+const myPetrolCarGood = new CarGood(new PetrolEngineGood());
+myPetrolCarGood.start();
+
+const myDieselCarGood = new CarGood(new DieselEngineGood());
+myDieselCarGood.start();
+
+const myElectricCarGood = new CarGood(new ElectricEngineGood())
+myElectricCarGood.start()

src/solid/isp/main.ts

@@ -0,0 +1,50 @@
+/**
+ * Interface Segregation Principle (ISP)
+ * 
+ * Tt states that clients should not be forced to depend on methods they do not use. 
+ * In other words, large interfaces should be split into smaller, 
+ * more specific interfaces so that clients only need to know about the methods that are relevant to them.
+ */
+
+// Bad: Vehicle interface forces unrelated methods on some implementations
+interface VehicleActions {
+    drive(): void;
+    fly(): void;
+    sail(): void;
+}
+
+class Car implements VehicleActions {
+    drive() { }
+    fly(): void {
+        throw new Error("Cars cannot fly.");
+    }
+    sail(): void {
+        throw new Error("Cars cannot sail.");
+    }
+}
+
+// Good: Separate interfaces for specific actions
+interface Drivable {
+    drive(): void;
+}
+
+interface Flyable {
+    fly(): void;
+}
+
+interface Sailable {
+    sail(): void;
+}
+
+class CarISP implements Drivable {
+    drive() { }
+}
+
+class AirplaneISP implements Flyable, Drivable {
+    fly() { }
+    drive() { } // Can taxi on the ground
+}
+
+class BoatISP implements Sailable {
+    sail() { }
+}