add: prototype pattern

Author: Winter-Soren

.gitignore

@@ -0,0 +1,3 @@
+out
+*.class
+practice ce

Creational Patterns/Prototype Pattern/Main.java

@@ -0,0 +1,35 @@
+// Prototype interface
+interface Person {
+    Person clone();
+    void display();
+}
+
+// Concrete implementation of Person
+class ConcretePerson implements Person {
+    private String name;
+
+    public ConcretePerson(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public Person clone() {
+        return new ConcretePerson(this.name);
+    }
+
+    @Override
+    public void display() {
+        System.out.println("Hello, I'm " + name);
+    }
+}
+
+// Client code
+public class Main {
+    public static void main(String[] args) {
+        Person originalPerson = new ConcretePerson("ThunderBolt");
+        originalPerson.display();  // Hello, I'm ThunderBolt
+
+        Person clonedPerson = originalPerson.clone();
+        clonedPerson.display();    // Hello, I'm ThunderBolt (cloned)
+    }
+}

Creational Patterns/Prototype Pattern/README.md

@@ -0,0 +1,79 @@
+# Prototype Design Pattern 🧬
+
+<p align="center">
+  <img src="https://refactoring.guru/images/patterns/content/prototype/prototype.png" alt="Prototype Design Pattern Illustration" width="400">
+</p>
+
+The Prototype design pattern allows you to create new objects by copying an existing object's properties. It's like making custom cakes at a bakery—instead of inventing new recipes, you clone a design and customize it according to your preferences.
+
+## 🔧 Key Principles
+
+🧬 **Prototype Interface:** The prototype interface declares a `clone` method for copying objects. Concrete prototypes implement this method.
+
+🧫 **Concrete Prototypes:** Concrete prototype classes implement the `clone` method to create copies of themselves with customized properties.
+
+🔬 **Client:** The client code selects a prototype, clones it, and customizes the clone as needed.
+
+## 🚀 Flow of Prototype Pattern
+
+1. **Create Prototype Interface:** Define a prototype interface with a `clone` method.
+
+2. **Create Concrete Prototypes:** Implement concrete prototype classes by extending the prototype interface. Implement the `clone` method to create a copy and customize properties.
+
+3. **Create Client Code:** In your application, choose a prototype, clone it, and customize the clone.
+
+## 🌟 Pros
+
+🔁 **Flexible Object Creation:** Prototype lets you create customized objects by copying existing ones, avoiding complex constructors.
+
+📖 **Simplified Customization:** Customize cloned objects easily by modifying their properties.
+
+💡 **Minimized Subclasses:** Prototype reduces the need for creating multiple subclasses.
+
+## 🛑 Cons
+
+🔌 **Copying Complexity:** Cloning nested objects might require deep copying to ensure proper duplication.
+
+🗂️ **Clones Management:** Managing multiple clones can be challenging in some scenarios.
+
+## 🎮 Real-World Analogy
+
+Think of a bakery where you make custom cakes. You copy existing cake designs and customize them with different flavors and decorations.
+
+## 💼 Real-World Example
+
+Imagine a graphic design app. Users create shapes with colors and sizes. Instead of creating separate classes for each shape-color-size combination, you use prototypes.
+
+## 🤔 Why Use Prototype?
+
+**Efficient Object Creation:** Prototype is used when creating new objects from scratch is resource-intensive or complex. By copying existing objects, you save time and resources.
+
+## 💡 Problem Solved by Prototype
+
+Imagine you're building a game with multiple characters. Each character has unique properties, and creating new characters from scratch would be cumbersome. Prototype solves this by allowing you to clone a character prototype and customize it for each character, saving development effort.
+
+## 🤔 When to Use
+
+Use the Prototype pattern when you want to:
+
+- Create similar objects with customized properties.
+- Avoid subclass proliferation when dealing with variations.
+- Efficiently create objects without complex constructors.
+
+## 🤓 Interview Questions
+
+1. **What's the main idea behind the Prototype design pattern?**
+   It involves copying existing objects to create new instances with similar properties.
+
+2. **How is Prototype different from Factory?**
+   Prototype focuses on copying, while Factory focuses on creating instances of classes.
+
+3. **What's the significance of the `clone` method?**
+   The `clone` method defines how an object can copy itself.
+
+4. **When would you use Prototype over other patterns?**
+   Prototype is useful when creating similar objects with variations, without resorting to complex constructors or subclasses.
+
+## 🚀 Conclusion
+
+The Prototype pattern simplifies object creation by copying existing ones. It offers flexibility and customization while minimizing the need for complex class structures. By using prototypes as templates, you can create and customize objects effortlessly, making your codebase more efficient and organized.