added decorator pattern

Author: maniebra

.obsidian/workspace.json

@@ -27,12 +27,12 @@
             "state": {
               "type": "markdown",
               "state": {
-                "file": "README.md",
+                "file": "Design Patterns/Decorator Pattern.md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "README"
+              "title": "Decorator Pattern"
             }
           }
         ],
@@ -199,8 +199,8 @@
     "Design Patterns/Design Principles.md",
     "Design Patterns/Decorator Pattern.md",
     "Design Patterns/Observer Pattern.md",
-    "System Design/0. Introduction/0.1 Systems Development Life Cycle (SDLC).md",
     "README.md",
+    "System Design/0. Introduction/0.1 Systems Development Life Cycle (SDLC).md",
     "LICENSE",
     "System.md",
     "System Design.md",

Design Patterns/Decorator Pattern.md

@@ -1 +1,106 @@
 
+# Definition
+
+## The "formal" definition
+
+> The Decorator Pattern attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub-classing for extending functionality.
+
+
+
+# How does it work
+
+```java
+// Coffee.java
+public interface Coffee {
+    String getDescription();
+    double getCost();
+}
+
+// PlainCoffee.java
+public class PlainCoffee implements Coffee {
+    @Override
+    public String getDescription() {
+        return "Plain Coffee";
+    }
+
+    @Override
+    public double getCost() {
+        return 2.0;
+    }
+}
+
+// CoffeeDecorator.java
+public abstract class CoffeeDecorator implements Coffee {
+    protected Coffee decoratedCoffee;
+
+    public CoffeeDecorator(Coffee decoratedCoffee) {
+        this.decoratedCoffee = decoratedCoffee;
+    }
+
+    @Override
+    public String getDescription() {
+        return decoratedCoffee.getDescription();
+    }
+
+    @Override
+    public double getCost() {
+        return decoratedCoffee.getCost();
+    }
+}
+
+// MilkDecorator.java
+public class MilkDecorator extends CoffeeDecorator {
+    public MilkDecorator(Coffee decoratedCoffee) {
+        super(decoratedCoffee);
+    }
+
+    @Override
+    public String getDescription() {
+        return decoratedCoffee.getDescription() + ", Milk";
+    }
+
+    @Override
+    public double getCost() {
+        return decoratedCoffee.getCost() + 0.5;
+    }
+}
+
+// SugarDecorator.java
+public class SugarDecorator extends CoffeeDecorator {
+    public SugarDecorator(Coffee decoratedCoffee) {
+        super(decoratedCoffee);
+    }
+
+    @Override
+    public String getDescription() {
+        return decoratedCoffee.getDescription() + ", Sugar";
+    }
+
+    @Override
+    public double getCost() {
+        return decoratedCoffee.getCost() + 0.2;
+    }
+}
+
+// Main.java
+public class Main {
+    public static void main(String[] args) {
+        // Plain Coffee
+        Coffee coffee = new PlainCoffee();
+        System.out.println("Description: " + coffee.getDescription());
+        System.out.println("Cost: $" + coffee.getCost());
+
+        // Coffee with Milk
+        Coffee milkCoffee = new MilkDecorator(new PlainCoffee());
+        System.out.println("\nDescription: " + milkCoffee.getDescription());
+        System.out.println("Cost: $" + milkCoffee.getCost());
+
+        // Coffee with Sugar and Milk
+        Coffee sugarMilkCoffee = new SugarDecorator(new MilkDecorator(new PlainCoffee()));
+        System.out.println("\nDescription: " + sugarMilkCoffee.getDescription());
+        System.out.println("Cost: $" + sugarMilkCoffee.getCost());
+    }
+}
+```
+
+As you can see, for each additional property that can be in a cup of coffee, we create a decorator class. This decorator class can alter other attributes of the main object (like `cost` and `description`). Using this pattern will able us to create extensions and removes the need to alter the original class.

Design Patterns/Design Principles.md

@@ -1,5 +1,6 @@
 
 1. Identify the aspects of your app that vary and separate them from what stays the same.
-2. Program to an interface, not an implementation.
-3. Classes should be open for extensions, but closed for modifications.
-	1. 
+2. Favor composition over inheritance.
+3. Program to an interface, not an implementation.
+4. Loosely coupled designs allow us to build flexible object oriented systems that can handle change because they minimize the inter-dependency between objects.
+5. Classes should be open for extensions, but closed for modifications.