Abstract Factory Pattern
A creational design pattern that provides an interface for creating families of related or dependent objects without specifying their …
Object-Oriented-Design
Abstraction
A fundamental programming principle that hides complex implementation details behind simplified interfaces, allowing developers to work with …
Adapter Pattern
A structural design pattern that converts the interface of a class into another interface that clients expect, enabling incompatible …
Bridge Pattern
A structural design pattern that decouples an abstraction from its implementation so that the two can vary independently.
Builder Pattern
A creational design pattern that separates the construction of a complex object from its representation, allowing the same construction …
Chain of Responsibility Pattern
A behavioral design pattern that passes a request along a chain of handlers, where each handler decides whether to process the request or …
Command Pattern
A behavioral design pattern that encapsulates a request as an object, allowing parameterization of clients with different requests, queuing, …
Composite Pattern
A structural design pattern that composes objects into tree structures to represent part-whole hierarchies, letting clients treat individual …
Composition Over Inheritance
A design principle that favors object composition over class inheritance for code reuse, resulting in more flexible and maintainable …
Decorator Pattern
A structural design pattern that attaches additional responsibilities to an object dynamically, providing a flexible alternative to …
Dependency Inversion Principle (DIP)
A SOLID design principle stating that high-level modules should not depend on low-level modules, and both should depend on abstractions.
Encapsulation
A fundamental object-oriented programming principle that bundles data and the methods that operate on that data within a single unit, …
Facade Pattern
A structural design pattern that provides a simplified interface to a complex subsystem, reducing the coupling between clients and subsystem …
Factory Method Pattern
A creational design pattern that defines an interface for creating objects but lets subclasses decide which class to instantiate.
Flyweight Pattern
A structural design pattern that uses sharing to support large numbers of fine-grained objects efficiently by externalizing shared state.
Inheritance and Polymorphism
Core object-oriented programming mechanisms: inheritance creates class hierarchies for code reuse, while polymorphism enables objects of …
Interface Segregation Principle (ISP)
A SOLID design principle stating that no client should be forced to depend on methods it does not use, favoring small, specific interfaces …
Interpreter Pattern
A behavioral design pattern that defines a representation for a language's grammar and provides an interpreter to evaluate sentences in that …
Iterator Pattern
A behavioral design pattern that provides a way to access elements of an aggregate object sequentially without exposing its underlying …
Law of Demeter
A design guideline for developing software, particularly object-oriented programs, that promotes loose coupling by restricting the set of …
Liskov Substitution Principle (LSP)
A SOLID design principle stating that objects of a supertype should be replaceable with objects of a subtype without altering the …
Mediator Pattern
A behavioral design pattern that defines an object that encapsulates how a set of objects interact, promoting loose coupling by preventing …
Memento Pattern
A behavioral design pattern that captures and externalizes an object's internal state so it can be restored later, without violating …
Observer Pattern
A behavioral design pattern that defines a one-to-many dependency between objects so that when one object changes state, all its dependents …
Open-Closed Principle (OCP)
A SOLID design principle stating that software entities should be open for extension but closed for modification.
Prototype Pattern
A creational design pattern that creates new objects by cloning an existing instance, avoiding the cost of standard construction.
Proxy Pattern
A structural design pattern that provides a surrogate or placeholder for another object to control access to it.
Single Responsibility Principle (SRP)
A SOLID design principle stating that a class should have only one reason to change, meaning it should encapsulate exactly one …
Singleton Pattern
A creational design pattern that ensures a class has only one instance and provides a global point of access to it.
SOLID Principles
Five foundational object-oriented design principles that promote maintainable, flexible, and understandable software: Single Responsibility, …
State Pattern
A behavioral design pattern that allows an object to alter its behavior when its internal state changes, appearing to change its class.
Strategy Pattern
A behavioral design pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable at runtime.
Template Method Pattern
A behavioral design pattern that defines the skeleton of an algorithm in a base class, letting subclasses override specific steps without …
Visitor Pattern
A behavioral design pattern that lets you add new operations to existing object structures without modifying the classes of the elements on …