{"title":"Exercise: Open-Closed Principle","description":null,"content":"Try implementing the below code exercises to reinforce your understanding. Your goal is to implement the classes below so that they produce the expected output.\n\n---\n\n# Exercise 1: ShippingCostCalculator\n\n\n**Problem:** A `ShippingCostCalculator` uses `if-else` to determine the shipping cost based on the shipping type (Standard, Express, Overnight, International). Every time a new shipping type is added, someone has to modify the calculator. Refactor this so that new shipping types can be added without modifying the calculator.\n\n**Requirements:**\n\n- Define a `ShippingStrategy` interface with a `calculateCost(weight)` method\n- Create concrete implementations: `StandardShipping`, `ExpressShipping`, `OvernightShipping`, `InternationalShipping`\n- Refactor `ShippingCostCalculator` to accept a `ShippingStrategy` instead of a string\n- The calculator should delegate cost computation to the strategy\n\n```java\nclass ShippingCostCalculator {\n public double calculate(String shippingType, double weight) {\n if (\"Standard\".equals(shippingType)) {\n return weight * 1.5;\n } else if (\"Express\".equals(shippingType)) {\n return weight * 3.0;\n } else if (\"Overnight\".equals(shippingType)) {\n return weight * 5.0;\n } else if (\"International\".equals(shippingType)) {\n return weight * 10.0;\n }\n throw new IllegalArgumentException(\"Unknown shipping type: \" + shippingType);\n }\n}\n\n// Usage\npublic class Main {\n public static void main(String[] args) {\n ShippingCostCalculator calculator = new ShippingCostCalculator();\n System.out.println(\"Standard: $\" + calculator.calculate(\"Standard\", 2.0));\n System.out.println(\"Express: $\" + calculator.calculate(\"Express\", 2.0));\n }\n}\n\n// TODO: Define a ShippingStrategy interface with a calculateCost(weight) method.\n// TODO: Create concrete implementations for each shipping type.\n// TODO: Refactor ShippingCostCalculator to accept a ShippingStrategy.\n```\n\n```python\nclass ShippingCostCalculator:\n def calculate(self, shipping_type: str, weight: float) -> float:\n if shipping_type == \"Standard\":\n return weight * 1.5\n elif shipping_type == \"Express\":\n return weight * 3.0\n elif shipping_type == \"Overnight\":\n return weight * 5.0\n elif shipping_type == \"International\":\n return weight * 10.0\n raise ValueError(f\"Unknown shipping type: {shipping_type}\")\n\n# Usage\ncalculator = ShippingCostCalculator()\nprint(f\"Standard: ${calculator.calculate('Standard', 2.0)}\")\nprint(f\"Express: ${calculator.calculate('Express', 2.0)}\")\n\n# TODO: Define a ShippingStrategy interface (ABC) with a calculate_cost(weight) method.\n# TODO: Create concrete implementations for each shipping type.\n# TODO: Refactor ShippingCostCalculator to accept a ShippingStrategy.\n```\n\n```cpp\n#include \n#include \n#include \n\nusing namespace std;\n\nclass ShippingCostCalculator {\npublic:\n double calculate(const string& shippingType, double weight) {\n if (shippingType == \"Standard\") {\n return weight * 1.5;\n } else if (shippingType == \"Express\") {\n return weight * 3.0;\n } else if (shippingType == \"Overnight\") {\n return weight * 5.0;\n } else if (shippingType == \"International\") {\n return weight * 10.0;\n }\n throw invalid_argument(\"Unknown shipping type: \" + shippingType);\n }\n};\n\nint main() {\n ShippingCostCalculator calculator;\n cout << \"Standard: $\" << calculator.calculate(\"Standard\", 2.0) << endl;\n cout << \"Express: $\" << calculator.calculate(\"Express\", 2.0) << endl;\n return 0;\n}\n\n// TODO: Define a ShippingStrategy interface with a calculateCost(weight) method.\n// TODO: Create concrete implementations for each shipping type.\n// TODO: Refactor ShippingCostCalculator to accept a ShippingStrategy.\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\ntype ShippingCostCalculator struct {\n}\n\nfunc (s *ShippingCostCalculator) Calculate(shippingType string, weight float64) float64 {\n\t// TODO: implement\n\treturn 0\n}\n\n// Usage\nfunc main() {\n\tcalculator := &ShippingCostCalculator{}\n\tfmt.Printf(\"Standard: $%v\\n\", calculator.Calculate(\"Standard\", 2.0))\n\tfmt.Printf(\"Express: $%v\\n\", calculator.Calculate(\"Express\", 2.0))\n}\n\n// TODO: Define a ShippingStrategy interface with a CalculateCost(weight) method.\n// TODO: Create concrete implementations for each shipping type.\n// TODO: Refactor ShippingCostCalculator to accept a ShippingStrategy.\n```\n\n```csharp\nusing System;\n\nclass ShippingCostCalculator\n{\n public double Calculate(string shippingType, double weight)\n {\n if (shippingType == \"Standard\")\n return weight * 1.5;\n else if (shippingType == \"Express\")\n return weight * 3.0;\n else if (shippingType == \"Overnight\")\n return weight * 5.0;\n else if (shippingType == \"International\")\n return weight * 10.0;\n throw new ArgumentException($\"Unknown shipping type: {shippingType}\");\n }\n}\n\n// Usage\nclass Program\n{\n static void Main()\n {\n var calculator = new ShippingCostCalculator();\n Console.WriteLine($\"Standard: ${calculator.Calculate(\"Standard\", 2.0)}\");\n Console.WriteLine($\"Express: ${calculator.Calculate(\"Express\", 2.0)}\");\n }\n}\n\n// TODO: Define an IShippingStrategy interface with a CalculateCost(weight) method.\n// TODO: Create concrete implementations for each shipping type.\n// TODO: Refactor ShippingCostCalculator to accept an IShippingStrategy.\n```\n\n```typescript\nclass ShippingCostCalculator {\n calculate(shippingType: string, weight: number): number {\n if (shippingType === \"Standard\") {\n return weight * 1.5;\n } else if (shippingType === \"Express\") {\n return weight * 3.0;\n } else if (shippingType === \"Overnight\") {\n return weight * 5.0;\n } else if (shippingType === \"International\") {\n return weight * 10.0;\n }\n throw new Error(`Unknown shipping type: ${shippingType}`);\n }\n}\n\n// Usage\nconst calculator = new ShippingCostCalculator();\nconsole.log(`Standard: $${calculator.calculate(\"Standard\", 2.0)}`);\nconsole.log(`Express: $${calculator.calculate(\"Express\", 2.0)}`);\n\n// TODO: Define a ShippingStrategy interface with a calculateCost(weight) method.\n// TODO: Create concrete implementations for each shipping type.\n// TODO: Refactor ShippingCostCalculator to accept a ShippingStrategy.\n```\n\n#### Solutions\n\n```java\n// ShippingStrategy interface\ninterface ShippingStrategy {\n double calculateCost(double weight);\n}\n\n// Concrete strategies\nclass StandardShipping implements ShippingStrategy {\n @Override\n public double calculateCost(double weight) {\n return weight * 1.5;\n }\n}\n\nclass ExpressShipping implements ShippingStrategy {\n @Override\n public double calculateCost(double weight) {\n return weight * 3.0;\n }\n}\n\nclass OvernightShipping implements ShippingStrategy {\n @Override\n public double calculateCost(double weight) {\n return weight * 5.0;\n }\n}\n\nclass InternationalShipping implements ShippingStrategy {\n @Override\n public double calculateCost(double weight) {\n return weight * 10.0;\n }\n}\n\n// Refactored calculator - no if-else\nclass ShippingCostCalculator {\n private final ShippingStrategy strategy;\n\n public ShippingCostCalculator(ShippingStrategy strategy) {\n this.strategy = strategy;\n }\n\n public double calculate(double weight) {\n return strategy.calculateCost(weight);\n }\n}\n\n// Main\npublic class Main {\n public static void main(String[] args) {\n double weight = 2.0;\n\n ShippingCostCalculator standard = new ShippingCostCalculator(new StandardShipping());\n ShippingCostCalculator express = new ShippingCostCalculator(new ExpressShipping());\n ShippingCostCalculator overnight = new ShippingCostCalculator(new OvernightShipping());\n ShippingCostCalculator international = new ShippingCostCalculator(new InternationalShipping());\n\n System.out.println(\"Standard: $\" + standard.calculate(weight));\n System.out.println(\"Express: $\" + express.calculate(weight));\n System.out.println(\"Overnight: $\" + overnight.calculate(weight));\n System.out.println(\"International: $\" + international.calculate(weight));\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\n# ShippingStrategy interface\nclass ShippingStrategy(ABC):\n @abstractmethod\n def calculate_cost(self, weight: float) -> float:\n pass\n\n# Concrete strategies\nclass StandardShipping(ShippingStrategy):\n def calculate_cost(self, weight: float) -> float:\n return weight * 1.5\n\nclass ExpressShipping(ShippingStrategy):\n def calculate_cost(self, weight: float) -> float:\n return weight * 3.0\n\nclass OvernightShipping(ShippingStrategy):\n def calculate_cost(self, weight: float) -> float:\n return weight * 5.0\n\nclass InternationalShipping(ShippingStrategy):\n def calculate_cost(self, weight: float) -> float:\n return weight * 10.0\n\n# Refactored calculator - no if-else\nclass ShippingCostCalculator:\n def __init__(self, strategy: ShippingStrategy):\n self.strategy = strategy\n\n def calculate(self, weight: float) -> float:\n return self.strategy.calculate_cost(weight)\n\n# Main\nif __name__ == \"__main__\":\n weight = 2.0\n\n standard = ShippingCostCalculator(StandardShipping())\n express = ShippingCostCalculator(ExpressShipping())\n overnight = ShippingCostCalculator(OvernightShipping())\n international = ShippingCostCalculator(InternationalShipping())\n\n print(f\"Standard: ${standard.calculate(weight)}\")\n print(f\"Express: ${express.calculate(weight)}\")\n print(f\"Overnight: ${overnight.calculate(weight)}\")\n print(f\"International: ${international.calculate(weight)}\")\n```\n\n```cpp\n#include \n#include \n#include \nusing namespace std;\n\n// ShippingStrategy interface\nclass ShippingStrategy {\npublic:\n virtual ~ShippingStrategy() = default;\n virtual double calculateCost(double weight) const = 0;\n};\n\n// Concrete strategies\nclass StandardShipping : public ShippingStrategy {\npublic:\n double calculateCost(double weight) const override {\n return weight * 1.5;\n }\n};\n\nclass ExpressShipping : public ShippingStrategy {\npublic:\n double calculateCost(double weight) const override {\n return weight * 3.0;\n }\n};\n\nclass OvernightShipping : public ShippingStrategy {\npublic:\n double calculateCost(double weight) const override {\n return weight * 5.0;\n }\n};\n\nclass InternationalShipping : public ShippingStrategy {\npublic:\n double calculateCost(double weight) const override {\n return weight * 10.0;\n }\n};\n\n// Refactored calculator - no if-else\nclass ShippingCostCalculator {\nprivate:\n unique_ptr strategy;\npublic:\n ShippingCostCalculator(unique_ptr strategy)\n : strategy(move(strategy)) {}\n\n double calculate(double weight) const {\n return strategy->calculateCost(weight);\n }\n};\n\nint main() {\n double weight = 2.0;\n\n ShippingCostCalculator standard(make_unique());\n ShippingCostCalculator express(make_unique());\n ShippingCostCalculator overnight(make_unique());\n ShippingCostCalculator international(make_unique());\n\n cout << fixed << setprecision(1);\n cout << \"Standard: $\" << standard.calculate(weight) << endl;\n cout << \"Express: $\" << express.calculate(weight) << endl;\n cout << \"Overnight: $\" << overnight.calculate(weight) << endl;\n cout << \"International: $\" << international.calculate(weight) << endl;\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\n// ShippingStrategy interface\ntype ShippingStrategy interface {\n\tCalculateCost(weight float64) float64\n}\n\n// Concrete strategies\ntype StandardShipping struct{}\n\nfunc (s StandardShipping) CalculateCost(weight float64) float64 {\n\treturn weight * 1.5\n}\n\ntype ExpressShipping struct{}\n\nfunc (s ExpressShipping) CalculateCost(weight float64) float64 {\n\treturn weight * 3.0\n}\n\ntype OvernightShipping struct{}\n\nfunc (s OvernightShipping) CalculateCost(weight float64) float64 {\n\treturn weight * 5.0\n}\n\ntype InternationalShipping struct{}\n\nfunc (s InternationalShipping) CalculateCost(weight float64) float64 {\n\treturn weight * 10.0\n}\n\n// Refactored calculator - no if-else\ntype ShippingCostCalculator struct {\n\tstrategy ShippingStrategy\n}\n\nfunc NewShippingCostCalculator(strategy ShippingStrategy) *ShippingCostCalculator {\n\treturn &ShippingCostCalculator{strategy: strategy}\n}\n\nfunc (c *ShippingCostCalculator) Calculate(weight float64) float64 {\n\treturn c.strategy.CalculateCost(weight)\n}\n\n// Main\nfunc main() {\n\tweight := 2.0\n\n\tstandard := NewShippingCostCalculator(StandardShipping{})\n\texpress := NewShippingCostCalculator(ExpressShipping{})\n\tovernight := NewShippingCostCalculator(OvernightShipping{})\n\tinternational := NewShippingCostCalculator(InternationalShipping{})\n\n\tfmt.Printf(\"Standard: $%.1f\\n\", standard.Calculate(weight))\n\tfmt.Printf(\"Express: $%.1f\\n\", express.Calculate(weight))\n\tfmt.Printf(\"Overnight: $%.1f\\n\", overnight.Calculate(weight))\n\tfmt.Printf(\"International: $%.1f\\n\", international.Calculate(weight))\n}\n```\n\n```csharp\nusing System;\n\n// ShippingStrategy interface\ninterface IShippingStrategy\n{\n double CalculateCost(double weight);\n}\n\n// Concrete strategies\nclass StandardShipping : IShippingStrategy\n{\n public double CalculateCost(double weight) => weight * 1.5;\n}\n\nclass ExpressShipping : IShippingStrategy\n{\n public double CalculateCost(double weight) => weight * 3.0;\n}\n\nclass OvernightShipping : IShippingStrategy\n{\n public double CalculateCost(double weight) => weight * 5.0;\n}\n\nclass InternationalShipping : IShippingStrategy\n{\n public double CalculateCost(double weight) => weight * 10.0;\n}\n\n// Refactored calculator - no if-else\nclass ShippingCostCalculator\n{\n private readonly IShippingStrategy _strategy;\n\n public ShippingCostCalculator(IShippingStrategy strategy)\n {\n _strategy = strategy;\n }\n\n public double Calculate(double weight)\n {\n return _strategy.CalculateCost(weight);\n }\n}\n\nclass Program\n{\n static void Main()\n {\n double weight = 2.0;\n\n var standard = new ShippingCostCalculator(new StandardShipping());\n var express = new ShippingCostCalculator(new ExpressShipping());\n var overnight = new ShippingCostCalculator(new OvernightShipping());\n var international = new ShippingCostCalculator(new InternationalShipping());\n\n Console.WriteLine($\"Standard: ${standard.Calculate(weight):F1}\");\n Console.WriteLine($\"Express: ${express.Calculate(weight):F1}\");\n Console.WriteLine($\"Overnight: ${overnight.Calculate(weight):F1}\");\n Console.WriteLine($\"International: ${international.Calculate(weight):F1}\");\n }\n}\n```\n\n```typescript\n// ShippingStrategy interface\ninterface ShippingStrategy {\n calculateCost(weight: number): number;\n}\n\n// Concrete strategies\nclass StandardShipping implements ShippingStrategy {\n calculateCost(weight: number): number {\n return weight * 1.5;\n }\n}\n\nclass ExpressShipping implements ShippingStrategy {\n calculateCost(weight: number): number {\n return weight * 3.0;\n }\n}\n\nclass OvernightShipping implements ShippingStrategy {\n calculateCost(weight: number): number {\n return weight * 5.0;\n }\n}\n\nclass InternationalShipping implements ShippingStrategy {\n calculateCost(weight: number): number {\n return weight * 10.0;\n }\n}\n\n// Refactored calculator - no if-else\nclass ShippingCostCalculator {\n private strategy: ShippingStrategy;\n\n constructor(strategy: ShippingStrategy) {\n this.strategy = strategy;\n }\n\n calculate(weight: number): number {\n return this.strategy.calculateCost(weight);\n }\n}\n\n// Main\nconst weight = 2.0;\n\nconst standard = new ShippingCostCalculator(new StandardShipping());\nconst express = new ShippingCostCalculator(new ExpressShipping());\nconst overnight = new ShippingCostCalculator(new OvernightShipping());\nconst international = new ShippingCostCalculator(new InternationalShipping());\n\nconsole.log(`Standard: $${standard.calculate(weight).toFixed(1)}`);\nconsole.log(`Express: $${express.calculate(weight).toFixed(1)}`);\nconsole.log(`Overnight: $${overnight.calculate(weight).toFixed(1)}`);\nconsole.log(`International: $${international.calculate(weight).toFixed(1)}`);\n```\n\n\n---\n\n# Exercise 2: NotificationService\n\n\n**Problem:** A `NotificationService` has hardcoded notification channels (Email and SMS). Every time the business wants to add a new channel (Push, Slack, WhatsApp), the service must be modified. Refactor it to make it extensible so that new channels can be added without modifying existing code.\n\n**Requirements:**\n\n- Define a `NotificationChannel` interface with a `send(message)` method\n- Create concrete implementations: `EmailChannel`, `SMSChannel`, `PushChannel`, `SlackChannel`\n- Refactor `NotificationService` to accept one or more `NotificationChannel` instances\n- The service should delegate sending to the channel without knowing its type\n\n```java\nclass NotificationService {\n public void sendNotification(String channel, String message) {\n if (\"Email\".equals(channel)) {\n System.out.println(\"Sending EMAIL: \" + message);\n // Email-specific logic (SMTP, templates, etc.)\n } else if (\"SMS\".equals(channel)) {\n System.out.println(\"Sending SMS: \" + message);\n // SMS-specific logic (Twilio, carrier API, etc.)\n } else {\n throw new IllegalArgumentException(\"Unknown channel: \" + channel);\n }\n }\n}\n\n// Usage\npublic class Main {\n public static void main(String[] args) {\n NotificationService service = new NotificationService();\n service.sendNotification(\"Email\", \"Your order has shipped!\");\n service.sendNotification(\"SMS\", \"Your order has shipped!\");\n }\n}\n\n// TODO: Define a NotificationChannel interface with a send(message) method.\n// TODO: Create EmailChannel, SMSChannel, PushChannel, and SlackChannel.\n// TODO: Refactor NotificationService to accept a NotificationChannel.\n```\n\n```python\nclass NotificationService:\n def send_notification(self, channel: str, message: str) -> None:\n if channel == \"Email\":\n print(f\"Sending EMAIL: {message}\")\n # Email-specific logic (SMTP, templates, etc.)\n elif channel == \"SMS\":\n print(f\"Sending SMS: {message}\")\n # SMS-specific logic (Twilio, carrier API, etc.)\n else:\n raise ValueError(f\"Unknown channel: {channel}\")\n\n# Usage\nservice = NotificationService()\nservice.send_notification(\"Email\", \"Your order has shipped!\")\nservice.send_notification(\"SMS\", \"Your order has shipped!\")\n\n# TODO: Define a NotificationChannel interface (ABC) with a send(message) method.\n# TODO: Create EmailChannel, SMSChannel, PushChannel, and SlackChannel.\n# TODO: Refactor NotificationService to accept a NotificationChannel.\n```\n\n```cpp\n#include \n#include \n#include \n\nusing namespace std;\n\nclass NotificationService {\npublic:\n void sendNotification(const string& channel, const string& message) {\n if (channel == \"Email\") {\n cout << \"Sending EMAIL: \" << message << endl;\n // Email-specific logic\n } else if (channel == \"SMS\") {\n cout << \"Sending SMS: \" << message << endl;\n // SMS-specific logic\n } else {\n throw invalid_argument(\"Unknown channel: \" + channel);\n }\n }\n};\n\nint main() {\n NotificationService service;\n service.sendNotification(\"Email\", \"Your order has shipped!\");\n service.sendNotification(\"SMS\", \"Your order has shipped!\");\n return 0;\n}\n\n// TODO: Define a NotificationChannel interface with a send(message) method.\n// TODO: Create EmailChannel, SMSChannel, PushChannel, and SlackChannel.\n// TODO: Refactor NotificationService to accept a NotificationChannel.\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\ntype NotificationService struct {\n}\n\nfunc (ns *NotificationService) SendNotification(channel string, message string) {\n\tif channel == \"Email\" {\n\t\tfmt.Println(\"Sending EMAIL:\", message)\n\t\t// Email-specific logic (SMTP, templates, etc.)\n\t} else if channel == \"SMS\" {\n\t\tfmt.Println(\"Sending SMS:\", message)\n\t\t// SMS-specific logic (Twilio, carrier API, etc.)\n\t} else {\n\t\tpanic(fmt.Sprintf(\"Unknown channel: %s\", channel))\n\t}\n}\n\nfunc main() {\n\tservice := &NotificationService{}\n\tservice.SendNotification(\"Email\", \"Your order has shipped!\")\n\tservice.SendNotification(\"SMS\", \"Your order has shipped!\")\n}\n\n// TODO: Define a NotificationChannel interface with a send(message) method.\n// TODO: Create EmailChannel, SMSChannel, PushChannel, and SlackChannel.\n// TODO: Refactor NotificationService to accept a NotificationChannel.\n```\n\n```csharp\nusing System;\n\nclass NotificationService\n{\n public void SendNotification(string channel, string message)\n {\n if (channel == \"Email\")\n {\n Console.WriteLine($\"Sending EMAIL: {message}\");\n // Email-specific logic\n }\n else if (channel == \"SMS\")\n {\n Console.WriteLine($\"Sending SMS: {message}\");\n // SMS-specific logic\n }\n else\n {\n throw new ArgumentException($\"Unknown channel: {channel}\");\n }\n }\n}\n\nclass Program\n{\n static void Main()\n {\n var service = new NotificationService();\n service.SendNotification(\"Email\", \"Your order has shipped!\");\n service.SendNotification(\"SMS\", \"Your order has shipped!\");\n }\n}\n\n// TODO: Define an INotificationChannel interface with a Send(message) method.\n// TODO: Create EmailChannel, SMSChannel, PushChannel, and SlackChannel.\n// TODO: Refactor NotificationService to accept an INotificationChannel.\n```\n\n```typescript\nclass NotificationService {\n sendNotification(channel: string, message: string): void {\n if (channel === \"Email\") {\n console.log(`Sending EMAIL: ${message}`);\n // Email-specific logic (SMTP, templates, etc.)\n } else if (channel === \"SMS\") {\n console.log(`Sending SMS: ${message}`);\n // SMS-specific logic (Twilio, carrier API, etc.)\n } else {\n throw new Error(`Unknown channel: ${channel}`);\n }\n }\n}\n\n// Usage\nconst service = new NotificationService();\nservice.sendNotification(\"Email\", \"Your order has shipped!\");\nservice.sendNotification(\"SMS\", \"Your order has shipped!\");\n\n// TODO: Define a NotificationChannel interface with a send(message) method.\n// TODO: Create EmailChannel, SMSChannel, PushChannel, and SlackChannel.\n// TODO: Refactor NotificationService to accept a NotificationChannel.\n```\n\n#### Solutions\n\n```java\nimport java.util.List;\n\n// NotificationChannel interface\ninterface NotificationChannel {\n void send(String message);\n}\n\n// Concrete channels\nclass EmailChannel implements NotificationChannel {\n @Override\n public void send(String message) {\n System.out.println(\"Sending EMAIL: \" + message);\n }\n}\n\nclass SMSChannel implements NotificationChannel {\n @Override\n public void send(String message) {\n System.out.println(\"Sending SMS: \" + message);\n }\n}\n\nclass PushChannel implements NotificationChannel {\n @Override\n public void send(String message) {\n System.out.println(\"Sending PUSH: \" + message);\n }\n}\n\nclass SlackChannel implements NotificationChannel {\n @Override\n public void send(String message) {\n System.out.println(\"Sending SLACK: \" + message);\n }\n}\n\n// Refactored service - no if-else\nclass NotificationService {\n private final List channels;\n\n public NotificationService(List channels) {\n this.channels = channels;\n }\n\n public void sendNotification(String message) {\n for (NotificationChannel channel : channels) {\n channel.send(message);\n }\n }\n}\n\n// Main\npublic class Main {\n public static void main(String[] args) {\n List channels = List.of(\n new EmailChannel(),\n new SMSChannel(),\n new PushChannel(),\n new SlackChannel()\n );\n\n NotificationService service = new NotificationService(channels);\n service.sendNotification(\"Your order has shipped!\");\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\n# NotificationChannel interface\nclass NotificationChannel(ABC):\n @abstractmethod\n def send(self, message: str) -> None:\n pass\n\n# Concrete channels\nclass EmailChannel(NotificationChannel):\n def send(self, message: str) -> None:\n print(f\"Sending EMAIL: {message}\")\n\nclass SMSChannel(NotificationChannel):\n def send(self, message: str) -> None:\n print(f\"Sending SMS: {message}\")\n\nclass PushChannel(NotificationChannel):\n def send(self, message: str) -> None:\n print(f\"Sending PUSH: {message}\")\n\nclass SlackChannel(NotificationChannel):\n def send(self, message: str) -> None:\n print(f\"Sending SLACK: {message}\")\n\n# Refactored service - no if-else\nclass NotificationService:\n def __init__(self, channels: list[NotificationChannel]):\n self.channels = channels\n\n def send_notification(self, message: str) -> None:\n for channel in self.channels:\n channel.send(message)\n\n# Main\nif __name__ == \"__main__\":\n channels = [\n EmailChannel(),\n SMSChannel(),\n PushChannel(),\n SlackChannel(),\n ]\n\n service = NotificationService(channels)\n service.send_notification(\"Your order has shipped!\")\n```\n\n```cpp\n#include \n#include \n#include \n#include \nusing namespace std;\n\n// NotificationChannel interface\nclass NotificationChannel {\npublic:\n virtual ~NotificationChannel() = default;\n virtual void send(const string& message) const = 0;\n};\n\n// Concrete channels\nclass EmailChannel : public NotificationChannel {\npublic:\n void send(const string& message) const override {\n cout << \"Sending EMAIL: \" << message << endl;\n }\n};\n\nclass SMSChannel : public NotificationChannel {\npublic:\n void send(const string& message) const override {\n cout << \"Sending SMS: \" << message << endl;\n }\n};\n\nclass PushChannel : public NotificationChannel {\npublic:\n void send(const string& message) const override {\n cout << \"Sending PUSH: \" << message << endl;\n }\n};\n\nclass SlackChannel : public NotificationChannel {\npublic:\n void send(const string& message) const override {\n cout << \"Sending SLACK: \" << message << endl;\n }\n};\n\n// Refactored service - no if-else\nclass NotificationService {\nprivate:\n vector> channels;\npublic:\n NotificationService(vector> channels)\n : channels(move(channels)) {}\n\n void sendNotification(const string& message) const {\n for (const auto& channel : channels) {\n channel->send(message);\n }\n }\n};\n\nint main() {\n vector> channels;\n channels.push_back(make_unique());\n channels.push_back(make_unique());\n channels.push_back(make_unique());\n channels.push_back(make_unique());\n\n NotificationService service(move(channels));\n service.sendNotification(\"Your order has shipped!\");\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\n// NotificationChannel interface\ntype NotificationChannel interface {\n\tSend(message string)\n}\n\n// Concrete channels\ntype EmailChannel struct{}\n\nfunc (e *EmailChannel) Send(message string) {\n\tfmt.Println(\"Sending EMAIL: \" + message)\n}\n\ntype SMSChannel struct{}\n\nfunc (s *SMSChannel) Send(message string) {\n\tfmt.Println(\"Sending SMS: \" + message)\n}\n\ntype PushChannel struct{}\n\nfunc (p *PushChannel) Send(message string) {\n\tfmt.Println(\"Sending PUSH: \" + message)\n}\n\ntype SlackChannel struct{}\n\nfunc (s *SlackChannel) Send(message string) {\n\tfmt.Println(\"Sending SLACK: \" + message)\n}\n\n// Refactored service - no if-else\ntype NotificationService struct {\n\tchannels []NotificationChannel\n}\n\nfunc NewNotificationService(channels []NotificationChannel) *NotificationService {\n\treturn &NotificationService{channels: channels}\n}\n\nfunc (ns *NotificationService) SendNotification(message string) {\n\tfor _, channel := range ns.channels {\n\t\tchannel.Send(message)\n\t}\n}\n\nfunc main() {\n\tchannels := []NotificationChannel{\n\t\t&EmailChannel{},\n\t\t&SMSChannel{},\n\t\t&PushChannel{},\n\t\t&SlackChannel{},\n\t}\n\n\tservice := NewNotificationService(channels)\n\tservice.SendNotification(\"Your order has shipped!\")\n}\n```\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\n// NotificationChannel interface\ninterface INotificationChannel\n{\n void Send(string message);\n}\n\n// Concrete channels\nclass EmailChannel : INotificationChannel\n{\n public void Send(string message)\n {\n Console.WriteLine($\"Sending EMAIL: {message}\");\n }\n}\n\nclass SMSChannel : INotificationChannel\n{\n public void Send(string message)\n {\n Console.WriteLine($\"Sending SMS: {message}\");\n }\n}\n\nclass PushChannel : INotificationChannel\n{\n public void Send(string message)\n {\n Console.WriteLine($\"Sending PUSH: {message}\");\n }\n}\n\nclass SlackChannel : INotificationChannel\n{\n public void Send(string message)\n {\n Console.WriteLine($\"Sending SLACK: {message}\");\n }\n}\n\n// Refactored service - no if-else\nclass NotificationService\n{\n private readonly List _channels;\n\n public NotificationService(List channels)\n {\n _channels = channels;\n }\n\n public void SendNotification(string message)\n {\n foreach (var channel in _channels)\n {\n channel.Send(message);\n }\n }\n}\n\nclass Program\n{\n static void Main()\n {\n var channels = new List\n {\n new EmailChannel(),\n new SMSChannel(),\n new PushChannel(),\n new SlackChannel()\n };\n\n var service = new NotificationService(channels);\n service.SendNotification(\"Your order has shipped!\");\n }\n}\n```\n\n```typescript\n// NotificationChannel interface\ninterface NotificationChannel {\n send(message: string): void;\n}\n\n// Concrete channels\nclass EmailChannel implements NotificationChannel {\n send(message: string): void {\n console.log(`Sending EMAIL: ${message}`);\n }\n}\n\nclass SMSChannel implements NotificationChannel {\n send(message: string): void {\n console.log(`Sending SMS: ${message}`);\n }\n}\n\nclass PushChannel implements NotificationChannel {\n send(message: string): void {\n console.log(`Sending PUSH: ${message}`);\n }\n}\n\nclass SlackChannel implements NotificationChannel {\n send(message: string): void {\n console.log(`Sending SLACK: ${message}`);\n }\n}\n\n// Refactored service - no if-else\nclass NotificationService {\n private channels: NotificationChannel[];\n\n constructor(channels: NotificationChannel[]) {\n this.channels = channels;\n }\n\n sendNotification(message: string): void {\n for (const channel of this.channels) {\n channel.send(message);\n }\n }\n}\n\n// Main\nconst channels: NotificationChannel[] = [\n new EmailChannel(),\n new SMSChannel(),\n new PushChannel(),\n new SlackChannel(),\n];\n\nconst service = new NotificationService(channels);\nservice.sendNotification(\"Your order has shipped!\");\n```\n","pageType":"lld-interviews"}

Exercise 1: ShippingCostCalculator

Exercise 2: NotificationService

Get Premium