website·Indexed 29 days ago
https://system-design-lac.vercel.appA comprehensive guide to software design principles and patterns, featuring detailed explanations and examples of SOLID principles, creational, structural, and behavioral design patterns implemented in Java and TypeScript.
Creational design patterns provide mechanisms to create objects in a manner suitable for a given situation. Their primary goal is to decouple client code from the specific classes or objects being instantiated, thereby increasing flexibility and reusability in software development. Common creational patterns include:
| Category | Template Method | Polymorphism |
|---|---|---|
| Purpose | Defines algorithm structure; subclasses provide specific step implementations. | Treats different classes as a common superclass/interface for different behavior. |
| Design Level | High-level design pattern for organizing algorithms. | Fundamental OOP concept focusing on object behavior. |
| Abstraction | Higher level | Lower level |
| Implementation | Abstract or virtual methods | Inheritance or interfaces |
The State pattern allows an object to alter its behavior when its internal state changes, making it appear as if the object changed its class. This is particularly useful when an object's behavior depends on its internal state and needs to change dynamically at runtime without using complex conditional statements.
Key components of the pattern:
The Observer pattern is a behavioral design pattern used to define a subscription mechanism to notify multiple objects (observers) about events happening to the object they are observing (the subject). It establishes a one-to-many dependency so that when the subject's state changes, all registered dependents are notified and updated automatically. This is also known as the Publisher-Subscriber model.
Key characteristics:
The Command pattern is a behavioral design pattern that encapsulates a request as a stand-alone object. This decoupling allows for parameterizing clients with different requests, queuing or logging requests, and supporting undoable operations. It is particularly useful in multithreaded environments.
executeCommand()).The Mediator pattern is a behavioral design pattern used to reduce chaotic dependencies between objects by restricting direct communication. Instead of objects referring to each other explicitly, they collaborate only via a mediator object, promoting loose coupling and allowing interaction logic to vary independently.
new operator manually. Instead, a factory method (typically called create) abstracts the instantiation logic and returns an object conforming to a common interface.public class Car {
private Engine engine;
public Car() {
// The Engine is created inside the Car, coupling their lifecycles
engine = new Engine();
}
}The Prototype Pattern is used to create new objects by copying an existing prototypical instance. This avoids the overhead of manual object creation and property assignment, especially when objects need to be cloned at runtime or when the new operator is too expensive.
Key implementation steps:
Prototype interface that declares a clone() method.clone() method to produce identical copies of an object, then modify specific properties as needed.interface Prototype {
clone(): Prototype;
}
class Soldier implements Prototype {
constructor(public weapon: string, public rank: string) {}
clone(): Prototype {
return new Soldier(this.weapon, this.rank);
}
}
// Usage
const basicSoldier = new Soldier('Rifle', 'Private');
const clonedSoldier = basicSoldier.clone() as Soldier;
clonedSoldier.rank = 'Sergeant'; // Modify properties after cloningThe Composite pattern is a structural design pattern used to compose objects into tree structures to represent part-whole hierarchies. It allows clients to treat individual objects (leaves) and compositions of objects (composites) uniformly through a common interface.
FileSystemComponent).File).Directory).// Component: Common interface for both leaf and composite objects
interface FileSystemComponent {
void showDetails();
}
// Leaf: Represents individual objects
class File implements FileSystemComponent {
private String name;
public File(String name) {
this.name = name;
}
public void showDetails() {
System.out.println("File: " + name);
}
}
// Composite: Represents containers that can hold other components
class Directory implements FileSystemComponent {
private String name;
private List<FileSystemComponent> components;
public Directory(String name) {
this.name = name;
components = new ArrayList<>();
}
public void addComponent(FileSystemComponent component) {
components.add(component);
}
public void removeComponent(FileSystemComponent component) {
components.remove(component);
}
public void showDetails() {
System.out.println("Directory: " + name);
for (FileSystemComponent component : components) {
component.showDetails();
}
}
}
// Usage
public class CompositeExample {
public static void main(String[] args) {
FileSystemComponent file1 = new File("document.txt");
FileSystemComponent file2 = new File("image.jpg");
FileSystemComponent subdirectory = new Directory("documents");
FileSystemComponent directory = new Directory("root");
((Directory) subdirectory).addComponent(file1);
((Directory) directory).addComponent(file2);
((Directory) directory).addComponent(subdirectory);
directory.showDetails();
}
}