Design patterns are reusable solutions to common problems in software design. They provide best practices for structuring code to improve flexibility, maintainability, and scalability. Below is an in-depth breakdown of key design patterns with practical implementations.
1. Chain of Responsibility
Passes a request along a chain of handlers until one processes it. Promotes loose coupling.
Example: Logging systems where different loggers handle errors, warnings, and info messages.
Python Implementation:
class Handler:
def <strong>init</strong>(self, successor=None):
self._successor = successor
def handle(self, request):
if self._successor:
self._successor.handle(request)
class ErrorHandler(Handler):
def handle(self, request):
if request == "error":
print("Error logged")
else:
super().handle(request)
class WarningHandler(Handler):
def handle(self, request):
if request == "warning":
print("Warning logged")
else:
super().handle(request)
chain = ErrorHandler(WarningHandler())
chain.handle("warning")
2. Factory Method
Creates objects without specifying the exact class. Useful for runtime flexibility.
Example: GUI frameworks generating different buttons (Windows vs. Mac).
Java Implementation:
interface Button { void render(); }
class WindowsButton implements Button {
public void render() { System.out.println("Windows Button"); }
}
class MacButton implements Button {
public void render() { System.out.println("Mac Button"); }
}
abstract class Dialog {
abstract Button createButton();
void render() { createButton().render(); }
}
class WindowsDialog extends Dialog {
Button createButton() { return new WindowsButton(); }
}
3. Abstract Factory
Creates families of related objects without specifying concrete classes.
Example: Cross-platform UI kits (Windows/Mac).
C++ Implementation:
class Checkbox { public: virtual void paint() = 0; };
class WinCheckbox : public Checkbox {
void paint() { cout << "Windows Checkbox"; }
};
class MacCheckbox : public Checkbox {
void paint() { cout << "Mac Checkbox"; }
};
class GUIFactory {
public:
virtual Checkbox createCheckbox() = 0;
};
class WinFactory : public GUIFactory {
Checkbox createCheckbox() { return new WinCheckbox(); }
};
4. Builder Pattern
Constructs complex objects step-by-step. Ideal for objects with many configurations.
Example: Building a custom computer.
Python Example:
class Computer:
def <strong>init</strong>(self):
self.parts = []
def add(self, part):
self.parts.append(part)
def display(self):
print("Computer Parts:", ", ".join(self.parts))
class Builder:
def build_cpu(self): pass
def build_ram(self): pass
class GamingPCBuilder(Builder):
def <strong>init</strong>(self):
self.computer = Computer()
def build_cpu(self):
self.computer.add("Intel i9")
def build_ram(self):
self.computer.add("32GB DDR5")
5. Prototype Pattern
Clones objects instead of creating new instances. Reduces overhead.
Example: Game character duplication.
JavaScript Implementation:
class Enemy {
constructor(name, health) {
this.name = name;
this.health = health;
}
clone() {
return new Enemy(this.name, this.health);
}
}
const skeleton = new Enemy("Skeleton", 100);
const clonedSkeleton = skeleton.clone();
6. Singleton Pattern
Ensures only one instance exists. Used for logging, configurations.
Python Thread-Safe Singleton:
from threading import Lock class Singleton: _instance = None _lock = Lock() def <strong>new</strong>(cls): if not cls._instance: with cls._lock: if not cls._instance: cls._instance = super().<strong>new</strong>(cls) return cls._instance
7. Command Pattern
Encapsulates a request as an object. Supports undo operations.
Example: Text editor commands (copy, paste).
C Example:
interface ICommand { void Execute(); }
class CopyCommand : ICommand {
public void Execute() { Console.WriteLine("Text Copied"); }
}
class Invoker {
private ICommand _command;
public void SetCommand(ICommand cmd) { _command = cmd; }
public void ExecuteCommand() { _command.Execute(); }
}
8. Iterator Pattern
Traverses collections without exposing internal structure.
Example: Custom list iteration.
Python Example:
class ListIterator: def <strong>init</strong>(self, collection): self._collection = collection self._index = 0 def <strong>next</strong>(self): if self._index < len(self._collection): item = self._collection[self._index] self._index += 1 return item raise StopIteration class CustomList: def <strong>init</strong>(self): self._items = [] def add(self, item): self._items.append(item) def <strong>iter</strong>(self): return ListIterator(self._items)
You Should Know:
- Linux Command for Logging (Chain of Responsibility):
tail -f /var/log/syslog | grep "error"
- Windows PowerShell (Factory Pattern):
$button = New-Object -TypeName System.Windows.Forms.Button
- Git Command (Command Pattern):
git commit -m "Implement Command Pattern"
What Undercode Say:
Design patterns optimize software architecture by providing tested solutions. Mastering them enhances code quality and maintainability. Future trends may see AI-generated pattern implementations, but understanding core principles remains essential.
Expected Output:
A structured guide to design patterns with executable code snippets and real-world applications.
Relevant URLs:
References:
Reported By: Ashsau Design – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
