Scribd
Upload
565 views1 page

SOLID Principles

The SOLID principles are a set of five design principles for writing maintainable and scalable object-oriented code. The SOLID acronym stands for Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. Following these principles helps developers create software that is easier to maintain, extend, and refactor through high modularity, flexibility, and robustness.

Uploaded by

Sampath Kumar Chindirala
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
565 views1 page

SOLID Principles

The SOLID principles are a set of five design principles for writing maintainable and scalable object-oriented code. The SOLID acronym stands for Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. Following these principles helps developers create software that is easier to maintain, extend, and refactor through high modularity, flexibility, and robustness.

Uploaded by

Sampath Kumar Chindirala
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 1

The SOLID principles are a set of five design principles for writing maintainable and

scalable software. These principles were introduced by Robert C. Martin and are widely
used in object-oriented programming to create more robust and flexible code. The
SOLID acronym stands for:

1. Single Responsibility Principle (SRP): This principle states that a class should
have only one reason to change. In other words, a class should have only one
responsibility or job. By adhering to this principle, you can make your code more
maintainable because changes to one aspect of the software won't affect other
unrelated parts.
2. Open/Closed Principle (OCP): This principle emphasizes that software entities
(classes, modules, functions, etc.) should be open for extension but closed for
modification. Instead of altering existing code, you should be able to extend its
behavior through inheritance, composition, or interfaces.
3. Liskov Substitution Principle (LSP): Named after Barbara Liskov, this principle
states that objects of a derived class should be able to replace objects of the base
class without affecting the correctness of the program. In essence, it ensures that
subtypes are substitutable for their base types without causing unexpected
behavior.
4. Interface Segregation Principle (ISP): This principle suggests that clients should
not be forced to depend on interfaces they do not use. In other words, it's better
to have smaller, focused interfaces rather than large, monolithic ones. This
promotes a more granular and flexible design.
5. Dependency Inversion Principle (DIP): This principle advocates that high-level
modules should not depend on low-level modules, but both should depend on
abstractions. It also suggests that abstractions should not depend on details, but
details should depend on abstractions. In practical terms, this means using
interfaces or abstract classes to decouple high-level and low-level components,
which makes the code more adaptable to changes.

By following the SOLID principles, developers can create software that is easier to
maintain, extend, and refactor. These principles help in achieving a high degree of
modularity, flexibility, and robustness in software design.

You might also like