By Ali Moradi AliDeWeb
- Encapsulation – Bundling data and methods within a class while restricting direct access to some details.
- Abstraction – Hiding complex implementation details and exposing only the necessary functionality.
- Inheritance – Allowing a class to inherit properties and behaviors from another class to promote code reuse.
- Polymorphism – Enabling multiple classes to be treated as instances of a common superclass, allowing method overriding and dynamic behavior.
- Single Responsibility Principle (SRP) – A class should have only one reason to change, meaning it should have only one responsibility.
- Open/Closed Principle (OCP) – Software entities should be open for extension but closed for modification.
- Liskov Substitution Principle (LSP) – Subtypes must be substitutable for their base types without altering the correctness of the program.
- Interface Segregation Principle (ISP) – Clients should not be forced to depend on interfaces they do not use.
- Dependency Inversion Principle (DIP) – High-level modules should not depend on low-level modules; both should depend on abstractions.
Apart from SOLID, other key design principles in OOP include:
- DRY (Don’t Repeat Yourself) – Avoid duplication by abstracting reusable code.
- KISS (Keep It Simple, Stupid) – Keep code simple and avoid unnecessary complexity.
- YAGNI (You Ain’t Gonna Need It) – Don’t implement features unless absolutely necessary.
- Law of Demeter (LoD) – Objects should only interact with closely related objects to reduce coupling.
These principles ensure maintainability, scalability, and clean code.
| Design Pattern | Documentation |
|---|---|
| Memento | 📜 README |
| State | 📜 README |
| Iterator | 📜 README |
| Strategy | 📜 README |
| Template Method | 📜 README |
| Command | 📜 README |