SOLID


S - Single Responsibility Principle
  |
O - Open/Closed Principle
  |
L - Liskov Substitution Principle
  |
I - Interface Segregation Principle
  |
D - Dependency Inversion Principle

SOLID is an acronym for five principles of object-oriented design that were first introduced by software developer Robert C. Martin. The five principles are:

Single Responsibility Principle - This principle states that every class should have a single, well-defined responsibility, and that the class should be responsible for only one thing. This means that a class should not have multiple, unrelated responsibilities, and that it should be designed to do one thing well.
Open/Closed Principle - This principle states that a class should be open for extension, but closed for modification. This means that a class should be designed in such a way that it can be extended and customized without changing its existing code.
Liskov Substitution Principle - This principle states that subtypes should be substitutable for their base types. This means that a subtype should be able to be used in any context where its base type is expected, and that it should not violate the behavior or expectations of the base type.
Interface Segregation Principle - This principle states that clients should not be forced to depend on methods that they do not use. This means that interfaces should be designed in such a way that clients only have to implement the methods that they need, and that they are not forced to implement unused or unnecessary methods.
Dependency Inversion Principle - This principle states that high-level modules should not depend on low-level modules, but rather that both should depend on abstractions. This means that modules should be designed in such a way that they do not depend on the details of other modules, but rather that they depend on abstractions that are independent of the details of the other modules.

Overall, the SOLID principles are a set of guidelines and best practices for object-oriented design that are intended to help developers write high-quality, maintainable, and scalable code. These principles are widely used in software development, and are considered to be an essential part of good software design.